diff --git a/src/pretalx/orga/templates/orga/cfp/flow.html b/src/pretalx/orga/templates/orga/cfp/flow.html
index e280b5a1af..6d578c30a2 100644
--- a/src/pretalx/orga/templates/orga/cfp/flow.html
+++ b/src/pretalx/orga/templates/orga/cfp/flow.html
@@ -6,9 +6,7 @@
 
 {% block stylesheets %}
     <link rel="stylesheet" type="text/css" href="{% static "common/css/headers-uncompressed.css" %}" />
-    {% compress css %}
-        <link rel="stylesheet" href="{% static "orga/css/flow.css" %}">
-    {% endcompress %}
+    <link rel="stylesheet" href='{% static "orga/css/flow.css" %}'>
 {% endblock stylesheets %}
 
 {% block scripts %}
diff --git a/src/pretalx/static/orga/css/flow.css b/src/pretalx/static/orga/css/flow.css
index a1158225a7..a8f796c1e0 100644
--- a/src/pretalx/static/orga/css/flow.css
+++ b/src/pretalx/static/orga/css/flow.css
@@ -4,6 +4,7 @@
   position: relative;
   user-select: none;
   margin-right: 270px;
+  width: 100%;
 
   #steps {
     display: flex;
@@ -103,7 +104,7 @@
   margin-bottom: 0;
   bottom: 1px;
   left: 250px;
-  right: 0;
+  right: 250px;
   box-shadow: var(--shadow-dialog);
   button {
     margin-left: auto;
diff --git a/src/pretalx/static/orga/js/cfp_flow.js b/src/pretalx/static/orga/js/cfp_flow.js
index 315f1803e7..3ea60bd8e2 100644
--- a/src/pretalx/static/orga/js/cfp_flow.js
+++ b/src/pretalx/static/orga/js/cfp_flow.js
@@ -30,7 +30,7 @@ var api = {
 }
 
 let currentLanguage = "en"
-let currentModal = Vue.observable({
+let currentModal = Vue.reactive({
     type: null,
     data: null,
     show: false,
@@ -58,15 +58,17 @@ document.onclick = (event) => {
         currentModal.data = null
     }
 }
-document.onkeypress = (event) => {
+document.onkeydown = (event) => {
     if (!currentModal.data) return
     let isEscape = false
-    if ("key" in evt) {
-        isEscape = evt.key === "Escape" || evt.key === "Esc"
+    if ("key" in event) {
+        isEscape = event.key === "Escape" || event.key === "Esc"
     } else {
-        isEscape = evt.keyCode === 27
+        isEscape = event.keyCode === 27
+    }
+    if (isEscape) {
+        currentModal.data = null
     }
-    currentModal.data = null
 }
 
 function areEqual() {
@@ -127,63 +129,138 @@ function areEqual() {
     return true
 }
 
-Vue.component("field", {
-    template: `
-    <div>
-      <h2 v-if="isModal" class="mb-4">Change input field</h2>
-      <div :class="['form-group', 'row', field.field_source].concat(isModal ? '' : 'editable')" v-bind:style="style" @click.stop="makeModal" v-if="!(isModal && isQuestion)">
-      <label class="col-md-3 col-form-label pt-0">
-        <template v-if="field.widget !== 'CheckboxInput'">
-          <template v-if="isModal">
-            <div class="i18n-form-group mb-2 title-input" @click.stop="">
-              <input type="text" class="form-control" :title="locale" :lang="locale" v-model="field.label[locale]" v-for="locale in locales">
-            </div>
-          </template>
-          <template v-else>
-            {{ field.label[currentLanguage] }}
-            <br>
-          </template>
-          <template v-if="isModal && editRequirement">
-            <span v-if="!field.required & !field.hard_required" :class="[editable ? 'editable' : '', 'optional']" @click.stop="field.required=true">Optional</span>
-            <span v-else-if="!field.hard_required" :class="[editable ? 'editable' : '', 'optional']" @click.stop="field.required=false"><strong>Required</strong></span>
-            <span v-else class="optional"><strong>Required</strong></span>
-          </template>
-          <template v-else>
-            <span v-if="!field.required" class="optional">Optional</span>
-            <span v-else class="optional"><strong>Required</strong></span>
-          </template>
-        </template>
-      </label>
-      <div class="col-md-9">
-        <input class="form-control" type="text" :placeholder="field.title" readonly disabled v-if="field.widget === 'TextInput' || field.widget === 'NumberInput' || field.widget === 'EmailInput'">
-        <select class="form-control" type="text" :placeholder="field.title" readonly disabled v-else-if="field.widget === 'Select'"></select>
-        <textarea class="form-control" type="text" :placeholder="field.title" readonly disabled v-else-if="field.widget === 'Textarea' || field.widget === 'MarkdownWidget'"></textarea>
-        <div class="form-check" v-else-if="field.widget === 'CheckboxInput'">
-          <input type="checkbox" class="form-check-input">
-          <label class="form-check-label">{{ field.label[currentLanguage] }}</label>
-        </div>
-        <div class="row bootstrap4-multi-input" v-else-if="field.widget === 'ClearableFileInput'">
-          <div class="col-12"><input type="file"></div>
-        </div>
-
-        <template v-if="!isModal">
-          <div class="text-muted" v-if="display_help_text" v-html="display_help_text"></div>
-        </template>
-        <template v-else>
-          <div class="i18n-form-group" @click.stop="">
-            <input type="text" class="form-control" :title="locale" :lang="locale" v-model="field.help_text[locale]" v-for="locale in locales">
-          </div>
-          <div class="text-muted" v-if="fixed_help_text">{{ fixed_help_text }}</div>
-        </template>
-      </div>
-      </div>
-      <div v-else>
-        <p>
-          This is a custom question you added to the CfP. You can change or remove this CfP question <a :href="questionUrl">here</a>.
-        </p>
-      </div>
-    </div>
-  `,
+const FieldComponent = {
+    render() {
+    const h = Vue.h;
+        const isQuestion = this.field.key.startsWith("question_");
+        const questionUrl = window.location.pathname.replace(
+            "flow/",
+            this.field.key.replace("question_", "questions/")
+        ) + "/edit";
+        const displayHelpText = isQuestion ? 
+            marked.parse(this.fixed_help_text, markedOptions) :
+            marked.parse(
+                this.field.help_text[currentLanguage] + " " + this.fixed_help_text,
+                markedOptions
+            );
+        const labelContent = [];
+        if (this.field.widget !== 'CheckboxInput') {
+            if (this.isModal) {
+                labelContent.push(
+                    h('div', { class: 'i18n-form-group mb-2 title-input', onClick: (e) => e.stopPropagation() }, 
+                        this.locales.map(locale => 
+                            h('input', {
+                                type: 'text',
+                                class: 'form-control',
+                                title: locale,
+                                lang: locale,
+                                value: this.field.label[locale],
+                                onInput: (e) => { this.field.label[locale] = e.target.value; }
+                            })
+                        )
+                    )
+                );
+                // Requirement editing logic
+                if (this.editRequirement) {
+                    if (!this.field.required && !this.field.hard_required) {
+                        labelContent.push(
+                            h('span', {
+                                class: this.editable ? 'editable optional' : 'optional',
+                                onClick: (e) => { e.stopPropagation(); this.field.required = true; }
+                            }, 'Optional')
+                        );
+                    } else if (!this.field.hard_required) {
+                        labelContent.push(
+                            h('span', {
+                                class: this.editable ? 'editable optional' : 'optional',
+                                onClick: (e) => { e.stopPropagation(); this.field.required = false; }
+                            }, [h('strong', 'Required')])
+                        );
+                    } else {
+                        labelContent.push(h('span', { class: 'optional' }, [h('strong', 'Required')]));
+                    }
+                }
+            } else {
+                labelContent.push(
+                    h('span', {
+                        class: this.editable ? 'editable' : '',
+                        onClick: (e) => {
+                            e.stopPropagation();
+                            if (this.editable) {
+                                currentModal.data = this.field;
+                                currentModal.type = 'field';
+                                currentModal.show = true;
+                            }
+                        }
+                    }, this.field.label[this.currentLanguage]),
+                    h('br'),
+                    !this.field.required ?
+                        h('span', { class: 'optional' }, 'Optional') :
+                        h('span', { class: 'optional' }, [h('strong', 'Required')])
+                );
+            }
+        }
+        const fieldInput = this.getFieldInput(h);
+        // Help text content
+        let helpTextContent;
+        if (this.isModal) {
+            helpTextContent = [
+                h('div', { class: 'i18n-form-group', onClick: (e) => e.stopPropagation() },
+                    this.locales.map(locale =>
+                        h('input', {
+                            type: 'text',
+                            class: 'form-control',
+                            title: locale,
+                            lang: locale,
+                            value: this.field.help_text[locale],
+                            onInput: (e) => { this.field.help_text[locale] = e.target.value; }
+                        })
+                    )
+                ),
+                this.fixed_help_text ? h('div', { class: 'text-muted' }, this.fixed_help_text) : null
+            ];
+        } else {
+            helpTextContent = h('div', {
+                class: 'text-muted',
+                innerHTML: this.display_help_text
+            });
+        }
+        if (this.isModal && isQuestion) {
+            return h('div', [
+                h('h2', { class: 'mb-4' }, 'Change input field'),
+                h('p', [
+                    'This is a custom question you added to the CfP. You can change or remove this CfP question ',
+                    h('a', { href: questionUrl }, 'here'),
+                    '.'
+                ])
+            ]);
+        }
+        const mainContent = h('div', {
+            class: ['form-group', 'row', this.field.field_source].concat(this.isModal ? '' : 'editable'),
+            style: this.style,
+            onClick: (e) => {
+                e.stopPropagation();
+                this.makeModal(e);
+            }
+        }, [
+            h('label', { class: 'col-md-3 col-form-label pt-0' }, 
+                this.field.widget === 'CheckboxInput' ? [
+                    h('div', { class: 'form-check' }, [
+                        h('input', { type: 'checkbox', class: 'form-check-input' }),
+                        h('label', { class: 'form-check-label' }, this.field.label[this.currentLanguage])
+                    ])
+                ] : labelContent
+            ),
+            h('div', { class: 'col-md-9' }, [
+                fieldInput,
+                helpTextContent
+            ])
+        ]);
+        return h('div', [
+            this.isModal ? h('h2', { class: 'mb-4' }, 'Change input field') : null,
+            mainContent
+        ]);
+    },
     data() {
         return {
             editRequirement: false,
@@ -231,7 +308,7 @@ Vue.component("field", {
         makeModal(event) {
             if (this.isModal) return
             if (!this.isModal && !this.editable) {
-                Vue.set(currentModal, "data", null)
+                currentModal.data = null
                 currentModal.type = null
                 currentModal.show = false
             } else {
@@ -240,6 +317,72 @@ Vue.component("field", {
                 currentModal.show = true
             }
         },
+        getFieldInput(h) {
+            switch (this.field.widget) {
+                case 'TextInput':
+                case 'NumberInput':
+                case 'EmailInput':
+                    return h('input', { 
+                        class: 'form-control', 
+                        type: 'text', 
+                        placeholder: this.field.title,
+                        readonly: true,
+                        disabled: true
+                    });
+                case 'Select':
+                    return h('select', { 
+                        class: 'form-control', 
+                        type: 'text', 
+                        placeholder: this.field.title,
+                        readonly: true,
+                        disabled: true
+                    });
+                case 'Textarea':
+                case 'MarkdownWidget':
+                    return h('textarea', { 
+                        class: 'form-control', 
+                        type: 'text', 
+                        placeholder: this.field.title,
+                        readonly: true,
+                        disabled: true,
+                        style: { height: '2.5em' }
+                    });
+                case 'CheckboxInput':
+                    return null; // Handled in label
+                case 'ClearableFileInput':
+                    return h('div', { class: 'row bootstrap4-multi-input' }, [
+                        h('div', { class: 'col-12' }, [
+                            h('input', { type: 'file' })
+                        ])
+                    ]);
+                default:
+                    return null;
+            }
+        },
+        getHelpTextContent(h, displayHelpText) {
+            if (this.isModal) {
+                return [
+                    h('div', { class: 'i18n-form-group', onClick: (e) => e.stopPropagation() }, 
+                        this.locales.map(locale => 
+                            h('input', {
+                                type: 'text',
+                                class: 'form-control',
+                                title: locale,
+                                lang: locale,
+                                modelValue: this.field.help_text[locale],
+                                onInput: (e) => { this.field.help_text[locale] = e.target.value; }
+                            })
+                        )
+                    ),
+                    this.fixed_help_text ? h('div', { class: 'text-muted' }, this.fixed_help_text) : null
+                ];
+            } else {
+                return h('div', { 
+                    class: 'text-muted',
+                    innerHTML: this.display_help_text
+                });
+            }
+        }
     },
     created() {
         this.fixed_help_text = this.field.full_help_text.replace(
@@ -247,70 +390,123 @@ Vue.component("field", {
             "",
         )
     },
-})
+}
 
-Vue.component("step", {
-    template: `
-    <div class="step" @click="editingTitle = false; editingText = false">
-      <div :class="['step-header', 'header', eventConfiguration.header_pattern]" :style="headerStyle">
-        <img :src="eventConfiguration.header_image" v-if="eventConfiguration.header_image">
-      </div>
-      <div class="step-main-container">
-        <div class="submission-steps stages">
-          <span :class="['step', 'step-' + stp.phase]" v-for="stp in headerSteps">
-              <div class="step-icon">
-                  <span :class="['fa', 'fa-' + stp.icon]"></span>
-              </div>
-              <div class="step-label">
-                  {{ stp.label }}
-              </div>
-          </span>
-        </div>
-        <h2 class="edit-container">
-          <span v-if="!editingTitle" :class="[editable ? 'editable' : '']" @click.stop="editTitle">{{ step.title[currentLanguage] || '…' }}</span>
-          <span v-else>
-          <div class="col-md-9"><div class="i18n-form-group" @click.stop="">
-            <input type="text" class="form-control" :title="locale" :lang="locale" v-model="step.title[locale]" v-for="locale in locales">
-          </div></div>
-          </span>
-        </h2>
-        <div class="edit-container">
-          <span v-if="!editingText" :class="[editable ? 'editable' : '']" @click.stop="editText" v-html="marked(step.text[currentLanguage] || '…')"></span>
-          <span v-else @click.stop="">
-            <div class="col-md-9"><div class="i18n-form-group">
-              <textarea type="text" class="form-control" :title="locale" :lang="locale" v-model="step.text[locale]" v-for="locale in locales"></textarea>
-            </div></div>
-          </span>
-        </div>
-        <form v-if="step.identifier != 'user'">
-          <field :field="field" v-for="field in step.fields" :key="field.key" :locales="locales" v-if="field.widget !== 'HiddenInput'">
-          </field>
-        </form>
-        <form v-else id="auth-form">
-          <div class="auth-form-block">
-            <h4 class="text-center">I already have an account</h4>
-            <div class="form-group"><input type="text" class="form-control" placeholder="Email address" readonly disabled></div>
-            <div class="form-group"><input type="password" class="form-control" placeholder="Password" readonly disabled></div>
-            <button type="submit" class="btn btn-lg btn-success btn-block" disabled>Log in</button>
-          </div>
-          <div class="auth-form-block">
-            <h4 class="text-center">I need a new account</h4>
-            <div class="form-group"><input type="text" class="form-control" placeholder="Name" readonly disabled></div>
-            <div class="form-group"><input type="text" class="form-control" placeholder="Email address" readonly disabled></div>
-            <div class="form-group"><input type="password" class="form-control" placeholder="Password" readonly disabled></div>
-            <div class="form-group"><input type="password" class="form-control" placeholder="Password (again)" readonly disabled></div>
-            <button type="submit" class="btn btn-lg btn-info btn-block" disabled>Register</button>
-            <div class="overlay">
-              This form cannot be modified – a page to login or register needs to be in place, but you can change the page title and description.
-            </div>
-          </div>
-        </form>
-        <div v-if="step.identifier == 'questions'" class="alert alert-info">
-          This step will only be shown if you have questions configured.
-        </div>
-      </div>
-    </div>
-  `,
+const StepComponent = {
+    render() {
+    const h = Vue.h;
+    const headerSteps = this.headerSteps;
+    const stepPosition = this.stepPosition;
+    const titleContent = this.editingTitle ? 
+            h('span', { onClick: (e) => e.stopPropagation() }, [
+                h('div', { class: 'col-md-9' }, [
+                    h('div', { class: 'i18n-form-group', onClick: (e) => e.stopPropagation() }, 
+                        this.locales.map(locale => 
+                            h('input', {
+                                type: 'text',
+                                class: 'form-control',
+                                title: locale,
+                                lang: locale,
+                                value: this.step.title[locale],
+                                onInput: (e) => { this.step.title[locale] = e.target.value; }
+                            })
+                        )
+                    )
+                ])
+            ]) :
+            h('span', {
+                class: this.editable ? 'editable' : '',
+                onClick: (e) => {
+                    if (this.editable) {
+                        e.stopPropagation();
+                        this.editingTitle = true;
+                    }
+                }
+            }, this.step.title[this.currentLanguage] || '…');
+        const textContent = this.editingText ?
+            h('span', { onClick: (e) => e.stopPropagation() }, [
+                h('div', { class: 'col-md-9' }, [
+                    h('div', { class: 'i18n-form-group' }, 
+                        this.locales.map(locale => 
+                            h('textarea', {
+                                class: 'form-control',
+                                title: locale,
+                                lang: locale,
+                                value: this.step.text[locale],
+                                onInput: (e) => { this.step.text[locale] = e.target.value; },
+                                style: { height: '2.5em' }
+                            })
+                        )
+                    )
+                ])
+            ]) :
+            h('span', {
+                class: this.editable ? 'editable' : '',
+                onClick: (e) => {
+                    if (this.editable) {
+                        e.stopPropagation();
+                        this.editingText = true;
+                    }
+                },
+                innerHTML: this.marked(this.step.text[this.currentLanguage] || '…')
+            });
+        const fieldComponent = Vue.resolveComponent('field');
+        const formContent = this.step.identifier !== 'user' ? 
+            h('form', 
+                this.step.fields.filter(field => field && field.widget !== 'HiddenInput').map(field => {
+                    return h(fieldComponent, { 
+                        field: field,
+                        locales: this.locales,
+                        key: field.key
+                    });
+                })
+            ) :
+            h('form', { id: 'auth-form' }, [
+                h('div', { class: 'auth-form-block' }, [
+                    h('h4', { class: 'text-center' }, 'I already have an account'),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'text', class: 'form-control', placeholder: 'Email address', readonly: true, disabled: true })]),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'password', class: 'form-control', placeholder: 'Password', readonly: true, disabled: true })]),
+                    h('button', { type: 'submit', class: 'btn btn-lg btn-success btn-block', disabled: true }, 'Log in')
+                ]),
+                h('div', { class: 'auth-form-block' }, [
+                    h('h4', { class: 'text-center' }, 'I need a new account'),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'text', class: 'form-control', placeholder: 'Name', readonly: true, disabled: true })]),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'text', class: 'form-control', placeholder: 'Email address', readonly: true, disabled: true })]),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'password', class: 'form-control', placeholder: 'Password', readonly: true, disabled: true })]),
+                    h('div', { class: 'form-group' }, [h('input', { type: 'password', class: 'form-control', placeholder: 'Password (again)', readonly: true, disabled: true })]),
+                    h('button', { type: 'submit', class: 'btn btn-lg btn-info btn-block', disabled: true }, 'Register'),
+                    h('div', { class: 'overlay' }, 'This form cannot be modified – a page to login or register needs to be in place, but you can change the page title and description.')
+                ])
+            ]);
+        const questionAlert = this.step.identifier === 'questions' ? 
+            h('div', { class: 'alert alert-info' }, 'This step will only be shown if you have questions configured.') : 
+            null;
+        return h('div', { class: 'step', onClick: () => { this.editingTitle = false; this.editingText = false; } }, [
+            h('div', { 
+                class: ['step-header', 'header', this.eventConfiguration.header_pattern],
+                style: this.headerStyle
+            }, this.eventConfiguration.header_image ? 
+                h('img', { src: this.eventConfiguration.header_image }) : 
+                null
+            ),
+            h('div', { class: 'step-main-container' }, [
+                h('div', { class: 'submission-steps stages' }, 
+                    headerSteps.map(stp => 
+                        h('span', { class: ['step', 'step-' + stp.phase] }, [
+                            h('div', { class: 'step-icon' }, 
+                                h('span', { class: ['fa', 'fa-' + stp.icon] })
+                            ),
+                            h('div', { class: 'step-label' }, stp.label)
+                        ])
+                    )
+                ),
+                h('h2', { class: 'edit-container' }, titleContent),
+                h('div', { class: 'edit-container' }, textContent),
+                formContent,
+                questionAlert
+            ])
+        ]);
+    },
     data() {
         return {
             editingTitle: false,
@@ -376,54 +572,86 @@ Vue.component("step", {
             return result
         },
     },
-})
+}
 
-var app = new Vue({
-    el: "#flow",
-    template: `
-    <div :class="currentModal.data ? 'defocused' : 'focused'" :style="{'--color': eventConfiguration.primary_color || '#2185d0'}">
-      <div id="flow-modal" v-if="currentModal.data">
-        <form>
-          <field :field="currentModal.data" :isModal="true" key="modal" :locales="locales"></field>
-        </form>
-      </div>
-      <div id="flow">
-        <div id="loading" v-if="loading">
-            <i class="fa fa-spinner fa-pulse fa-4x fa-fw text-primary mb-4 mt-4"></i>
-            <h3 class="mt-2 mb-4">Loading talks, please wait.</h3>
-        </div>
-        <div id="steps" v-else>
-          <step v-for="step in stepsConfiguration" :step="step" :eventConfiguration="eventConfiguration" :key="step.identifier" :steps="stepsConfiguration" :locales="locales">
-          </step>
-        </div>
-      </div>
-      <div id="unassigned-group" class="d-none">
-        <div class="step-header" ref="stepHeader"></div>
-        <div id='unassigned-fields'>
-          <div class="input-group">
-            <div class="input-group-prepend input-group-text"><i class="fa fa-search"></i></div>
-            <input type="text" class="form-control" placeholder="Search..." v-model="search">
-          </div>
-          <div id="unassigned-container" ref="unassigned">
-              <field v-for="field in filteredFields" :field="field" :key="field.id"></field>
-          </div>
-        </div>
-      </div>
-      <div id="dirty-flow" class="alert alert-warning" v-if="configurationChanged">
-        <span>
-          Unsaved configuration changes!
-        </span>
-        <button class="btn btn-success" @click="save" :disabled="saving">
-          <span v-if="saving">
-            <i class="fa fa-spinner fa-pulse fa-fw text-success mb-2 mt-2"></i>
-          </span>
-          <span v-else>
-            Save now
-          </span>
-        </button>
-      </div>
-    </div>
-  `,
+const app = Vue.createApp({
+    render() {
+        const h = Vue.h;
+        const stepComponent = Vue.resolveComponent('step');
+        const fieldComponent = Vue.resolveComponent('field');
+        const modalContent = currentModal.data ? 
+            h('div', { id: 'flow-modal' }, [
+                h('form', [
+                    h(fieldComponent, { 
+                        field: currentModal.data,
+                        isModal: true,
+                        key: 'modal',
+                        locales: this.locales
+                    })
+                ])
+            ]) : null;
+        const loadingContent = this.loading ?
+            h('div', { id: 'loading' }, [
+                h('i', { class: 'fa fa-spinner fa-pulse fa-4x fa-fw text-primary mb-4 mt-4' }),
+                h('h3', { class: 'mt-2 mb-4' }, 'Loading talks, please wait.')
+            ]) :
+            h('div', { id: 'steps' }, 
+                this.stepsConfiguration.map(step => {
+                    return h(stepComponent, {
+                        step: step,
+                        eventConfiguration: this.eventConfiguration,
+                        key: step.identifier,
+                        steps: this.stepsConfiguration,
+                        locales: this.locales
+                    });
+                })
+            );
+        const unassignedContent = h('div', { id: 'unassigned-group', class: 'd-none' }, [
+            h('div', { class: 'step-header', ref: 'stepHeader' }),
+            h('div', { id: 'unassigned-fields' }, [
+                h('div', { class: 'input-group' }, [
+                    h('div', { class: 'input-group-prepend input-group-text' }, 
+                        h('i', { class: 'fa fa-search' })
+                    ),
+                    h('input', {
+                        type: 'text',
+                        class: 'form-control',
+                        placeholder: 'Search...',
+                        value: this.search,
+                        onInput: (e) => { this.search = e.target.value; }
+                    })
+                ]),
+                h('div', { id: 'unassigned-container', ref: 'unassigned' }, 
+                    this.filteredFields.map(field => {
+                        return h(fieldComponent, { field: field, key: field.id });
+                    })
+                )
+            ])
+        ]);
+        const dirtyFlowContent = this.configurationChanged ?
+            h('div', { id: 'dirty-flow', class: 'alert alert-warning' }, [
+                h('span', 'Unsaved configuration changes!'),
+                h('button', {
+                    class: 'btn btn-success',
+                    onClick: this.save,
+                    disabled: this.saving
+                }, this.saving ? 
+                    h('span', [
+                        h('i', { class: 'fa fa-spinner fa-pulse fa-fw text-success mb-2 mt-2' })
+                    ]) : 
+                    h('span', 'Save now')
+                )
+            ]) : null;
+        return h('div', {
+            class: currentModal.data ? 'defocused' : 'focused',
+            style: { '--color': this.eventConfiguration.primary_color || '#2185d0' }
+        }, [
+            modalContent,
+            h('div', { id: 'flow' }, loadingContent),
+            unassignedContent,
+            dirtyFlowContent
+        ]);
+    },
     data() {
         return {
             steps: null,
@@ -488,3 +716,7 @@ var app = new Vue({
         },
     },
 })
+
+app.component("field", FieldComponent)
+app.component("step", StepComponent)
+app.mount("#flow")
diff --git a/src/pretalx/static/vendored/vue.js b/src/pretalx/static/vendored/vue.js
index 4ef7ff1b0a..a44287e4c7 100644
--- a/src/pretalx/static/vendored/vue.js
+++ b/src/pretalx/static/vendored/vue.js
@@ -1,11944 +1,18193 @@
-/*!
- * Vue.js v2.6.10
- * (c) 2014-2019 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 = 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
-  }
-
-  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 (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()
+/**
+* vue v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/
+var Vue = (function (exports) {
+  'use strict';
+
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function makeMap(str) {
+    const map = /* @__PURE__ */ Object.create(null);
+    for (const key of str.split(",")) map[key] = 1;
+    return (val) => val in map;
+  }
+
+  const EMPTY_OBJ = Object.freeze({}) ;
+  const EMPTY_ARR = Object.freeze([]) ;
+  const NOOP = () => {
+  };
+  const NO = () => false;
+  const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+  (key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
+  const isModelListener = (key) => key.startsWith("onUpdate:");
+  const extend = Object.assign;
+  const remove = (arr, el) => {
+    const i = arr.indexOf(el);
+    if (i > -1) {
+      arr.splice(i, 1);
+    }
+  };
+  const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
+  const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
+  const isArray = Array.isArray;
+  const isMap = (val) => toTypeString(val) === "[object Map]";
+  const isSet = (val) => toTypeString(val) === "[object Set]";
+  const isDate = (val) => toTypeString(val) === "[object Date]";
+  const isRegExp = (val) => toTypeString(val) === "[object RegExp]";
+  const isFunction = (val) => typeof val === "function";
+  const isString = (val) => typeof val === "string";
+  const isSymbol = (val) => typeof val === "symbol";
+  const isObject = (val) => val !== null && typeof val === "object";
+  const isPromise = (val) => {
+    return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
+  };
+  const objectToString = Object.prototype.toString;
+  const toTypeString = (value) => objectToString.call(value);
+  const toRawType = (value) => {
+    return toTypeString(value).slice(8, -1);
+  };
+  const isPlainObject = (val) => toTypeString(val) === "[object Object]";
+  const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key;
+  const isReservedProp = /* @__PURE__ */ makeMap(
+    // the leading comma is intentional so empty string "" is also included
+    ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"
+  );
+  const isBuiltInDirective = /* @__PURE__ */ makeMap(
+    "bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"
+  );
+  const cacheStringFunction = (fn) => {
+    const cache = /* @__PURE__ */ Object.create(null);
+    return (str) => {
+      const hit = cache[str];
+      return hit || (cache[str] = fn(str));
+    };
+  };
+  const camelizeRE = /-(\w)/g;
+  const camelize = cacheStringFunction(
+    (str) => {
+      return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : "");
+    }
+  );
+  const hyphenateRE = /\B([A-Z])/g;
+  const hyphenate = cacheStringFunction(
+    (str) => str.replace(hyphenateRE, "-$1").toLowerCase()
+  );
+  const capitalize = cacheStringFunction((str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
   });
-
-  /**
-   * 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)
+  const toHandlerKey = cacheStringFunction(
+    (str) => {
+      const s = str ? `on${capitalize(str)}` : ``;
+      return s;
     }
-
-    boundFn._length = fn.length;
-    return boundFn
+  );
+  const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
+  const invokeArrayFns = (fns, ...arg) => {
+    for (let i = 0; i < fns.length; i++) {
+      fns[i](...arg);
+    }
+  };
+  const def = (obj, key, value, writable = false) => {
+    Object.defineProperty(obj, key, {
+      configurable: true,
+      enumerable: false,
+      writable,
+      value
+    });
+  };
+  const looseToNumber = (val) => {
+    const n = parseFloat(val);
+    return isNaN(n) ? val : n;
+  };
+  const toNumber = (val) => {
+    const n = isString(val) ? Number(val) : NaN;
+    return isNaN(n) ? val : n;
+  };
+  let _globalThis;
+  const getGlobalThis = () => {
+    return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
+  };
+  function genCacheKey(source, options) {
+    return source + JSON.stringify(
+      options,
+      (_, val) => typeof val === "function" ? val.toString() : val
+    );
   }
 
-  function nativeBind (fn, ctx) {
-    return fn.bind(ctx)
-  }
+  const PatchFlagNames = {
+    [1]: `TEXT`,
+    [2]: `CLASS`,
+    [4]: `STYLE`,
+    [8]: `PROPS`,
+    [16]: `FULL_PROPS`,
+    [32]: `NEED_HYDRATION`,
+    [64]: `STABLE_FRAGMENT`,
+    [128]: `KEYED_FRAGMENT`,
+    [256]: `UNKEYED_FRAGMENT`,
+    [512]: `NEED_PATCH`,
+    [1024]: `DYNAMIC_SLOTS`,
+    [2048]: `DEV_ROOT_FRAGMENT`,
+    [-1]: `CACHED`,
+    [-2]: `BAIL`
+  };
 
-  var bind = Function.prototype.bind
-    ? nativeBind
-    : polyfillBind;
+  const slotFlagsText = {
+    [1]: "STABLE",
+    [2]: "DYNAMIC",
+    [3]: "FORWARDED"
+  };
 
-  /**
-   * 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];
+  const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol";
+  const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
+
+  const range = 2;
+  function generateCodeFrame(source, start = 0, end = source.length) {
+    start = Math.max(0, Math.min(start, source.length));
+    end = Math.max(0, Math.min(end, source.length));
+    if (start > end) return "";
+    let lines = source.split(/(\r?\n)/);
+    const newlineSequences = lines.filter((_, idx) => idx % 2 === 1);
+    lines = lines.filter((_, idx) => idx % 2 === 0);
+    let count = 0;
+    const res = [];
+    for (let i = 0; i < lines.length; i++) {
+      count += lines[i].length + (newlineSequences[i] && newlineSequences[i].length || 0);
+      if (count >= start) {
+        for (let j = i - range; j <= i + range || end > count; j++) {
+          if (j < 0 || j >= lines.length) continue;
+          const line = j + 1;
+          res.push(
+            `${line}${" ".repeat(Math.max(3 - String(line).length, 0))}|  ${lines[j]}`
+          );
+          const lineLength = lines[j].length;
+          const newLineSeqLength = newlineSequences[j] && newlineSequences[j].length || 0;
+          if (j === i) {
+            const pad = start - (count - (lineLength + newLineSeqLength));
+            const length = Math.max(
+              1,
+              end > count ? lineLength - pad : end - start
+            );
+            res.push(`   |  ` + " ".repeat(pad) + "^".repeat(length));
+          } else if (j > i) {
+            if (end > count) {
+              const length = Math.max(Math.min(end - count, lineLength), 1);
+              res.push(`   |  ` + "^".repeat(length));
+            }
+            count += lineLength + newLineSeqLength;
+          }
+        }
+        break;
+      }
     }
-    return ret
+    return res.join("\n");
   }
 
-  /**
-   * Mix properties into target object.
-   */
-  function extend (to, _from) {
-    for (var key in _from) {
-      to[key] = _from[key];
+  function normalizeStyle(value) {
+    if (isArray(value)) {
+      const res = {};
+      for (let i = 0; i < value.length; i++) {
+        const item = value[i];
+        const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item);
+        if (normalized) {
+          for (const key in normalized) {
+            res[key] = normalized[key];
+          }
+        }
+      }
+      return res;
+    } else if (isString(value) || isObject(value)) {
+      return value;
     }
-    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]);
+  const listDelimiterRE = /;(?![^(]*\))/g;
+  const propertyDelimiterRE = /:([^]+)/;
+  const styleCommentRE = /\/\*[^]*?\*\//g;
+  function parseStringStyle(cssText) {
+    const ret = {};
+    cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+      if (item) {
+        const tmp = item.split(propertyDelimiterRE);
+        tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
+      }
+    });
+    return ret;
+  }
+  function stringifyStyle(styles) {
+    if (!styles) return "";
+    if (isString(styles)) return styles;
+    let ret = "";
+    for (const key in styles) {
+      const value = styles[key];
+      if (isString(value) || typeof value === "number") {
+        const normalizedKey = key.startsWith(`--`) ? key : hyphenate(key);
+        ret += `${normalizedKey}:${value};`;
+      }
+    }
+    return ret;
+  }
+  function normalizeClass(value) {
+    let res = "";
+    if (isString(value)) {
+      res = value;
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        const normalized = normalizeClass(value[i]);
+        if (normalized) {
+          res += normalized + " ";
+        }
+      }
+    } else if (isObject(value)) {
+      for (const name in value) {
+        if (value[name]) {
+          res += name + " ";
+        }
       }
     }
-    return res
+    return res.trim();
+  }
+  function normalizeProps(props) {
+    if (!props) return null;
+    let { class: klass, style } = props;
+    if (klass && !isString(klass)) {
+      props.class = normalizeClass(klass);
+    }
+    if (style) {
+      props.style = normalizeStyle(style);
+    }
+    return props;
   }
 
-  /* 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 */
+  const HTML_TAGS = "html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot";
+  const SVG_TAGS = "svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view";
+  const MATH_TAGS = "annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics";
+  const VOID_TAGS = "area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr";
+  const isHTMLTag = /* @__PURE__ */ makeMap(HTML_TAGS);
+  const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
+  const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
+  const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
 
-  /**
-   * Return the same value.
-   */
-  var identity = function (_) { return _; };
+  const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+  const isSpecialBooleanAttr = /* @__PURE__ */ makeMap(specialBooleanAttrs);
+  const isBooleanAttr = /* @__PURE__ */ makeMap(
+    specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,hidden,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
+  );
+  function includeBooleanAttr(value) {
+    return !!value || value === "";
+  }
+  const isKnownHtmlAttr = /* @__PURE__ */ makeMap(
+    `accept,accept-charset,accesskey,action,align,allow,alt,async,autocapitalize,autocomplete,autofocus,autoplay,background,bgcolor,border,buffered,capture,challenge,charset,checked,cite,class,code,codebase,color,cols,colspan,content,contenteditable,contextmenu,controls,coords,crossorigin,csp,data,datetime,decoding,default,defer,dir,dirname,disabled,download,draggable,dropzone,enctype,enterkeyhint,for,form,formaction,formenctype,formmethod,formnovalidate,formtarget,headers,height,hidden,high,href,hreflang,http-equiv,icon,id,importance,inert,integrity,ismap,itemprop,keytype,kind,label,lang,language,loading,list,loop,low,manifest,max,maxlength,minlength,media,min,multiple,muted,name,novalidate,open,optimum,pattern,ping,placeholder,poster,preload,radiogroup,readonly,referrerpolicy,rel,required,reversed,rows,rowspan,sandbox,scope,scoped,selected,shape,size,sizes,slot,span,spellcheck,src,srcdoc,srclang,srcset,start,step,style,summary,tabindex,target,title,translate,type,usemap,value,width,wrap`
+  );
+  const isKnownSvgAttr = /* @__PURE__ */ makeMap(
+    `xmlns,accent-height,accumulate,additive,alignment-baseline,alphabetic,amplitude,arabic-form,ascent,attributeName,attributeType,azimuth,baseFrequency,baseline-shift,baseProfile,bbox,begin,bias,by,calcMode,cap-height,class,clip,clipPathUnits,clip-path,clip-rule,color,color-interpolation,color-interpolation-filters,color-profile,color-rendering,contentScriptType,contentStyleType,crossorigin,cursor,cx,cy,d,decelerate,descent,diffuseConstant,direction,display,divisor,dominant-baseline,dur,dx,dy,edgeMode,elevation,enable-background,end,exponent,fill,fill-opacity,fill-rule,filter,filterRes,filterUnits,flood-color,flood-opacity,font-family,font-size,font-size-adjust,font-stretch,font-style,font-variant,font-weight,format,from,fr,fx,fy,g1,g2,glyph-name,glyph-orientation-horizontal,glyph-orientation-vertical,glyphRef,gradientTransform,gradientUnits,hanging,height,href,hreflang,horiz-adv-x,horiz-origin-x,id,ideographic,image-rendering,in,in2,intercept,k,k1,k2,k3,k4,kernelMatrix,kernelUnitLength,kerning,keyPoints,keySplines,keyTimes,lang,lengthAdjust,letter-spacing,lighting-color,limitingConeAngle,local,marker-end,marker-mid,marker-start,markerHeight,markerUnits,markerWidth,mask,maskContentUnits,maskUnits,mathematical,max,media,method,min,mode,name,numOctaves,offset,opacity,operator,order,orient,orientation,origin,overflow,overline-position,overline-thickness,panose-1,paint-order,path,pathLength,patternContentUnits,patternTransform,patternUnits,ping,pointer-events,points,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,r,radius,referrerPolicy,refX,refY,rel,rendering-intent,repeatCount,repeatDur,requiredExtensions,requiredFeatures,restart,result,rotate,rx,ry,scale,seed,shape-rendering,slope,spacing,specularConstant,specularExponent,speed,spreadMethod,startOffset,stdDeviation,stemh,stemv,stitchTiles,stop-color,stop-opacity,strikethrough-position,strikethrough-thickness,string,stroke,stroke-dasharray,stroke-dashoffset,stroke-linecap,stroke-linejoin,stroke-miterlimit,stroke-opacity,stroke-width,style,surfaceScale,systemLanguage,tabindex,tableValues,target,targetX,targetY,text-anchor,text-decoration,text-rendering,textLength,to,transform,transform-origin,type,u1,u2,underline-position,underline-thickness,unicode,unicode-bidi,unicode-range,units-per-em,v-alphabetic,v-hanging,v-ideographic,v-mathematical,values,vector-effect,version,vert-adv-y,vert-origin-x,vert-origin-y,viewBox,viewTarget,visibility,width,widths,word-spacing,writing-mode,x,x-height,x1,x2,xChannelSelector,xlink:actuate,xlink:arcrole,xlink:href,xlink:role,xlink:show,xlink:title,xlink:type,xmlns:xlink,xml:base,xml:lang,xml:space,y,y1,y2,yChannelSelector,z,zoomAndPan`
+  );
+  function isRenderableAttrValue(value) {
+    if (value == null) {
+      return false;
+    }
+    const type = typeof value;
+    return type === "string" || type === "number" || type === "boolean";
+  }
 
-  /**
-   * Generate a string containing static keys from compiler modules.
-   */
-  function genStaticKeys (modules) {
-    return modules.reduce(function (keys, m) {
-      return keys.concat(m.staticKeys || [])
-    }, []).join(',')
+  const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
+  function getEscapedCssVarName(key, doubleEscape) {
+    return key.replace(
+      cssVarNameEscapeSymbolsRE,
+      (s) => `\\${s}`
+    );
   }
 
-  /**
-   * 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
+  function looseCompareArrays(a, b) {
+    if (a.length !== b.length) return false;
+    let equal = true;
+    for (let i = 0; equal && i < a.length; i++) {
+      equal = looseEqual(a[i], b[i]);
+    }
+    return equal;
+  }
+  function looseEqual(a, b) {
+    if (a === b) return true;
+    let aValidType = isDate(a);
+    let bValidType = isDate(b);
+    if (aValidType || bValidType) {
+      return aValidType && bValidType ? a.getTime() === b.getTime() : false;
+    }
+    aValidType = isSymbol(a);
+    bValidType = isSymbol(b);
+    if (aValidType || bValidType) {
+      return a === b;
+    }
+    aValidType = isArray(a);
+    bValidType = isArray(b);
+    if (aValidType || bValidType) {
+      return aValidType && bValidType ? looseCompareArrays(a, b) : false;
+    }
+    aValidType = isObject(a);
+    bValidType = isObject(b);
+    if (aValidType || bValidType) {
+      if (!aValidType || !bValidType) {
+        return false;
+      }
+      const aKeysCount = Object.keys(a).length;
+      const bKeysCount = Object.keys(b).length;
+      if (aKeysCount !== bKeysCount) {
+        return false;
+      }
+      for (const key in a) {
+        const aHasKey = a.hasOwnProperty(key);
+        const bHasKey = b.hasOwnProperty(key);
+        if (aHasKey && !bHasKey || !aHasKey && bHasKey || !looseEqual(a[key], b[key])) {
+          return false;
         }
-      } catch (e) {
-        /* istanbul ignore next */
-        return false
       }
-    } else if (!isObjectA && !isObjectB) {
-      return String(a) === String(b)
-    } else {
-      return false
     }
+    return String(a) === String(b);
+  }
+  function looseIndexOf(arr, val) {
+    return arr.findIndex((item) => looseEqual(item, val));
   }
 
-  /**
-   * 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 }
+  const isRef$1 = (val) => {
+    return !!(val && val["__v_isRef"] === true);
+  };
+  const toDisplayString = (val) => {
+    return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? isRef$1(val) ? toDisplayString(val.value) : JSON.stringify(val, replacer, 2) : String(val);
+  };
+  const replacer = (_key, val) => {
+    if (isRef$1(val)) {
+      return replacer(_key, val.value);
+    } else if (isMap(val)) {
+      return {
+        [`Map(${val.size})`]: [...val.entries()].reduce(
+          (entries, [key, val2], i) => {
+            entries[stringifySymbol(key, i) + " =>"] = val2;
+            return entries;
+          },
+          {}
+        )
+      };
+    } else if (isSet(val)) {
+      return {
+        [`Set(${val.size})`]: [...val.values()].map((v) => stringifySymbol(v))
+      };
+    } else if (isSymbol(val)) {
+      return stringifySymbol(val);
+    } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
+      return String(val);
     }
-    return -1
-  }
+    return val;
+  };
+  const stringifySymbol = (v, i = "") => {
+    var _a;
+    return (
+      // Symbol.description in es2019+ so we need to cast here to pass
+      // the lib: es2016 check
+      isSymbol(v) ? `Symbol(${(_a = v.description) != null ? _a : i})` : v
+    );
+  };
 
-  /**
-   * Ensure a function is called only once.
-   */
-  function once (fn) {
-    var called = false;
-    return function () {
-      if (!called) {
-        called = true;
-        fn.apply(this, arguments);
+  function warn$2(msg, ...args) {
+    console.warn(`[Vue warn] ${msg}`, ...args);
+  }
+
+  let activeEffectScope;
+  class EffectScope {
+    constructor(detached = false) {
+      this.detached = detached;
+      /**
+       * @internal
+       */
+      this._active = true;
+      /**
+       * @internal track `on` calls, allow `on` call multiple times
+       */
+      this._on = 0;
+      /**
+       * @internal
+       */
+      this.effects = [];
+      /**
+       * @internal
+       */
+      this.cleanups = [];
+      this._isPaused = false;
+      this.parent = activeEffectScope;
+      if (!detached && activeEffectScope) {
+        this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
+          this
+        ) - 1;
+      }
+    }
+    get active() {
+      return this._active;
+    }
+    pause() {
+      if (this._active) {
+        this._isPaused = true;
+        let i, l;
+        if (this.scopes) {
+          for (i = 0, l = this.scopes.length; i < l; i++) {
+            this.scopes[i].pause();
+          }
+        }
+        for (i = 0, l = this.effects.length; i < l; i++) {
+          this.effects[i].pause();
+        }
       }
     }
-  }
-
-  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: "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
+     * Resumes the effect scope, including all child scopes and effects.
      */
-    getTagNamespace: noop,
-
+    resume() {
+      if (this._active) {
+        if (this._isPaused) {
+          this._isPaused = false;
+          let i, l;
+          if (this.scopes) {
+            for (i = 0, l = this.scopes.length; i < l; i++) {
+              this.scopes[i].resume();
+            }
+          }
+          for (i = 0, l = this.effects.length; i < l; i++) {
+            this.effects[i].resume();
+          }
+        }
+      }
+    }
+    run(fn) {
+      if (this._active) {
+        const currentEffectScope = activeEffectScope;
+        try {
+          activeEffectScope = this;
+          return fn();
+        } finally {
+          activeEffectScope = currentEffectScope;
+        }
+      } else {
+        warn$2(`cannot run an inactive effect scope.`);
+      }
+    }
     /**
-     * Parse the real tag name for the specific platform.
+     * This should only be called on non-detached scopes
+     * @internal
      */
-    parsePlatformTagName: identity,
-
+    on() {
+      if (++this._on === 1) {
+        this.prevScope = activeEffectScope;
+        activeEffectScope = this;
+      }
+    }
     /**
-     * Check if an attribute must be bound using property, e.g. value
-     * Platform-dependent.
+     * This should only be called on non-detached scopes
+     * @internal
      */
-    mustUseProp: no,
+    off() {
+      if (this._on > 0 && --this._on === 0) {
+        activeEffectScope = this.prevScope;
+        this.prevScope = void 0;
+      }
+    }
+    stop(fromParent) {
+      if (this._active) {
+        this._active = false;
+        let i, l;
+        for (i = 0, l = this.effects.length; i < l; i++) {
+          this.effects[i].stop();
+        }
+        this.effects.length = 0;
+        for (i = 0, l = this.cleanups.length; i < l; i++) {
+          this.cleanups[i]();
+        }
+        this.cleanups.length = 0;
+        if (this.scopes) {
+          for (i = 0, l = this.scopes.length; i < l; i++) {
+            this.scopes[i].stop(true);
+          }
+          this.scopes.length = 0;
+        }
+        if (!this.detached && this.parent && !fromParent) {
+          const last = this.parent.scopes.pop();
+          if (last && last !== this) {
+            this.parent.scopes[this.index] = last;
+            last.index = this.index;
+          }
+        }
+        this.parent = void 0;
+      }
+    }
+  }
+  function effectScope(detached) {
+    return new EffectScope(detached);
+  }
+  function getCurrentScope() {
+    return activeEffectScope;
+  }
+  function onScopeDispose(fn, failSilently = false) {
+    if (activeEffectScope) {
+      activeEffectScope.cleanups.push(fn);
+    } else if (!failSilently) {
+      warn$2(
+        `onScopeDispose() is called when there is no active effect scope to be associated with.`
+      );
+    }
+  }
 
+  let activeSub;
+  const pausedQueueEffects = /* @__PURE__ */ new WeakSet();
+  class ReactiveEffect {
+    constructor(fn) {
+      this.fn = fn;
+      /**
+       * @internal
+       */
+      this.deps = void 0;
+      /**
+       * @internal
+       */
+      this.depsTail = void 0;
+      /**
+       * @internal
+       */
+      this.flags = 1 | 4;
+      /**
+       * @internal
+       */
+      this.next = void 0;
+      /**
+       * @internal
+       */
+      this.cleanup = void 0;
+      this.scheduler = void 0;
+      if (activeEffectScope && activeEffectScope.active) {
+        activeEffectScope.effects.push(this);
+      }
+    }
+    pause() {
+      this.flags |= 64;
+    }
+    resume() {
+      if (this.flags & 64) {
+        this.flags &= -65;
+        if (pausedQueueEffects.has(this)) {
+          pausedQueueEffects.delete(this);
+          this.trigger();
+        }
+      }
+    }
     /**
-     * Perform updates asynchronously. Intended to be used by Vue Test Utils
-     * This will significantly reduce performance if set to false.
+     * @internal
      */
-    async: true,
-
+    notify() {
+      if (this.flags & 2 && !(this.flags & 32)) {
+        return;
+      }
+      if (!(this.flags & 8)) {
+        batch(this);
+      }
+    }
+    run() {
+      if (!(this.flags & 1)) {
+        return this.fn();
+      }
+      this.flags |= 2;
+      cleanupEffect(this);
+      prepareDeps(this);
+      const prevEffect = activeSub;
+      const prevShouldTrack = shouldTrack;
+      activeSub = this;
+      shouldTrack = true;
+      try {
+        return this.fn();
+      } finally {
+        if (activeSub !== this) {
+          warn$2(
+            "Active effect was not restored correctly - this is likely a Vue internal bug."
+          );
+        }
+        cleanupDeps(this);
+        activeSub = prevEffect;
+        shouldTrack = prevShouldTrack;
+        this.flags &= -3;
+      }
+    }
+    stop() {
+      if (this.flags & 1) {
+        for (let link = this.deps; link; link = link.nextDep) {
+          removeSub(link);
+        }
+        this.deps = this.depsTail = void 0;
+        cleanupEffect(this);
+        this.onStop && this.onStop();
+        this.flags &= -2;
+      }
+    }
+    trigger() {
+      if (this.flags & 64) {
+        pausedQueueEffects.add(this);
+      } else if (this.scheduler) {
+        this.scheduler();
+      } else {
+        this.runIfDirty();
+      }
+    }
     /**
-     * Exposed for legacy reasons
+     * @internal
      */
-    _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
+    runIfDirty() {
+      if (isDirty(this)) {
+        this.run();
+      }
+    }
+    get dirty() {
+      return isDirty(this);
+    }
+  }
+  let batchDepth = 0;
+  let batchedSub;
+  let batchedComputed;
+  function batch(sub, isComputed = false) {
+    sub.flags |= 8;
+    if (isComputed) {
+      sub.next = batchedComputed;
+      batchedComputed = sub;
+      return;
+    }
+    sub.next = batchedSub;
+    batchedSub = sub;
+  }
+  function startBatch() {
+    batchDepth++;
+  }
+  function endBatch() {
+    if (--batchDepth > 0) {
+      return;
+    }
+    if (batchedComputed) {
+      let e = batchedComputed;
+      batchedComputed = void 0;
+      while (e) {
+        const next = e.next;
+        e.next = void 0;
+        e.flags &= -9;
+        e = next;
+      }
+    }
+    let error;
+    while (batchedSub) {
+      let e = batchedSub;
+      batchedSub = void 0;
+      while (e) {
+        const next = e.next;
+        e.next = void 0;
+        e.flags &= -9;
+        if (e.flags & 1) {
+          try {
+            ;
+            e.trigger();
+          } catch (err) {
+            if (!error) error = err;
+          }
+        }
+        e = next;
+      }
+    }
+    if (error) throw error;
   }
-
-  /**
-   * Define a property.
-   */
-  function def (obj, key, val, enumerable) {
-    Object.defineProperty(obj, key, {
-      value: val,
-      enumerable: !!enumerable,
-      writable: true,
-      configurable: true
-    });
+  function prepareDeps(sub) {
+    for (let link = sub.deps; link; link = link.nextDep) {
+      link.version = -1;
+      link.prevActiveLink = link.dep.activeLink;
+      link.dep.activeLink = link;
+    }
   }
-
-  /**
-   * Parse simple path.
-   */
-  var bailRE = new RegExp(("[^" + (unicodeRegExp.source) + ".$_\\d]"));
-  function parsePath (path) {
-    if (bailRE.test(path)) {
-      return
+  function cleanupDeps(sub) {
+    let head;
+    let tail = sub.depsTail;
+    let link = tail;
+    while (link) {
+      const prev = link.prevDep;
+      if (link.version === -1) {
+        if (link === tail) tail = prev;
+        removeSub(link);
+        removeDep(link);
+      } else {
+        head = link;
+      }
+      link.dep.activeLink = link.prevActiveLink;
+      link.prevActiveLink = void 0;
+      link = prev;
     }
-    var segments = path.split('.');
-    return function (obj) {
-      for (var i = 0; i < segments.length; i++) {
-        if (!obj) { return }
-        obj = obj[segments[i]];
+    sub.deps = head;
+    sub.depsTail = tail;
+  }
+  function isDirty(sub) {
+    for (let link = sub.deps; link; link = link.nextDep) {
+      if (link.dep.version !== link.version || link.dep.computed && (refreshComputed(link.dep.computed) || link.dep.version !== link.version)) {
+        return true;
       }
-      return obj
     }
+    if (sub._dirty) {
+      return true;
+    }
+    return false;
   }
-
-  /*  */
-
-  // 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;
-
-  var supportsPassive = false;
-  if (inBrowser) {
+  function refreshComputed(computed) {
+    if (computed.flags & 4 && !(computed.flags & 16)) {
+      return;
+    }
+    computed.flags &= -17;
+    if (computed.globalVersion === globalVersion) {
+      return;
+    }
+    computed.globalVersion = globalVersion;
+    if (!computed.isSSR && computed.flags & 128 && (!computed.deps && !computed._dirty || !isDirty(computed))) {
+      return;
+    }
+    computed.flags |= 2;
+    const dep = computed.dep;
+    const prevSub = activeSub;
+    const prevShouldTrack = shouldTrack;
+    activeSub = computed;
+    shouldTrack = true;
     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) {}
-  }
-
-  // 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;
+      prepareDeps(computed);
+      const value = computed.fn(computed._value);
+      if (dep.version === 0 || hasChanged(value, computed._value)) {
+        computed.flags |= 128;
+        computed._value = value;
+        dep.version++;
+      }
+    } catch (err) {
+      dep.version++;
+      throw err;
+    } finally {
+      activeSub = prevSub;
+      shouldTrack = prevShouldTrack;
+      cleanupDeps(computed);
+      computed.flags &= -3;
+    }
+  }
+  function removeSub(link, soft = false) {
+    const { dep, prevSub, nextSub } = link;
+    if (prevSub) {
+      prevSub.nextSub = nextSub;
+      link.prevSub = void 0;
+    }
+    if (nextSub) {
+      nextSub.prevSub = prevSub;
+      link.nextSub = void 0;
+    }
+    if (dep.subsHead === link) {
+      dep.subsHead = nextSub;
+    }
+    if (dep.subs === link) {
+      dep.subs = prevSub;
+      if (!prevSub && dep.computed) {
+        dep.computed.flags &= -5;
+        for (let l = dep.computed.deps; l; l = l.nextDep) {
+          removeSub(l, true);
+        }
       }
     }
-    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())
+    if (!soft && !--dep.sc && dep.map) {
+      dep.map.delete(dep.key);
+    }
   }
-
-  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 removeDep(link) {
+    const { prevDep, nextDep } = link;
+    if (prevDep) {
+      prevDep.nextDep = nextDep;
+      link.prevDep = void 0;
+    }
+    if (nextDep) {
+      nextDep.prevDep = prevDep;
+      link.nextDep = void 0;
+    }
   }
-
-  /*  */
-
-  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 (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>'
+  function effect(fn, options) {
+    if (fn.effect instanceof ReactiveEffect) {
+      fn = fn.effect.fn;
+    }
+    const e = new ReactiveEffect(fn);
+    if (options) {
+      extend(e, options);
+    }
+    try {
+      e.run();
+    } catch (err) {
+      e.stop();
+      throw err;
+    }
+    const runner = e.run.bind(e);
+    runner.effect = e;
+    return runner;
+  }
+  function stop(runner) {
+    runner.effect.stop();
+  }
+  let shouldTrack = true;
+  const trackStack = [];
+  function pauseTracking() {
+    trackStack.push(shouldTrack);
+    shouldTrack = false;
+  }
+  function resetTracking() {
+    const last = trackStack.pop();
+    shouldTrack = last === void 0 ? true : last;
+  }
+  function cleanupEffect(e) {
+    const { cleanup } = e;
+    e.cleanup = void 0;
+    if (cleanup) {
+      const prevSub = activeSub;
+      activeSub = void 0;
+      try {
+        cleanup();
+      } finally {
+        activeSub = prevSub;
+      }
+    }
+  }
+
+  let globalVersion = 0;
+  class Link {
+    constructor(sub, dep) {
+      this.sub = sub;
+      this.dep = dep;
+      this.version = dep.version;
+      this.nextDep = this.prevDep = this.nextSub = this.prevSub = this.prevActiveLink = void 0;
+    }
+  }
+  class Dep {
+    // TODO isolatedDeclarations "__v_skip"
+    constructor(computed) {
+      this.computed = computed;
+      this.version = 0;
+      /**
+       * Link between this dep and the current active effect
+       */
+      this.activeLink = void 0;
+      /**
+       * Doubly linked list representing the subscribing effects (tail)
+       */
+      this.subs = void 0;
+      /**
+       * For object property deps cleanup
+       */
+      this.map = void 0;
+      this.key = void 0;
+      /**
+       * Subscriber counter
+       */
+      this.sc = 0;
+      /**
+       * @internal
+       */
+      this.__v_skip = true;
+      {
+        this.subsHead = void 0;
       }
-      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];
+    }
+    track(debugInfo) {
+      if (!activeSub || !shouldTrack || activeSub === this.computed) {
+        return;
       }
-
-      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;
-            }
+      let link = this.activeLink;
+      if (link === void 0 || link.sub !== activeSub) {
+        link = this.activeLink = new Link(activeSub, this);
+        if (!activeSub.deps) {
+          activeSub.deps = activeSub.depsTail = link;
+        } else {
+          link.prevDep = activeSub.depsTail;
+          activeSub.depsTail.nextDep = link;
+          activeSub.depsTail = link;
+        }
+        addSub(link);
+      } else if (link.version === -1) {
+        link.version = this.version;
+        if (link.nextDep) {
+          const next = link.nextDep;
+          next.prevDep = link.prevDep;
+          if (link.prevDep) {
+            link.prevDep.nextDep = next;
+          }
+          link.prevDep = activeSub.depsTail;
+          link.nextDep = void 0;
+          activeSub.depsTail.nextDep = link;
+          activeSub.depsTail = link;
+          if (activeSub.deps === link) {
+            activeSub.deps = next;
           }
-          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 (!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;
-  };
-
-  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 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,
-      // #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 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;
-  }
-
-  /**
-   * 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);
+      if (activeSub.onTrack) {
+        activeSub.onTrack(
+          extend(
+            {
+              effect: activeSub
+            },
+            debugInfo
+          )
+        );
       }
-      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
+      return link;
     }
-
-    // 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];
+    trigger(debugInfo) {
+      this.version++;
+      globalVersion++;
+      this.notify(debugInfo);
     }
-
-    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);
+    notify(debugInfo) {
+      startBatch();
+      try {
+        if (true) {
+          for (let head = this.subsHead; head; head = head.nextSub) {
+            if (head.sub.onTrigger && !(head.sub.flags & 8)) {
+              head.sub.onTrigger(
+                extend(
+                  {
+                    effect: head.sub
+                  },
+                  debugInfo
+                )
+              );
             }
           }
         }
-        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;
+        for (let link = this.subs; link; link = link.prevSub) {
+          if (link.sub.notify()) {
+            ;
+            link.sub.dep.notify();
+          }
         }
-        childOb = !shallow && observe(newVal);
-        dep.notify();
+      } finally {
+        endBatch();
       }
-    });
-  }
-
-  /**
-   * 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
   }
-
-  /**
-   * 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
+  function addSub(link) {
+    link.dep.sc++;
+    if (link.sub.flags & 4) {
+      const computed = link.dep.computed;
+      if (computed && !link.dep.subs) {
+        computed.flags |= 4 | 16;
+        for (let l = computed.deps; l; l = l.nextDep) {
+          addSub(l);
+        }
+      }
+      const currentTail = link.dep.subs;
+      if (currentTail !== link) {
+        link.prevSub = currentTail;
+        if (currentTail) currentTail.nextSub = link;
+      }
+      if (link.dep.subsHead === void 0) {
+        link.dep.subsHead = link;
+      }
+      link.dep.subs = link;
     }
-    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);
+  const targetMap = /* @__PURE__ */ new WeakMap();
+  const ITERATE_KEY = Symbol(
+    "Object iterate" 
+  );
+  const MAP_KEY_ITERATE_KEY = Symbol(
+    "Map keys iterate" 
+  );
+  const ARRAY_ITERATE_KEY = Symbol(
+    "Array iterate" 
+  );
+  function track(target, type, key) {
+    if (shouldTrack && activeSub) {
+      let depsMap = targetMap.get(target);
+      if (!depsMap) {
+        targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
+      }
+      let dep = depsMap.get(key);
+      if (!dep) {
+        depsMap.set(key, dep = new Dep());
+        dep.map = depsMap;
+        dep.key = key;
+      }
+      {
+        dep.track({
+          target,
+          type,
+          key
+        });
       }
     }
   }
-
-  /*  */
-
-  /**
-   * 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.'
-        );
+  function trigger(target, type, key, newValue, oldValue, oldTarget) {
+    const depsMap = targetMap.get(target);
+    if (!depsMap) {
+      globalVersion++;
+      return;
+    }
+    const run = (dep) => {
+      if (dep) {
+        {
+          dep.trigger({
+            target,
+            type,
+            key,
+            newValue,
+            oldValue,
+            oldTarget
+          });
+        }
       }
-      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
-        )
-      }
+    startBatch();
+    if (type === "clear") {
+      depsMap.forEach(run);
     } 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
+      const targetIsArray = isArray(target);
+      const isArrayIndex = targetIsArray && isIntegerKey(key);
+      if (targetIsArray && key === "length") {
+        const newLength = Number(newValue);
+        depsMap.forEach((dep, key2) => {
+          if (key2 === "length" || key2 === ARRAY_ITERATE_KEY || !isSymbol(key2) && key2 >= newLength) {
+            run(dep);
+          }
+        });
+      } else {
+        if (key !== void 0 || depsMap.has(void 0)) {
+          run(depsMap.get(key));
+        }
+        if (isArrayIndex) {
+          run(depsMap.get(ARRAY_ITERATE_KEY));
+        }
+        switch (type) {
+          case "add":
+            if (!targetIsArray) {
+              run(depsMap.get(ITERATE_KEY));
+              if (isMap(target)) {
+                run(depsMap.get(MAP_KEY_ITERATE_KEY));
+              }
+            } else if (isArrayIndex) {
+              run(depsMap.get("length"));
+            }
+            break;
+          case "delete":
+            if (!targetIsArray) {
+              run(depsMap.get(ITERATE_KEY));
+              if (isMap(target)) {
+                run(depsMap.get(MAP_KEY_ITERATE_KEY));
+              }
+            }
+            break;
+          case "set":
+            if (isMap(target)) {
+              run(depsMap.get(ITERATE_KEY));
+            }
+            break;
         }
       }
     }
+    endBatch();
+  }
+  function getDepFromReactive(object, key) {
+    const depMap = targetMap.get(object);
+    return depMap && depMap.get(key);
   }
 
-  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)
+  function reactiveReadArray(array) {
+    const raw = toRaw(array);
+    if (raw === array) return raw;
+    track(raw, "iterate", ARRAY_ITERATE_KEY);
+    return isShallow(array) ? raw : raw.map(toReactive);
+  }
+  function shallowReadArray(arr) {
+    track(arr = toRaw(arr), "iterate", ARRAY_ITERATE_KEY);
+    return arr;
+  }
+  const arrayInstrumentations = {
+    __proto__: null,
+    [Symbol.iterator]() {
+      return iterator(this, Symbol.iterator, toReactive);
+    },
+    concat(...args) {
+      return reactiveReadArray(this).concat(
+        ...args.map((x) => isArray(x) ? reactiveReadArray(x) : x)
+      );
+    },
+    entries() {
+      return iterator(this, "entries", (value) => {
+        value[1] = toReactive(value[1]);
+        return value;
+      });
+    },
+    every(fn, thisArg) {
+      return apply(this, "every", fn, thisArg, void 0, arguments);
+    },
+    filter(fn, thisArg) {
+      return apply(this, "filter", fn, thisArg, (v) => v.map(toReactive), arguments);
+    },
+    find(fn, thisArg) {
+      return apply(this, "find", fn, thisArg, toReactive, arguments);
+    },
+    findIndex(fn, thisArg) {
+      return apply(this, "findIndex", fn, thisArg, void 0, arguments);
+    },
+    findLast(fn, thisArg) {
+      return apply(this, "findLast", fn, thisArg, toReactive, arguments);
+    },
+    findLastIndex(fn, thisArg) {
+      return apply(this, "findLastIndex", fn, thisArg, void 0, arguments);
+    },
+    // flat, flatMap could benefit from ARRAY_ITERATE but are not straight-forward to implement
+    forEach(fn, thisArg) {
+      return apply(this, "forEach", fn, thisArg, void 0, arguments);
+    },
+    includes(...args) {
+      return searchProxy(this, "includes", args);
+    },
+    indexOf(...args) {
+      return searchProxy(this, "indexOf", args);
+    },
+    join(separator) {
+      return reactiveReadArray(this).join(separator);
+    },
+    // keys() iterator only reads `length`, no optimisation required
+    lastIndexOf(...args) {
+      return searchProxy(this, "lastIndexOf", args);
+    },
+    map(fn, thisArg) {
+      return apply(this, "map", fn, thisArg, void 0, arguments);
+    },
+    pop() {
+      return noTracking(this, "pop");
+    },
+    push(...args) {
+      return noTracking(this, "push", args);
+    },
+    reduce(fn, ...args) {
+      return reduce(this, "reduce", fn, args);
+    },
+    reduceRight(fn, ...args) {
+      return reduce(this, "reduceRight", fn, args);
+    },
+    shift() {
+      return noTracking(this, "shift");
+    },
+    // slice could use ARRAY_ITERATE but also seems to beg for range tracking
+    some(fn, thisArg) {
+      return apply(this, "some", fn, thisArg, void 0, arguments);
+    },
+    splice(...args) {
+      return noTracking(this, "splice", args);
+    },
+    toReversed() {
+      return reactiveReadArray(this).toReversed();
+    },
+    toSorted(comparer) {
+      return reactiveReadArray(this).toSorted(comparer);
+    },
+    toSpliced(...args) {
+      return reactiveReadArray(this).toSpliced(...args);
+    },
+    unshift(...args) {
+      return noTracking(this, "unshift", args);
+    },
+    values() {
+      return iterator(this, "values", toReactive);
     }
-
-    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
+  function iterator(self, method, wrapValue) {
+    const arr = shallowReadArray(self);
+    const iter = arr[method]();
+    if (arr !== self && !isShallow(self)) {
+      iter._next = iter.next;
+      iter.next = () => {
+        const result = iter._next();
+        if (result.value) {
+          result.value = wrapValue(result.value);
+        }
+        return result;
+      };
     }
-  }
-
-  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
-  };
-
-  /**
-   * Validate component names
-   */
-  function checkComponents (options) {
-    for (var key in options.components) {
-      validateComponentName(key);
+    return iter;
+  }
+  const arrayProto = Array.prototype;
+  function apply(self, method, fn, thisArg, wrappedRetFn, args) {
+    const arr = shallowReadArray(self);
+    const needsWrap = arr !== self && !isShallow(self);
+    const methodFn = arr[method];
+    if (methodFn !== arrayProto[method]) {
+      const result2 = methodFn.apply(self, args);
+      return needsWrap ? toReactive(result2) : result2;
+    }
+    let wrappedFn = fn;
+    if (arr !== self) {
+      if (needsWrap) {
+        wrappedFn = function(item, index) {
+          return fn.call(this, toReactive(item), index, self);
+        };
+      } else if (fn.length > 2) {
+        wrappedFn = function(item, index) {
+          return fn.call(this, item, index, self);
+        };
+      }
     }
+    const result = methodFn.call(arr, wrappedFn, thisArg);
+    return needsWrap && wrappedRetFn ? wrappedRetFn(result) : result;
   }
-
-  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.'
-      );
+  function reduce(self, method, fn, args) {
+    const arr = shallowReadArray(self);
+    let wrappedFn = fn;
+    if (arr !== self) {
+      if (!isShallow(self)) {
+        wrappedFn = function(acc, item, index) {
+          return fn.call(this, acc, toReactive(item), index, self);
+        };
+      } else if (fn.length > 3) {
+        wrappedFn = function(acc, item, index) {
+          return fn.call(this, acc, item, index, self);
+        };
+      }
     }
-    if (isBuiltInTag(name) || config.isReservedTag(name)) {
-      warn(
-        'Do not use built-in or reserved HTML elements as component ' +
-        'id: ' + name
-      );
+    return arr[method](wrappedFn, ...args);
+  }
+  function searchProxy(self, method, args) {
+    const arr = toRaw(self);
+    track(arr, "iterate", ARRAY_ITERATE_KEY);
+    const res = arr[method](...args);
+    if ((res === -1 || res === false) && isProxy(args[0])) {
+      args[0] = toRaw(args[0]);
+      return arr[method](...args);
     }
+    return res;
+  }
+  function noTracking(self, method, args = []) {
+    pauseTracking();
+    startBatch();
+    const res = toRaw(self)[method].apply(self, args);
+    endBatch();
+    resetTracking();
+    return res;
   }
 
-  /**
-   * 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.');
+  const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
+  const builtInSymbols = new Set(
+    /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
+  );
+  function hasOwnProperty(key) {
+    if (!isSymbol(key)) key = String(key);
+    const obj = toRaw(this);
+    track(obj, "has", key);
+    return obj.hasOwnProperty(key);
+  }
+  class BaseReactiveHandler {
+    constructor(_isReadonly = false, _isShallow = false) {
+      this._isReadonly = _isReadonly;
+      this._isShallow = _isShallow;
+    }
+    get(target, key, receiver) {
+      if (key === "__v_skip") return target["__v_skip"];
+      const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
+      if (key === "__v_isReactive") {
+        return !isReadonly2;
+      } else if (key === "__v_isReadonly") {
+        return isReadonly2;
+      } else if (key === "__v_isShallow") {
+        return isShallow2;
+      } else if (key === "__v_raw") {
+        if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
+        // this means the receiver is a user proxy of the reactive proxy
+        Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
+          return target;
         }
+        return;
       }
-    } else if (isPlainObject(props)) {
-      for (var key in props) {
-        val = props[key];
-        name = camelize(key);
-        res[name] = isPlainObject(val)
-          ? val
-          : { type: val };
+      const targetIsArray = isArray(target);
+      if (!isReadonly2) {
+        let fn;
+        if (targetIsArray && (fn = arrayInstrumentations[key])) {
+          return fn;
+        }
+        if (key === "hasOwnProperty") {
+          return hasOwnProperty;
+        }
       }
-    } else {
-      warn(
-        "Invalid value for option \"props\": expected an Array or an Object, " +
-        "but got " + (toRawType(props)) + ".",
-        vm
+      const res = Reflect.get(
+        target,
+        key,
+        // if this is a proxy wrapping a ref, return methods using the raw ref
+        // as receiver so that we don't have to call `toRaw` on the ref in all
+        // its class methods
+        isRef(target) ? target : receiver
       );
-    }
-    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] };
+      if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
+        return res;
       }
-    } else if (isPlainObject(inject)) {
-      for (var key in inject) {
-        var val = inject[key];
-        normalized[key] = isPlainObject(val)
-          ? extend({ from: key }, val)
-          : { from: val };
+      if (!isReadonly2) {
+        track(target, "get", key);
       }
-    } else {
-      warn(
-        "Invalid value for option \"inject\": expected an Array or an Object, " +
-        "but got " + (toRawType(inject)) + ".",
-        vm
-      );
+      if (isShallow2) {
+        return res;
+      }
+      if (isRef(res)) {
+        return targetIsArray && isIntegerKey(key) ? res : res.value;
+      }
+      if (isObject(res)) {
+        return isReadonly2 ? readonly(res) : reactive(res);
+      }
+      return res;
     }
   }
-
-  /**
-   * 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 };
+  class MutableReactiveHandler extends BaseReactiveHandler {
+    constructor(isShallow2 = false) {
+      super(false, isShallow2);
+    }
+    set(target, key, value, receiver) {
+      let oldValue = target[key];
+      if (!this._isShallow) {
+        const isOldValueReadonly = isReadonly(oldValue);
+        if (!isShallow(value) && !isReadonly(value)) {
+          oldValue = toRaw(oldValue);
+          value = toRaw(value);
+        }
+        if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
+          if (isOldValueReadonly) {
+            return false;
+          } else {
+            oldValue.value = value;
+            return true;
+          }
         }
       }
-    }
-  }
-
-  function assertObjectType (name, value, vm) {
-    if (!isPlainObject(value)) {
-      warn(
-        "Invalid value for option \"" + name + "\": expected an Object, " +
-        "but got " + (toRawType(value)) + ".",
-        vm
+      const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
+      const result = Reflect.set(
+        target,
+        key,
+        value,
+        isRef(target) ? target : receiver
       );
-    }
-  }
-
-  /**
-   * 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);
+      if (target === toRaw(receiver)) {
+        if (!hadKey) {
+          trigger(target, "add", key, value);
+        } else if (hasChanged(value, oldValue)) {
+          trigger(target, "set", key, value, oldValue);
         }
       }
+      return result;
     }
-
-    var options = {};
-    var key;
-    for (key in parent) {
-      mergeField(key);
+    deleteProperty(target, key) {
+      const hadKey = hasOwn(target, key);
+      const oldValue = target[key];
+      const result = Reflect.deleteProperty(target, key);
+      if (result && hadKey) {
+        trigger(target, "delete", key, void 0, oldValue);
+      }
+      return result;
     }
-    for (key in child) {
-      if (!hasOwn(parent, key)) {
-        mergeField(key);
+    has(target, key) {
+      const result = Reflect.has(target, key);
+      if (!isSymbol(key) || !builtInSymbols.has(key)) {
+        track(target, "has", key);
       }
+      return result;
     }
-    function mergeField (key) {
-      var strat = strats[key] || defaultStrat;
-      options[key] = strat(parent[key], child[key], vm, key);
+    ownKeys(target) {
+      track(
+        target,
+        "iterate",
+        isArray(target) ? "length" : ITERATE_KEY
+      );
+      return Reflect.ownKeys(target);
     }
-    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
+  class ReadonlyReactiveHandler extends BaseReactiveHandler {
+    constructor(isShallow2 = false) {
+      super(true, isShallow2);
     }
-    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
+    set(target, key) {
+      {
+        warn$2(
+          `Set operation on key "${String(key)}" failed: target is readonly.`,
+          target
+        );
+      }
+      return true;
+    }
+    deleteProperty(target, key) {
+      {
+        warn$2(
+          `Delete operation on key "${String(key)}" failed: target is readonly.`,
+          target
+        );
+      }
+      return true;
+    }
+  }
+  const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
+  const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
+  const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(true);
+  const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
+
+  const toShallow = (value) => value;
+  const getProto = (v) => Reflect.getPrototypeOf(v);
+  function createIterableMethod(method, isReadonly2, isShallow2) {
+    return function(...args) {
+      const target = this["__v_raw"];
+      const rawTarget = toRaw(target);
+      const targetIsMap = isMap(rawTarget);
+      const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
+      const isKeyOnly = method === "keys" && targetIsMap;
+      const innerIterator = target[method](...args);
+      const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive;
+      !isReadonly2 && track(
+        rawTarget,
+        "iterate",
+        isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
+      );
+      return {
+        // iterator protocol
+        next() {
+          const { value, done } = innerIterator.next();
+          return done ? { value, done } : {
+            value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
+            done
+          };
+        },
+        // iterable protocol
+        [Symbol.iterator]() {
+          return this;
+        }
+      };
+    };
+  }
+  function createReadonlyMethod(type) {
+    return function(...args) {
+      {
+        const key = args[0] ? `on key "${args[0]}" ` : ``;
+        warn$2(
+          `${capitalize(type)} operation ${key}failed: target is readonly.`,
+          toRaw(this)
+        );
+      }
+      return type === "delete" ? false : type === "clear" ? void 0 : this;
+    };
+  }
+  function createInstrumentations(readonly, shallow) {
+    const instrumentations = {
+      get(key) {
+        const target = this["__v_raw"];
+        const rawTarget = toRaw(target);
+        const rawKey = toRaw(key);
+        if (!readonly) {
+          if (hasChanged(key, rawKey)) {
+            track(rawTarget, "get", key);
+          }
+          track(rawTarget, "get", rawKey);
+        }
+        const { has } = getProto(rawTarget);
+        const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+        if (has.call(rawTarget, key)) {
+          return wrap(target.get(key));
+        } else if (has.call(rawTarget, rawKey)) {
+          return wrap(target.get(rawKey));
+        } else if (target !== rawTarget) {
+          target.get(key);
+        }
+      },
+      get size() {
+        const target = this["__v_raw"];
+        !readonly && track(toRaw(target), "iterate", ITERATE_KEY);
+        return Reflect.get(target, "size", target);
+      },
+      has(key) {
+        const target = this["__v_raw"];
+        const rawTarget = toRaw(target);
+        const rawKey = toRaw(key);
+        if (!readonly) {
+          if (hasChanged(key, rawKey)) {
+            track(rawTarget, "has", key);
+          }
+          track(rawTarget, "has", rawKey);
+        }
+        return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
+      },
+      forEach(callback, thisArg) {
+        const observed = this;
+        const target = observed["__v_raw"];
+        const rawTarget = toRaw(target);
+        const wrap = shallow ? toShallow : readonly ? toReadonly : toReactive;
+        !readonly && track(rawTarget, "iterate", ITERATE_KEY);
+        return target.forEach((value, key) => {
+          return callback.call(thisArg, wrap(value), wrap(key), observed);
+        });
+      }
+    };
+    extend(
+      instrumentations,
+      readonly ? {
+        add: createReadonlyMethod("add"),
+        set: createReadonlyMethod("set"),
+        delete: createReadonlyMethod("delete"),
+        clear: createReadonlyMethod("clear")
+      } : {
+        add(value) {
+          if (!shallow && !isShallow(value) && !isReadonly(value)) {
+            value = toRaw(value);
+          }
+          const target = toRaw(this);
+          const proto = getProto(target);
+          const hadKey = proto.has.call(target, value);
+          if (!hadKey) {
+            target.add(value);
+            trigger(target, "add", value, value);
+          }
+          return this;
+        },
+        set(key, value) {
+          if (!shallow && !isShallow(value) && !isReadonly(value)) {
+            value = toRaw(value);
+          }
+          const target = toRaw(this);
+          const { has, get } = getProto(target);
+          let hadKey = has.call(target, key);
+          if (!hadKey) {
+            key = toRaw(key);
+            hadKey = has.call(target, key);
+          } else {
+            checkIdentityKeys(target, has, key);
+          }
+          const oldValue = get.call(target, key);
+          target.set(key, value);
+          if (!hadKey) {
+            trigger(target, "add", key, value);
+          } else if (hasChanged(value, oldValue)) {
+            trigger(target, "set", key, value, oldValue);
+          }
+          return this;
+        },
+        delete(key) {
+          const target = toRaw(this);
+          const { has, get } = getProto(target);
+          let hadKey = has.call(target, key);
+          if (!hadKey) {
+            key = toRaw(key);
+            hadKey = has.call(target, key);
+          } else {
+            checkIdentityKeys(target, has, key);
+          }
+          const oldValue = get ? get.call(target, key) : void 0;
+          const result = target.delete(key);
+          if (hadKey) {
+            trigger(target, "delete", key, void 0, oldValue);
+          }
+          return result;
+        },
+        clear() {
+          const target = toRaw(this);
+          const hadItems = target.size !== 0;
+          const oldTarget = isMap(target) ? new Map(target) : new Set(target) ;
+          const result = target.clear();
+          if (hadItems) {
+            trigger(
+              target,
+              "clear",
+              void 0,
+              void 0,
+              oldTarget
+            );
+          }
+          return result;
+        }
+      }
+    );
+    const iteratorMethods = [
+      "keys",
+      "values",
+      "entries",
+      Symbol.iterator
+    ];
+    iteratorMethods.forEach((method) => {
+      instrumentations[method] = createIterableMethod(method, readonly, shallow);
+    });
+    return instrumentations;
+  }
+  function createInstrumentationGetter(isReadonly2, shallow) {
+    const instrumentations = createInstrumentations(isReadonly2, shallow);
+    return (target, key, receiver) => {
+      if (key === "__v_isReactive") {
+        return !isReadonly2;
+      } else if (key === "__v_isReadonly") {
+        return isReadonly2;
+      } else if (key === "__v_raw") {
+        return target;
+      }
+      return Reflect.get(
+        hasOwn(instrumentations, key) && key in target ? instrumentations : target,
+        key,
+        receiver
+      );
+    };
+  }
+  const mutableCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(false, false)
+  };
+  const shallowCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(false, true)
+  };
+  const readonlyCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(true, false)
+  };
+  const shallowReadonlyCollectionHandlers = {
+    get: /* @__PURE__ */ createInstrumentationGetter(true, true)
+  };
+  function checkIdentityKeys(target, has, key) {
+    const rawKey = toRaw(key);
+    if (rawKey !== key && has.call(target, rawKey)) {
+      const type = toRawType(target);
+      warn$2(
+        `Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`
       );
     }
-    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;
-        }
+  const reactiveMap = /* @__PURE__ */ new WeakMap();
+  const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
+  const readonlyMap = /* @__PURE__ */ new WeakMap();
+  const shallowReadonlyMap = /* @__PURE__ */ new WeakMap();
+  function targetTypeMap(rawType) {
+    switch (rawType) {
+      case "Object":
+      case "Array":
+        return 1 /* COMMON */;
+      case "Map":
+      case "Set":
+      case "WeakMap":
+      case "WeakSet":
+        return 2 /* COLLECTION */;
+      default:
+        return 0 /* INVALID */;
+    }
+  }
+  function getTargetType(value) {
+    return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
+  }
+  function reactive(target) {
+    if (isReadonly(target)) {
+      return target;
+    }
+    return createReactiveObject(
+      target,
+      false,
+      mutableHandlers,
+      mutableCollectionHandlers,
+      reactiveMap
+    );
+  }
+  function shallowReactive(target) {
+    return createReactiveObject(
+      target,
+      false,
+      shallowReactiveHandlers,
+      shallowCollectionHandlers,
+      shallowReactiveMap
+    );
+  }
+  function readonly(target) {
+    return createReactiveObject(
+      target,
+      true,
+      readonlyHandlers,
+      readonlyCollectionHandlers,
+      readonlyMap
+    );
+  }
+  function shallowReadonly(target) {
+    return createReactiveObject(
+      target,
+      true,
+      shallowReadonlyHandlers,
+      shallowReadonlyCollectionHandlers,
+      shallowReadonlyMap
+    );
+  }
+  function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
+    if (!isObject(target)) {
+      {
+        warn$2(
+          `value cannot be made ${isReadonly2 ? "readonly" : "reactive"}: ${String(
+          target
+        )}`
+        );
       }
+      return target;
     }
-    // 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 (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
+      return target;
     }
-    {
-      assertProp(prop, key, value, vm, absent);
+    const targetType = getTargetType(target);
+    if (targetType === 0 /* INVALID */) {
+      return target;
+    }
+    const existingProxy = proxyMap.get(target);
+    if (existingProxy) {
+      return existingProxy;
     }
-    return value
+    const proxy = new Proxy(
+      target,
+      targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers
+    );
+    proxyMap.set(target, proxy);
+    return proxy;
   }
-
-  /**
-   * Get the default value of a prop.
-   */
-  function getPropDefaultValue (vm, prop, key) {
-    // no default, return undefined
-    if (!hasOwn(prop, 'default')) {
-      return undefined
+  function isReactive(value) {
+    if (isReadonly(value)) {
+      return isReactive(value["__v_raw"]);
     }
-    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
-      );
+    return !!(value && value["__v_isReactive"]);
+  }
+  function isReadonly(value) {
+    return !!(value && value["__v_isReadonly"]);
+  }
+  function isShallow(value) {
+    return !!(value && value["__v_isShallow"]);
+  }
+  function isProxy(value) {
+    return value ? !!value["__v_raw"] : false;
+  }
+  function toRaw(observed) {
+    const raw = observed && observed["__v_raw"];
+    return raw ? toRaw(raw) : observed;
+  }
+  function markRaw(value) {
+    if (!hasOwn(value, "__v_skip") && Object.isExtensible(value)) {
+      def(value, "__v_skip", true);
     }
-    // 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
+    return value;
+  }
+  const toReactive = (value) => isObject(value) ? reactive(value) : value;
+  const toReadonly = (value) => isObject(value) ? readonly(value) : value;
+
+  function isRef(r) {
+    return r ? r["__v_isRef"] === true : false;
+  }
+  function ref(value) {
+    return createRef(value, false);
+  }
+  function shallowRef(value) {
+    return createRef(value, true);
+  }
+  function createRef(rawValue, shallow) {
+    if (isRef(rawValue)) {
+      return rawValue;
     }
-    if (value == null && !prop.required) {
-      return
+    return new RefImpl(rawValue, shallow);
+  }
+  class RefImpl {
+    constructor(value, isShallow2) {
+      this.dep = new Dep();
+      this["__v_isRef"] = true;
+      this["__v_isShallow"] = false;
+      this._rawValue = isShallow2 ? value : toRaw(value);
+      this._value = isShallow2 ? value : toReactive(value);
+      this["__v_isShallow"] = isShallow2;
     }
-    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;
+    get value() {
+      {
+        this.dep.track({
+          target: this,
+          type: "get",
+          key: "value"
+        });
       }
+      return this._value;
     }
-
-    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
-        );
+    set value(newValue) {
+      const oldValue = this._rawValue;
+      const useDirectValue = this["__v_isShallow"] || isShallow(newValue) || isReadonly(newValue);
+      newValue = useDirectValue ? newValue : toRaw(newValue);
+      if (hasChanged(newValue, oldValue)) {
+        this._rawValue = newValue;
+        this._value = useDirectValue ? newValue : toReactive(newValue);
+        {
+          this.dep.trigger({
+            target: this,
+            type: "set",
+            key: "value",
+            newValue,
+            oldValue
+          });
+        }
       }
     }
   }
-
-  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;
+  function triggerRef(ref2) {
+    if (ref2.dep) {
+      {
+        ref2.dep.trigger({
+          target: ref2,
+          type: "set",
+          key: "value",
+          newValue: ref2._value
+        });
       }
-    } 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
     }
   }
-
-  /**
-   * 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 unref(ref2) {
+    return isRef(ref2) ? ref2.value : ref2;
   }
-
-  function isSameType (a, b) {
-    return getType(a) === getType(b)
+  function toValue(source) {
+    return isFunction(source) ? source() : unref(source);
   }
-
-  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
+  const shallowUnwrapHandlers = {
+    get: (target, key, receiver) => key === "__v_raw" ? target : unref(Reflect.get(target, key, receiver)),
+    set: (target, key, value, receiver) => {
+      const oldValue = target[key];
+      if (isRef(oldValue) && !isRef(value)) {
+        oldValue.value = value;
+        return true;
+      } else {
+        return Reflect.set(target, key, value, receiver);
       }
     }
-    return -1
+  };
+  function proxyRefs(objectWithRefs) {
+    return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers);
   }
-
-  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;
+  class CustomRefImpl {
+    constructor(factory) {
+      this["__v_isRef"] = true;
+      this._value = void 0;
+      const dep = this.dep = new Dep();
+      const { get, set } = factory(dep.track.bind(dep), dep.trigger.bind(dep));
+      this._get = get;
+      this._set = set;
     }
-    message += ", got " + receivedType + " ";
-    // check if we need to specify received value
-    if (isExplicable(receivedType)) {
-      message += "with value " + receivedValue + ".";
+    get value() {
+      return this._value = this._get();
     }
-    return message
-  }
-
-  function styleValue (value, type) {
-    if (type === 'String') {
-      return ("\"" + value + "\"")
-    } else if (type === 'Number') {
-      return ("" + (Number(value)))
-    } else {
-      return ("" + value)
+    set value(newVal) {
+      this._set(newVal);
     }
   }
-
-  function isExplicable (value) {
-    var explicitTypes = ['string', 'number', 'boolean'];
-    return explicitTypes.some(function (elem) { return value.toLowerCase() === elem; })
+  function customRef(factory) {
+    return new CustomRefImpl(factory);
   }
-
-  function isBoolean () {
-    var args = [], len = arguments.length;
-    while ( len-- ) args[ len ] = arguments[ len ];
-
-    return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
+  function toRefs(object) {
+    if (!isProxy(object)) {
+      warn$2(`toRefs() expects a reactive object but received a plain one.`);
+    }
+    const ret = isArray(object) ? new Array(object.length) : {};
+    for (const key in object) {
+      ret[key] = propertyToRef(object, key);
+    }
+    return ret;
   }
-
-  /*  */
-
-  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();
+  class ObjectRefImpl {
+    constructor(_object, _key, _defaultValue) {
+      this._object = _object;
+      this._key = _key;
+      this._defaultValue = _defaultValue;
+      this["__v_isRef"] = true;
+      this._value = void 0;
+    }
+    get value() {
+      const val = this._object[this._key];
+      return this._value = val === void 0 ? this._defaultValue : val;
+    }
+    set value(newVal) {
+      this._object[this._key] = newVal;
+    }
+    get dep() {
+      return getDepFromReactive(toRaw(this._object), this._key);
     }
   }
-
-  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);
+  class GetterRefImpl {
+    constructor(_getter) {
+      this._getter = _getter;
+      this["__v_isRef"] = true;
+      this["__v_isReadonly"] = true;
+      this._value = void 0;
+    }
+    get value() {
+      return this._value = this._getter();
     }
-    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');
-        }
+  function toRef(source, key, defaultValue) {
+    if (isRef(source)) {
+      return source;
+    } else if (isFunction(source)) {
+      return new GetterRefImpl(source);
+    } else if (isObject(source) && arguments.length > 1) {
+      return propertyToRef(source, key, defaultValue);
+    } else {
+      return ref(source);
+    }
+  }
+  function propertyToRef(source, key, defaultValue) {
+    const val = source[key];
+    return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
+  }
+
+  class ComputedRefImpl {
+    constructor(fn, setter, isSSR) {
+      this.fn = fn;
+      this.setter = setter;
+      /**
+       * @internal
+       */
+      this._value = void 0;
+      /**
+       * @internal
+       */
+      this.dep = new Dep(this);
+      /**
+       * @internal
+       */
+      this.__v_isRef = true;
+      // TODO isolatedDeclarations "__v_isReadonly"
+      // A computed is also a subscriber that tracks other deps
+      /**
+       * @internal
+       */
+      this.deps = void 0;
+      /**
+       * @internal
+       */
+      this.depsTail = void 0;
+      /**
+       * @internal
+       */
+      this.flags = 16;
+      /**
+       * @internal
+       */
+      this.globalVersion = globalVersion - 1;
+      /**
+       * @internal
+       */
+      this.next = void 0;
+      // for backwards compat
+      this.effect = this;
+      this["__v_isReadonly"] = !setter;
+      this.isSSR = isSSR;
+    }
+    /**
+     * @internal
+     */
+    notify() {
+      this.flags |= 16;
+      if (!(this.flags & 8) && // avoid infinite self recursion
+      activeSub !== this) {
+        batch(this, true);
+        return true;
+      }
+    }
+    get value() {
+      const link = this.dep.track({
+        target: this,
+        type: "get",
+        key: "value"
+      }) ;
+      refreshComputed(this);
+      if (link) {
+        link.version = this.dep.version;
+      }
+      return this._value;
+    }
+    set value(newValue) {
+      if (this.setter) {
+        this.setter(newValue);
+      } else {
+        warn$2("Write operation failed: computed value is readonly");
       }
     }
-    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);
+  function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+    let getter;
+    let setter;
+    if (isFunction(getterOrOptions)) {
+      getter = getterOrOptions;
     } else {
-      throw err
-    }
-  }
-
-  /*  */
-
-  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]();
-    }
-  }
-
-  // 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 = 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.
-    // Techinically 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;
-      })
+      getter = getterOrOptions.get;
+      setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, isSSR);
+    if (debugOptions && !isSSR) {
+      cRef.onTrack = debugOptions.onTrack;
+      cRef.onTrigger = debugOptions.onTrigger;
     }
+    return cRef;
   }
 
-  /*  */
-
-  var mark;
-  var measure;
+  const TrackOpTypes = {
+    "GET": "get",
+    "HAS": "has",
+    "ITERATE": "iterate"
+  };
+  const TriggerOpTypes = {
+    "SET": "set",
+    "ADD": "add",
+    "DELETE": "delete",
+    "CLEAR": "clear"
+  };
 
-  {
-    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)
-      };
+  const INITIAL_WATCHER_VALUE = {};
+  const cleanupMap = /* @__PURE__ */ new WeakMap();
+  let activeWatcher = void 0;
+  function getCurrentWatcher() {
+    return activeWatcher;
+  }
+  function onWatcherCleanup(cleanupFn, failSilently = false, owner = activeWatcher) {
+    if (owner) {
+      let cleanups = cleanupMap.get(owner);
+      if (!cleanups) cleanupMap.set(owner, cleanups = []);
+      cleanups.push(cleanupFn);
+    } else if (!failSilently) {
+      warn$2(
+        `onWatcherCleanup() was called when there was no active watcher to associate with.`
+      );
     }
   }
-
-  /* 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
+  function watch$1(source, cb, options = EMPTY_OBJ) {
+    const { immediate, deep, once, scheduler, augmentJob, call } = options;
+    const warnInvalidSource = (s) => {
+      (options.onWarn || warn$2)(
+        `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.`
       );
     };
-
-    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
-      );
+    const reactiveGetter = (source2) => {
+      if (deep) return source2;
+      if (isShallow(source2) || deep === false || deep === 0)
+        return traverse(source2, 1);
+      return traverse(source2);
     };
-
-    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
-          }
+    let effect;
+    let getter;
+    let cleanup;
+    let boundCleanup;
+    let forceTrigger = false;
+    let isMultiSource = false;
+    if (isRef(source)) {
+      getter = () => source.value;
+      forceTrigger = isShallow(source);
+    } else if (isReactive(source)) {
+      getter = () => reactiveGetter(source);
+      forceTrigger = 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 reactiveGetter(s);
+        } else if (isFunction(s)) {
+          return call ? call(s, 2) : s();
+        } else {
+          warnInvalidSource(s);
         }
       });
+    } else if (isFunction(source)) {
+      if (cb) {
+        getter = call ? () => call(source, 2) : source;
+      } else {
+        getter = () => {
+          if (cleanup) {
+            pauseTracking();
+            try {
+              cleanup();
+            } finally {
+              resetTracking();
+            }
+          }
+          const currentEffect = activeWatcher;
+          activeWatcher = effect;
+          try {
+            return call ? call(source, 3, [boundCleanup]) : source(boundCleanup);
+          } finally {
+            activeWatcher = currentEffect;
+          }
+        };
+      }
+    } else {
+      getter = NOOP;
+      warnInvalidSource(source);
     }
-
-    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); }
+    if (cb && deep) {
+      const baseGetter = getter;
+      const depth = deep === true ? Infinity : deep;
+      getter = () => traverse(baseGetter(), depth);
+    }
+    const scope = getCurrentScope();
+    const watchHandle = () => {
+      effect.stop();
+      if (scope && scope.active) {
+        remove(scope.effects, effect);
+      }
+    };
+    if (once && cb) {
+      const _cb = cb;
+      cb = (...args) => {
+        _cb(...args);
+        watchHandle();
+      };
+    }
+    let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
+    const job = (immediateFirstRun) => {
+      if (!(effect.flags & 1) || !effect.dirty && !immediateFirstRun) {
+        return;
+      }
+      if (cb) {
+        const newValue = effect.run();
+        if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue))) {
+          if (cleanup) {
+            cleanup();
+          }
+          const currentWatcher = activeWatcher;
+          activeWatcher = effect;
+          try {
+            const args = [
+              newValue,
+              // pass undefined as the old value when it's changed for the first time
+              oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
+              boundCleanup
+            ];
+            oldValue = newValue;
+            call ? call(cb, 3, args) : (
+              // @ts-expect-error
+              cb(...args)
+            );
+          } finally {
+            activeWatcher = currentWatcher;
+          }
         }
-        return has || !isAllowed
+      } else {
+        effect.run();
       }
     };
-
-    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); }
+    if (augmentJob) {
+      augmentJob(job);
+    }
+    effect = new ReactiveEffect(getter);
+    effect.scheduler = scheduler ? () => scheduler(job, false) : job;
+    boundCleanup = (fn) => onWatcherCleanup(fn, false, effect);
+    cleanup = effect.onStop = () => {
+      const cleanups = cleanupMap.get(effect);
+      if (cleanups) {
+        if (call) {
+          call(cleanups, 4);
+        } else {
+          for (const cleanup2 of cleanups) cleanup2();
         }
-        return target[key]
+        cleanupMap.delete(effect);
       }
     };
-
-    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);
+    {
+      effect.onTrack = options.onTrack;
+      effect.onTrigger = options.onTrigger;
+    }
+    if (cb) {
+      if (immediate) {
+        job(true);
       } else {
-        vm._renderProxy = vm;
+        oldValue = effect.run();
+      }
+    } else if (scheduler) {
+      scheduler(job.bind(null, true), true);
+    } else {
+      effect.run();
+    }
+    watchHandle.pause = effect.pause.bind(effect);
+    watchHandle.resume = effect.resume.bind(effect);
+    watchHandle.stop = watchHandle;
+    return watchHandle;
+  }
+  function traverse(value, depth = Infinity, seen) {
+    if (depth <= 0 || !isObject(value) || value["__v_skip"]) {
+      return value;
+    }
+    seen = seen || /* @__PURE__ */ new Set();
+    if (seen.has(value)) {
+      return value;
+    }
+    seen.add(value);
+    depth--;
+    if (isRef(value)) {
+      traverse(value.value, depth, seen);
+    } else if (isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        traverse(value[i], depth, seen);
+      }
+    } else if (isSet(value) || isMap(value)) {
+      value.forEach((v) => {
+        traverse(v, depth, seen);
+      });
+    } else if (isPlainObject(value)) {
+      for (const key in value) {
+        traverse(value[key], depth, seen);
+      }
+      for (const key of Object.getOwnPropertySymbols(value)) {
+        if (Object.prototype.propertyIsEnumerable.call(value, key)) {
+          traverse(value[key], depth, seen);
+        }
       }
-    };
-  }
-
-  /*  */
-
-  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
+    return value;
+  }
+
+  const stack$1 = [];
+  function pushWarningContext(vnode) {
+    stack$1.push(vnode);
+  }
+  function popWarningContext() {
+    stack$1.pop();
+  }
+  let isWarning = false;
+  function warn$1(msg, ...args) {
+    if (isWarning) return;
+    isWarning = true;
+    pauseTracking();
+    const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
+    const appWarnHandler = instance && instance.appContext.config.warnHandler;
+    const trace = getComponentTrace();
+    if (appWarnHandler) {
+      callWithErrorHandling(
+        appWarnHandler,
+        instance,
+        11,
+        [
+          // eslint-disable-next-line no-restricted-syntax
+          msg + args.map((a) => {
+            var _a, _b;
+            return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
+          }).join(""),
+          instance && instance.proxy,
+          trace.map(
+            ({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
+          ).join("\n"),
+          trace
+        ]
+      );
+    } else {
+      const warnArgs = [`[Vue warn]: ${msg}`, ...args];
+      if (trace.length && // avoid spamming console during tests
+      true) {
+        warnArgs.push(`
+`, ...formatTrace(trace));
+      }
+      console.warn(...warnArgs);
+    }
+    resetTracking();
+    isWarning = false;
+  }
+  function getComponentTrace() {
+    let currentVNode = stack$1[stack$1.length - 1];
+    if (!currentVNode) {
+      return [];
+    }
+    const normalizedStack = [];
+    while (currentVNode) {
+      const last = normalizedStack[0];
+      if (last && last.vnode === currentVNode) {
+        last.recurseCount++;
+      } else {
+        normalizedStack.push({
+          vnode: currentVNode,
+          recurseCount: 0
+        });
       }
-      seen.add(depId);
+      const parentInstance = currentVNode.component && currentVNode.component.parent;
+      currentVNode = parentInstance && parentInstance.vnode;
     }
-    if (isA) {
-      i = val.length;
-      while (i--) { _traverse(val[i], seen); }
+    return normalizedStack;
+  }
+  function formatTrace(trace) {
+    const logs = [];
+    trace.forEach((entry, i) => {
+      logs.push(...i === 0 ? [] : [`
+`], ...formatTraceEntry(entry));
+    });
+    return logs;
+  }
+  function formatTraceEntry({ vnode, recurseCount }) {
+    const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
+    const isRoot = vnode.component ? vnode.component.parent == null : false;
+    const open = ` at <${formatComponentName(
+    vnode.component,
+    vnode.type,
+    isRoot
+  )}`;
+    const close = `>` + postfix;
+    return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close];
+  }
+  function formatProps(props) {
+    const res = [];
+    const keys = Object.keys(props);
+    keys.slice(0, 3).forEach((key) => {
+      res.push(...formatProp(key, props[key]));
+    });
+    if (keys.length > 3) {
+      res.push(` ...`);
+    }
+    return res;
+  }
+  function formatProp(key, value, raw) {
+    if (isString(value)) {
+      value = JSON.stringify(value);
+      return raw ? value : [`${key}=${value}`];
+    } else if (typeof value === "number" || typeof value === "boolean" || value == null) {
+      return raw ? value : [`${key}=${value}`];
+    } else if (isRef(value)) {
+      value = formatProp(key, toRaw(value.value), true);
+      return raw ? value : [`${key}=Ref<`, value, `>`];
+    } else if (isFunction(value)) {
+      return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
     } else {
-      keys = Object.keys(val);
-      i = keys.length;
-      while (i--) { _traverse(val[keys[i]], seen); }
+      value = toRaw(value);
+      return raw ? value : [`${key}=`, value];
     }
   }
-
-  /*  */
-
-  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
+  function assertNumber(val, type) {
+    if (val === void 0) {
+      return;
+    } else if (typeof val !== "number") {
+      warn$1(`${type} is not a valid number - got ${JSON.stringify(val)}.`);
+    } else if (isNaN(val)) {
+      warn$1(`${type} is NaN - the duration expression might be incorrect.`);
+    }
+  }
+
+  const ErrorCodes = {
+    "SETUP_FUNCTION": 0,
+    "0": "SETUP_FUNCTION",
+    "RENDER_FUNCTION": 1,
+    "1": "RENDER_FUNCTION",
+    "NATIVE_EVENT_HANDLER": 5,
+    "5": "NATIVE_EVENT_HANDLER",
+    "COMPONENT_EVENT_HANDLER": 6,
+    "6": "COMPONENT_EVENT_HANDLER",
+    "VNODE_HOOK": 7,
+    "7": "VNODE_HOOK",
+    "DIRECTIVE_HOOK": 8,
+    "8": "DIRECTIVE_HOOK",
+    "TRANSITION_HOOK": 9,
+    "9": "TRANSITION_HOOK",
+    "APP_ERROR_HANDLER": 10,
+    "10": "APP_ERROR_HANDLER",
+    "APP_WARN_HANDLER": 11,
+    "11": "APP_WARN_HANDLER",
+    "FUNCTION_REF": 12,
+    "12": "FUNCTION_REF",
+    "ASYNC_COMPONENT_LOADER": 13,
+    "13": "ASYNC_COMPONENT_LOADER",
+    "SCHEDULER": 14,
+    "14": "SCHEDULER",
+    "COMPONENT_UPDATE": 15,
+    "15": "COMPONENT_UPDATE",
+    "APP_UNMOUNT_CLEANUP": 16,
+    "16": "APP_UNMOUNT_CLEANUP"
+  };
+  const ErrorTypeStrings$1 = {
+    ["sp"]: "serverPrefetch hook",
+    ["bc"]: "beforeCreate hook",
+    ["c"]: "created hook",
+    ["bm"]: "beforeMount hook",
+    ["m"]: "mounted hook",
+    ["bu"]: "beforeUpdate hook",
+    ["u"]: "updated",
+    ["bum"]: "beforeUnmount hook",
+    ["um"]: "unmounted hook",
+    ["a"]: "activated hook",
+    ["da"]: "deactivated hook",
+    ["ec"]: "errorCaptured hook",
+    ["rtc"]: "renderTracked hook",
+    ["rtg"]: "renderTriggered hook",
+    [0]: "setup function",
+    [1]: "render function",
+    [2]: "watcher getter",
+    [3]: "watcher callback",
+    [4]: "watcher cleanup function",
+    [5]: "native event handler",
+    [6]: "component event handler",
+    [7]: "vnode hook",
+    [8]: "directive hook",
+    [9]: "transition hook",
+    [10]: "app errorHandler",
+    [11]: "app warnHandler",
+    [12]: "ref function",
+    [13]: "async component loader",
+    [14]: "scheduler flush",
+    [15]: "component update",
+    [16]: "app unmount cleanup function"
+  };
+  function callWithErrorHandling(fn, instance, type, args) {
+    try {
+      return args ? fn(...args) : fn();
+    } catch (err) {
+      handleError(err, instance, type);
     }
-  });
-
-  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;
+  }
+  function callWithAsyncErrorHandling(fn, instance, type, args) {
+    if (isFunction(fn)) {
+      const res = callWithErrorHandling(fn, instance, type, args);
+      if (res && isPromise(res)) {
+        res.catch((err) => {
+          handleError(err, instance, type);
+        });
       }
+      return res;
     }
-    for (name in oldOn) {
-      if (isUndef(on[name])) {
-        event = normalizeEvent(name);
-        remove$$1(event.name, oldOn[name], event.capture);
+    if (isArray(fn)) {
+      const values = [];
+      for (let i = 0; i < fn.length; i++) {
+        values.push(callWithAsyncErrorHandling(fn[i], instance, type, args));
       }
+      return values;
+    } else {
+      warn$1(
+        `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`
+      );
     }
   }
-
-  /*  */
-
-  function mergeVNodeHook (def, hookKey, hook) {
-    if (def instanceof VNode) {
-      def = def.data.hook || (def.data.hook = {});
+  function handleError(err, instance, type, throwInDev = true) {
+    const contextVNode = instance ? instance.vnode : null;
+    const { errorHandler, throwUnhandledErrorInProduction } = instance && instance.appContext.config || EMPTY_OBJ;
+    if (instance) {
+      let cur = instance.parent;
+      const exposedInstance = instance.proxy;
+      const errorInfo = ErrorTypeStrings$1[type] ;
+      while (cur) {
+        const errorCapturedHooks = cur.ec;
+        if (errorCapturedHooks) {
+          for (let i = 0; i < errorCapturedHooks.length; i++) {
+            if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
+              return;
+            }
+          }
+        }
+        cur = cur.parent;
+      }
+      if (errorHandler) {
+        pauseTracking();
+        callWithErrorHandling(errorHandler, null, 10, [
+          err,
+          exposedInstance,
+          errorInfo
+        ]);
+        resetTracking();
+        return;
+      }
     }
-    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);
+    logError(err, type, contextVNode, throwInDev, throwUnhandledErrorInProduction);
+  }
+  function logError(err, type, contextVNode, throwInDev = true, throwInProd = false) {
+    {
+      const info = ErrorTypeStrings$1[type];
+      if (contextVNode) {
+        pushWarningContext(contextVNode);
+      }
+      warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
+      if (contextVNode) {
+        popWarningContext();
+      }
+      if (throwInDev) {
+        throw err;
+      } else {
+        console.error(err);
+      }
+    }
+  }
+
+  const queue = [];
+  let flushIndex = -1;
+  const pendingPostFlushCbs = [];
+  let activePostFlushCbs = null;
+  let postFlushIndex = 0;
+  const resolvedPromise = /* @__PURE__ */ Promise.resolve();
+  let currentFlushPromise = null;
+  const RECURSION_LIMIT = 100;
+  function nextTick(fn) {
+    const p = currentFlushPromise || resolvedPromise;
+    return fn ? p.then(this ? fn.bind(this) : fn) : p;
+  }
+  function findInsertionIndex(id) {
+    let start = flushIndex + 1;
+    let end = queue.length;
+    while (start < end) {
+      const middle = start + end >>> 1;
+      const middleJob = queue[middle];
+      const middleJobId = getId(middleJob);
+      if (middleJobId < id || middleJobId === id && middleJob.flags & 2) {
+        start = middle + 1;
+      } else {
+        end = middle;
+      }
     }
-
-    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);
+    return start;
+  }
+  function queueJob(job) {
+    if (!(job.flags & 1)) {
+      const jobId = getId(job);
+      const lastJob = queue[queue.length - 1];
+      if (!lastJob || // fast path when the job id is larger than the tail
+      !(job.flags & 2) && jobId >= getId(lastJob)) {
+        queue.push(job);
       } else {
-        // existing plain hook
-        invoker = createFnInvoker([oldHook, wrappedHook]);
+        queue.splice(findInsertionIndex(jobId), 0, job);
       }
+      job.flags |= 1;
+      queueFlush();
     }
-
-    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
+  function queueFlush() {
+    if (!currentFlushPromise) {
+      currentFlushPromise = resolvedPromise.then(flushJobs);
     }
-    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);
+  }
+  function queuePostFlushCb(cb) {
+    if (!isArray(cb)) {
+      if (activePostFlushCbs && cb.id === -1) {
+        activePostFlushCbs.splice(postFlushIndex + 1, 0, cb);
+      } else if (!(cb.flags & 1)) {
+        pendingPostFlushCbs.push(cb);
+        cb.flags |= 1;
       }
+    } else {
+      pendingPostFlushCbs.push(...cb);
     }
-    return res
+    queueFlush();
   }
-
-  function checkProp (
-    res,
-    hash,
-    key,
-    altKey,
-    preserve
-  ) {
-    if (isDef(hash)) {
-      if (hasOwn(hash, key)) {
-        res[key] = hash[key];
-        if (!preserve) {
-          delete hash[key];
+  function flushPreFlushCbs(instance, seen, i = flushIndex + 1) {
+    {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    for (; i < queue.length; i++) {
+      const cb = queue[i];
+      if (cb && cb.flags & 2) {
+        if (instance && cb.id !== instance.uid) {
+          continue;
         }
-        return true
-      } else if (hasOwn(hash, altKey)) {
-        res[key] = hash[altKey];
-        if (!preserve) {
-          delete hash[altKey];
+        if (checkRecursiveUpdates(seen, cb)) {
+          continue;
+        }
+        queue.splice(i, 1);
+        i--;
+        if (cb.flags & 4) {
+          cb.flags &= -2;
+        }
+        cb();
+        if (!(cb.flags & 4)) {
+          cb.flags &= -2;
         }
-        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)
+  function flushPostFlushCbs(seen) {
+    if (pendingPostFlushCbs.length) {
+      const deduped = [...new Set(pendingPostFlushCbs)].sort(
+        (a, b) => getId(a) - getId(b)
+      );
+      pendingPostFlushCbs.length = 0;
+      if (activePostFlushCbs) {
+        activePostFlushCbs.push(...deduped);
+        return;
+      }
+      activePostFlushCbs = deduped;
+      {
+        seen = seen || /* @__PURE__ */ new Map();
+      }
+      for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
+        const cb = activePostFlushCbs[postFlushIndex];
+        if (checkRecursiveUpdates(seen, cb)) {
+          continue;
+        }
+        if (cb.flags & 4) {
+          cb.flags &= -2;
+        }
+        if (!(cb.flags & 8)) cb();
+        cb.flags &= -2;
       }
+      activePostFlushCbs = null;
+      postFlushIndex = 0;
     }
-    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();
+  const getId = (job) => job.id == null ? job.flags & 2 ? -1 : Infinity : job.id;
+  function flushJobs(seen) {
+    {
+      seen = seen || /* @__PURE__ */ new Map();
+    }
+    const check = (job) => checkRecursiveUpdates(seen, job) ;
+    try {
+      for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
+        const job = queue[flushIndex];
+        if (job && !(job.flags & 8)) {
+          if (check(job)) {
+            continue;
           }
-          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 + "__";
+          if (job.flags & 4) {
+            job.flags &= ~1;
           }
-          res.push(c);
+          callWithErrorHandling(
+            job,
+            job.i,
+            job.i ? 15 : 14
+          );
+          if (!(job.flags & 4)) {
+            job.flags &= ~1;
+          }
+        }
+      }
+    } finally {
+      for (; flushIndex < queue.length; flushIndex++) {
+        const job = queue[flushIndex];
+        if (job) {
+          job.flags &= -2;
         }
       }
+      flushIndex = -1;
+      queue.length = 0;
+      flushPostFlushCbs(seen);
+      currentFlushPromise = null;
+      if (queue.length || pendingPostFlushCbs.length) {
+        flushJobs(seen);
+      }
     }
-    return res
   }
-
-  /*  */
-
-  function initProvide (vm) {
-    var provide = vm.$options.provide;
-    if (provide) {
-      vm._provided = typeof provide === 'function'
-        ? provide.call(vm)
-        : provide;
+  function checkRecursiveUpdates(seen, fn) {
+    const count = seen.get(fn) || 0;
+    if (count > RECURSION_LIMIT) {
+      const instance = fn.i;
+      const componentName = instance && getComponentName(instance.type);
+      handleError(
+        `Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`,
+        null,
+        10
+      );
+      return true;
     }
+    seen.set(fn, count + 1);
+    return false;
   }
 
-  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
+  let isHmrUpdating = false;
+  const hmrDirtyComponents = /* @__PURE__ */ new Map();
+  {
+    getGlobalThis().__VUE_HMR_RUNTIME__ = {
+      createRecord: tryWrap(createRecord),
+      rerender: tryWrap(rerender),
+      reload: tryWrap(reload)
+    };
+  }
+  const map = /* @__PURE__ */ new Map();
+  function registerHMR(instance) {
+    const id = instance.type.__hmrId;
+    let record = map.get(id);
+    if (!record) {
+      createRecord(id, instance.type);
+      record = map.get(id);
     }
+    record.instances.add(instance);
   }
-
-  /*  */
-
-
-
-  /**
-   * 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);
+  function unregisterHMR(instance) {
+    map.get(instance.type.__hmrId).instances.delete(instance);
+  }
+  function createRecord(id, initialDef) {
+    if (map.has(id)) {
+      return false;
+    }
+    map.set(id, {
+      initialDef: normalizeClassComponent(initialDef),
+      instances: /* @__PURE__ */ new Set()
+    });
+    return true;
+  }
+  function normalizeClassComponent(component) {
+    return isClassComponent(component) ? component.__vccOpts : component;
+  }
+  function rerender(id, newRender) {
+    const record = map.get(id);
+    if (!record) {
+      return;
+    }
+    record.initialDef.render = newRender;
+    [...record.instances].forEach((instance) => {
+      if (newRender) {
+        instance.render = newRender;
+        normalizeClassComponent(instance.type).render = newRender;
+      }
+      instance.renderCache = [];
+      isHmrUpdating = true;
+      instance.update();
+      isHmrUpdating = false;
+    });
+  }
+  function reload(id, newComp) {
+    const record = map.get(id);
+    if (!record) return;
+    newComp = normalizeClassComponent(newComp);
+    updateComponentDef(record.initialDef, newComp);
+    const instances = [...record.instances];
+    for (let i = 0; i < instances.length; i++) {
+      const instance = instances[i];
+      const oldComp = normalizeClassComponent(instance.type);
+      let dirtyInstances = hmrDirtyComponents.get(oldComp);
+      if (!dirtyInstances) {
+        if (oldComp !== record.initialDef) {
+          updateComponentDef(oldComp, newComp);
         }
+        hmrDirtyComponents.set(oldComp, dirtyInstances = /* @__PURE__ */ new Set());
+      }
+      dirtyInstances.add(instance);
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
+      instance.appContext.optionsCache.delete(instance.type);
+      if (instance.ceReload) {
+        dirtyInstances.add(instance);
+        instance.ceReload(newComp.styles);
+        dirtyInstances.delete(instance);
+      } else if (instance.parent) {
+        queueJob(() => {
+          isHmrUpdating = true;
+          instance.parent.update();
+          isHmrUpdating = false;
+          dirtyInstances.delete(instance);
+        });
+      } else if (instance.appContext.reload) {
+        instance.appContext.reload();
+      } else if (typeof window !== "undefined") {
+        window.location.reload();
       } else {
-        (slots.default || (slots.default = [])).push(child);
+        console.warn(
+          "[HMR] Root or manually mounted instance modified. Full reload required."
+        );
+      }
+      if (instance.root.ce && instance !== instance.root) {
+        instance.root.ce._removeChildStyle(oldComp);
       }
     }
-    // ignore slots that contains only whitespace
-    for (var name$1 in slots) {
-      if (slots[name$1].every(isWhitespace)) {
-        delete slots[name$1];
+    queuePostFlushCb(() => {
+      hmrDirtyComponents.clear();
+    });
+  }
+  function updateComponentDef(oldComp, newComp) {
+    extend(oldComp, newComp);
+    for (const key in oldComp) {
+      if (key !== "__file" && !(key in newComp)) {
+        delete oldComp[key];
       }
     }
-    return slots
   }
-
-  function isWhitespace (node) {
-    return (node.isComment && !node.asyncFactory) || node.text === ' '
+  function tryWrap(fn) {
+    return (id, arg) => {
+      try {
+        return fn(id, arg);
+      } catch (e) {
+        console.error(e);
+        console.warn(
+          `[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
+        );
+      }
+    };
   }
 
-  /*  */
-
-  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
+  let devtools$1;
+  let buffer = [];
+  let devtoolsNotInstalled = false;
+  function emit$1(event, ...args) {
+    if (devtools$1) {
+      devtools$1.emit(event, ...args);
+    } else if (!devtoolsNotInstalled) {
+      buffer.push({ event, args });
+    }
+  }
+  function setDevtoolsHook$1(hook, target) {
+    var _a, _b;
+    devtools$1 = hook;
+    if (devtools$1) {
+      devtools$1.enabled = true;
+      buffer.forEach(({ event, args }) => devtools$1.emit(event, ...args));
+      buffer = [];
     } else if (
-      isStable &&
-      prevSlots &&
-      prevSlots !== emptyObject &&
-      key === prevSlots.$key &&
-      !hasNormalSlots &&
-      !prevSlots.$hasNormal
+      // handle late devtools injection - only do this if we are in an actual
+      // browser environment to avoid the timer handle stalling test runner exit
+      // (#4815)
+      typeof window !== "undefined" && // some envs mock window but not fully
+      window.HTMLElement && // also exclude jsdom
+      // eslint-disable-next-line no-restricted-syntax
+      !((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
     ) {
-      // 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
+      const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
+      replay.push((newHook) => {
+        setDevtoolsHook$1(newHook, target);
       });
+      setTimeout(() => {
+        if (!devtools$1) {
+          target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
+          devtoolsNotInstalled = true;
+          buffer = [];
+        }
+      }, 3e3);
+    } else {
+      devtoolsNotInstalled = true;
+      buffer = [];
     }
-    return normalized
   }
-
-  function proxyNormalSlot(slots, key) {
-    return function () { return slots[key]; }
+  function devtoolsInitApp(app, version) {
+    emit$1("app:init" /* APP_INIT */, app, version, {
+      Fragment,
+      Text,
+      Comment,
+      Static
+    });
+  }
+  function devtoolsUnmountApp(app) {
+    emit$1("app:unmount" /* APP_UNMOUNT */, app);
+  }
+  const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */);
+  const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
+  const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
+    "component:removed" /* COMPONENT_REMOVED */
+  );
+  const devtoolsComponentRemoved = (component) => {
+    if (devtools$1 && typeof devtools$1.cleanupBuffer === "function" && // remove the component if it wasn't buffered
+    !devtools$1.cleanupBuffer(component)) {
+      _devtoolsComponentRemoved(component);
+    }
+  };
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function createDevtoolsComponentHook(hook) {
+    return (component) => {
+      emit$1(
+        hook,
+        component.appContext.app,
+        component.uid,
+        component.parent ? component.parent.uid : void 0,
+        component
+      );
+    };
+  }
+  const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */);
+  const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */);
+  function createDevtoolsPerformanceHook(hook) {
+    return (component, type, time) => {
+      emit$1(hook, component.appContext.app, component.uid, component, type, time);
+    };
+  }
+  function devtoolsComponentEmit(component, event, params) {
+    emit$1(
+      "component:emit" /* COMPONENT_EMIT */,
+      component.appContext.app,
+      component,
+      event,
+      params
+    );
   }
 
-  /*  */
-
-  /**
-   * 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);
+  let currentRenderingInstance = null;
+  let currentScopeId = null;
+  function setCurrentRenderingInstance(instance) {
+    const prev = currentRenderingInstance;
+    currentRenderingInstance = instance;
+    currentScopeId = instance && instance.type.__scopeId || null;
+    return prev;
+  }
+  function pushScopeId(id) {
+    currentScopeId = id;
+  }
+  function popScopeId() {
+    currentScopeId = null;
+  }
+  const withScopeId = (_id) => withCtx;
+  function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
+    if (!ctx) return fn;
+    if (fn._n) {
+      return fn;
+    }
+    const renderFnWithContext = (...args) => {
+      if (renderFnWithContext._d) {
+        setBlockTracking(-1);
       }
-    } else if (typeof val === 'number') {
-      ret = new Array(val);
-      for (i = 0; i < val; i++) {
-        ret[i] = render(i + 1, i);
+      const prevInstance = setCurrentRenderingInstance(ctx);
+      let res;
+      try {
+        res = fn(...args);
+      } finally {
+        setCurrentRenderingInstance(prevInstance);
+        if (renderFnWithContext._d) {
+          setBlockTracking(1);
+        }
+      }
+      {
+        devtoolsComponentUpdated(ctx);
       }
-    } 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();
+      return res;
+    };
+    renderFnWithContext._n = true;
+    renderFnWithContext._c = true;
+    renderFnWithContext._d = true;
+    return renderFnWithContext;
+  }
+
+  function validateDirectiveName(name) {
+    if (isBuiltInDirective(name)) {
+      warn$1("Do not use built-in directive ids as custom directive id: " + name);
+    }
+  }
+  function withDirectives(vnode, directives) {
+    if (currentRenderingInstance === null) {
+      warn$1(`withDirectives can only be used inside render functions.`);
+      return vnode;
+    }
+    const instance = getComponentPublicInstance(currentRenderingInstance);
+    const bindings = vnode.dirs || (vnode.dirs = []);
+    for (let i = 0; i < directives.length; i++) {
+      let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
+      if (dir) {
+        if (isFunction(dir)) {
+          dir = {
+            mounted: dir,
+            updated: dir
+          };
         }
-      } 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 (dir.deep) {
+          traverse(value);
         }
+        bindings.push({
+          dir,
+          instance,
+          value,
+          oldValue: void 0,
+          arg,
+          modifiers
+        });
       }
     }
-    if (!isDef(ret)) {
-      ret = [];
+    return vnode;
+  }
+  function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+    const bindings = vnode.dirs;
+    const oldBindings = prevVNode && prevVNode.dirs;
+    for (let i = 0; i < bindings.length; i++) {
+      const binding = bindings[i];
+      if (oldBindings) {
+        binding.oldValue = oldBindings[i].value;
+      }
+      let hook = binding.dir[name];
+      if (hook) {
+        pauseTracking();
+        callWithAsyncErrorHandling(hook, instance, 8, [
+          vnode.el,
+          binding,
+          vnode,
+          prevVNode
+        ]);
+        resetTracking();
+      }
     }
-    (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
+  const TeleportEndKey = Symbol("_vte");
+  const isTeleport = (type) => type.__isTeleport;
+  const isTeleportDisabled = (props) => props && (props.disabled || props.disabled === "");
+  const isTeleportDeferred = (props) => props && (props.defer || props.defer === "");
+  const isTargetSVG = (target) => typeof SVGElement !== "undefined" && target instanceof SVGElement;
+  const isTargetMathML = (target) => typeof MathMLElement === "function" && target instanceof MathMLElement;
+  const resolveTarget = (props, select) => {
+    const targetSelector = props && props.to;
+    if (isString(targetSelector)) {
+      if (!select) {
+        warn$1(
+          `Current renderer does not support string target for Teleports. (missing querySelector renderer option)`
+        );
+        return null;
+      } else {
+        const target = select(targetSelector);
+        if (!target && !isTeleportDisabled(props)) {
+          warn$1(
+            `Failed to locate Teleport target with selector "${targetSelector}". Note the target element must exist before the component is mounted - i.e. the target cannot be rendered by the component itself, and ideally should be outside of the entire Vue component tree.`
           );
         }
-        props = extend(extend({}, bindObject), props);
+        return target;
       }
-      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
+      if (!targetSelector && !isTeleportDisabled(props)) {
+        warn$1(`Invalid Teleport target: ${targetSelector}`);
+      }
+      return targetSelector;
     }
-  }
-
-  /*  */
-
-  /**
-   * 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)) {
-        warn(
-          'v-bind without argument expects an Object or Array value',
-          this
-        );
+  };
+  const TeleportImpl = {
+    name: "Teleport",
+    __isTeleport: true,
+    process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, internals) {
+      const {
+        mc: mountChildren,
+        pc: patchChildren,
+        pbc: patchBlockChildren,
+        o: { insert, querySelector, createText, createComment }
+      } = internals;
+      const disabled = isTeleportDisabled(n2.props);
+      let { shapeFlag, children, dynamicChildren } = n2;
+      if (isHmrUpdating) {
+        optimized = false;
+        dynamicChildren = null;
+      }
+      if (n1 == null) {
+        const placeholder = n2.el = createComment("teleport start") ;
+        const mainAnchor = n2.anchor = createComment("teleport end") ;
+        insert(placeholder, container, anchor);
+        insert(mainAnchor, container, anchor);
+        const mount = (container2, anchor2) => {
+          if (shapeFlag & 16) {
+            if (parentComponent && parentComponent.isCE) {
+              parentComponent.ce._teleportTarget = container2;
+            }
+            mountChildren(
+              children,
+              container2,
+              anchor2,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          }
+        };
+        const mountToTarget = () => {
+          const target = n2.target = resolveTarget(n2.props, querySelector);
+          const targetAnchor = prepareAnchor(target, n2, createText, insert);
+          if (target) {
+            if (namespace !== "svg" && isTargetSVG(target)) {
+              namespace = "svg";
+            } else if (namespace !== "mathml" && isTargetMathML(target)) {
+              namespace = "mathml";
+            }
+            if (!disabled) {
+              mount(target, targetAnchor);
+              updateCssVars(n2, false);
+            }
+          } else if (!disabled) {
+            warn$1(
+              "Invalid Teleport target on mount:",
+              target,
+              `(${typeof target})`
+            );
+          }
+        };
+        if (disabled) {
+          mount(container, mainAnchor);
+          updateCssVars(n2, true);
+        }
+        if (isTeleportDeferred(n2.props)) {
+          n2.el.__isMounted = false;
+          queuePostRenderEffect(() => {
+            mountToTarget();
+            delete n2.el.__isMounted;
+          }, parentSuspense);
+        } else {
+          mountToTarget();
+        }
       } else {
-        if (Array.isArray(value)) {
-          value = toObject(value);
-        }
-        var hash;
-        var loop = function ( key ) {
-          if (
-            key === 'class' ||
-            key === 'style' ||
-            isReservedAttribute(key)
-          ) {
-            hash = data;
+        if (isTeleportDeferred(n2.props) && n1.el.__isMounted === false) {
+          queuePostRenderEffect(() => {
+            TeleportImpl.process(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized,
+              internals
+            );
+          }, parentSuspense);
+          return;
+        }
+        n2.el = n1.el;
+        n2.targetStart = n1.targetStart;
+        const mainAnchor = n2.anchor = n1.anchor;
+        const target = n2.target = n1.target;
+        const targetAnchor = n2.targetAnchor = n1.targetAnchor;
+        const wasDisabled = isTeleportDisabled(n1.props);
+        const currentContainer = wasDisabled ? container : target;
+        const currentAnchor = wasDisabled ? mainAnchor : targetAnchor;
+        if (namespace === "svg" || isTargetSVG(target)) {
+          namespace = "svg";
+        } else if (namespace === "mathml" || isTargetMathML(target)) {
+          namespace = "mathml";
+        }
+        if (dynamicChildren) {
+          patchBlockChildren(
+            n1.dynamicChildren,
+            dynamicChildren,
+            currentContainer,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds
+          );
+          traverseStaticChildren(n1, n2, false);
+        } else if (!optimized) {
+          patchChildren(
+            n1,
+            n2,
+            currentContainer,
+            currentAnchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            false
+          );
+        }
+        if (disabled) {
+          if (!wasDisabled) {
+            moveTeleport(
+              n2,
+              container,
+              mainAnchor,
+              internals,
+              1
+            );
           } 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 (n2.props && n1.props && n2.props.to !== n1.props.to) {
+              n2.props.to = n1.props.to;
             }
           }
-        };
-
-        for (var key in value) loop( key );
+        } else {
+          if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
+            const nextTarget = n2.target = resolveTarget(
+              n2.props,
+              querySelector
+            );
+            if (nextTarget) {
+              moveTeleport(
+                n2,
+                nextTarget,
+                null,
+                internals,
+                0
+              );
+            } else {
+              warn$1(
+                "Invalid Teleport target on update:",
+                target,
+                `(${typeof target})`
+              );
+            }
+          } else if (wasDisabled) {
+            moveTeleport(
+              n2,
+              target,
+              targetAnchor,
+              internals,
+              1
+            );
+          }
+        }
+        updateCssVars(n2, disabled);
+      }
+    },
+    remove(vnode, parentComponent, parentSuspense, { um: unmount, o: { remove: hostRemove } }, doRemove) {
+      const {
+        shapeFlag,
+        children,
+        anchor,
+        targetStart,
+        targetAnchor,
+        target,
+        props
+      } = vnode;
+      if (target) {
+        hostRemove(targetStart);
+        hostRemove(targetAnchor);
+      }
+      doRemove && hostRemove(anchor);
+      if (shapeFlag & 16) {
+        const shouldRemove = doRemove || !isTeleportDisabled(props);
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+          unmount(
+            child,
+            parentComponent,
+            parentSuspense,
+            shouldRemove,
+            !!child.dynamicChildren
+          );
+        }
+      }
+    },
+    move: moveTeleport,
+    hydrate: hydrateTeleport
+  };
+  function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2) {
+    if (moveType === 0) {
+      insert(vnode.targetAnchor, container, parentAnchor);
+    }
+    const { el, anchor, shapeFlag, children, props } = vnode;
+    const isReorder = moveType === 2;
+    if (isReorder) {
+      insert(el, container, parentAnchor);
+    }
+    if (!isReorder || isTeleportDisabled(props)) {
+      if (shapeFlag & 16) {
+        for (let i = 0; i < children.length; i++) {
+          move(
+            children[i],
+            container,
+            parentAnchor,
+            2
+          );
+        }
       }
     }
-    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
+    if (isReorder) {
+      insert(anchor, container, parentAnchor);
     }
-    // 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
+  }
+  function hydrateTeleport(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, {
+    o: { nextSibling, parentNode, querySelector, insert, createText }
+  }, hydrateChildren) {
+    const target = vnode.target = resolveTarget(
+      vnode.props,
+      querySelector
     );
-    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);
+    if (target) {
+      const disabled = isTeleportDisabled(vnode.props);
+      const targetNode = target._lpa || target.firstChild;
+      if (vnode.shapeFlag & 16) {
+        if (disabled) {
+          vnode.anchor = hydrateChildren(
+            nextSibling(node),
+            vnode,
+            parentNode(node),
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
+          vnode.targetStart = targetNode;
+          vnode.targetAnchor = targetNode && nextSibling(targetNode);
+        } else {
+          vnode.anchor = nextSibling(node);
+          let targetAnchor = targetNode;
+          while (targetAnchor) {
+            if (targetAnchor && targetAnchor.nodeType === 8) {
+              if (targetAnchor.data === "teleport start anchor") {
+                vnode.targetStart = targetAnchor;
+              } else if (targetAnchor.data === "teleport anchor") {
+                vnode.targetAnchor = targetAnchor;
+                target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+                break;
+              }
+            }
+            targetAnchor = nextSibling(targetAnchor);
+          }
+          if (!vnode.targetAnchor) {
+            prepareAnchor(target, vnode, createText, insert);
+          }
+          hydrateChildren(
+            targetNode && nextSibling(targetNode),
+            vnode,
+            target,
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
         }
       }
-    } else {
-      markStaticNode(tree, key, isOnce);
+      updateCssVars(vnode, disabled);
     }
+    return vnode.anchor && nextSibling(vnode.anchor);
   }
-
-  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
-        );
+  const Teleport = TeleportImpl;
+  function updateCssVars(vnode, isDisabled) {
+    const ctx = vnode.ctx;
+    if (ctx && ctx.ut) {
+      let node, anchor;
+      if (isDisabled) {
+        node = vnode.el;
+        anchor = vnode.anchor;
       } 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;
-        }
+        node = vnode.targetStart;
+        anchor = vnode.targetAnchor;
       }
-    }
-    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;
+      while (node && node !== anchor) {
+        if (node.nodeType === 1) node.setAttribute("data-v-owner", ctx.uid);
+        node = node.nextSibling;
       }
+      ctx.ut();
     }
-    if (contentHashKey) {
-      (res).$key = contentHashKey;
+  }
+  function prepareAnchor(target, vnode, createText, insert) {
+    const targetStart = vnode.targetStart = createText("");
+    const targetAnchor = vnode.targetAnchor = createText("");
+    targetStart[TeleportEndKey] = targetAnchor;
+    if (target) {
+      insert(targetStart, target);
+      insert(targetAnchor, target);
     }
-    return res
+    return targetAnchor;
   }
 
-  /*  */
-
-  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 speical 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;
+  const leaveCbKey = Symbol("_leaveCb");
+  const enterCbKey$1 = Symbol("_enterCb");
+  function useTransitionState() {
+    const state = {
+      isMounted: false,
+      isLeaving: false,
+      isUnmounting: false,
+      leavingVNodes: /* @__PURE__ */ new Map()
+    };
+    onMounted(() => {
+      state.isMounted = true;
+    });
+    onBeforeUnmount(() => {
+      state.isUnmounting = true;
+    });
+    return state;
   }
-
-  /*  */
-
-  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)
+  const TransitionHookValidator = [Function, Array];
+  const BaseTransitionPropsValidators = {
+    mode: String,
+    appear: Boolean,
+    persisted: Boolean,
+    // enter
+    onBeforeEnter: TransitionHookValidator,
+    onEnter: TransitionHookValidator,
+    onAfterEnter: TransitionHookValidator,
+    onEnterCancelled: TransitionHookValidator,
+    // leave
+    onBeforeLeave: TransitionHookValidator,
+    onLeave: TransitionHookValidator,
+    onAfterLeave: TransitionHookValidator,
+    onLeaveCancelled: TransitionHookValidator,
+    // appear
+    onBeforeAppear: TransitionHookValidator,
+    onAppear: TransitionHookValidator,
+    onAfterAppear: TransitionHookValidator,
+    onAppearCancelled: TransitionHookValidator
+  };
+  const recursiveGetSubtree = (instance) => {
+    const subTree = instance.subTree;
+    return subTree.component ? recursiveGetSubtree(subTree.component) : subTree;
+  };
+  const BaseTransitionImpl = {
+    name: `BaseTransition`,
+    props: BaseTransitionPropsValidators,
+    setup(props, { slots }) {
+      const instance = getCurrentInstance();
+      const state = useTransitionState();
+      return () => {
+        const children = slots.default && getTransitionRawChildren(slots.default(), true);
+        if (!children || !children.length) {
+          return;
+        }
+        const child = findNonCommentChild(children);
+        const rawProps = toRaw(props);
+        const { mode } = rawProps;
+        if (mode && mode !== "in-out" && mode !== "out-in" && mode !== "default") {
+          warn$1(`invalid <transition> mode: ${mode}`);
+        }
+        if (state.isLeaving) {
+          return emptyPlaceholder(child);
+        }
+        const innerChild = getInnerChild$1(child);
+        if (!innerChild) {
+          return emptyPlaceholder(child);
+        }
+        let enterHooks = resolveTransitionHooks(
+          innerChild,
+          rawProps,
+          state,
+          instance,
+          // #11061, ensure enterHooks is fresh after clone
+          (hooks) => enterHooks = hooks
         );
-      }
-      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;
+        if (innerChild.type !== Comment) {
+          setTransitionHooks(innerChild, enterHooks);
+        }
+        let oldInnerChild = instance.subTree && getInnerChild$1(instance.subTree);
+        if (oldInnerChild && oldInnerChild.type !== Comment && !isSameVNodeType(innerChild, oldInnerChild) && recursiveGetSubtree(instance).type !== Comment) {
+          let leavingHooks = resolveTransitionHooks(
+            oldInnerChild,
+            rawProps,
+            state,
+            instance
+          );
+          setTransitionHooks(oldInnerChild, leavingHooks);
+          if (mode === "out-in" && innerChild.type !== Comment) {
+            state.isLeaving = true;
+            leavingHooks.afterLeave = () => {
+              state.isLeaving = false;
+              if (!(instance.job.flags & 8)) {
+                instance.update();
+              }
+              delete leavingHooks.afterLeave;
+              oldInnerChild = void 0;
+            };
+            return emptyPlaceholder(child);
+          } else if (mode === "in-out" && innerChild.type !== Comment) {
+            leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => {
+              const leavingVNodesCache = getLeavingNodesForType(
+                state,
+                oldInnerChild
+              );
+              leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild;
+              el[leaveCbKey] = () => {
+                earlyRemove();
+                el[leaveCbKey] = void 0;
+                delete enterHooks.delayedLeave;
+                oldInnerChild = void 0;
+              };
+              enterHooks.delayedLeave = () => {
+                delayedLeave();
+                delete enterHooks.delayedLeave;
+                oldInnerChild = void 0;
+              };
+            };
+          } else {
+            oldInnerChild = void 0;
+          }
+        } else if (oldInnerChild) {
+          oldInnerChild = void 0;
         }
-        return vnode
+        return child;
       };
-    } 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 findNonCommentChild(children) {
+    let child = children[0];
+    if (children.length > 1) {
+      let hasFound = false;
+      for (const c of children) {
+        if (c.type !== Comment) {
+          if (hasFound) {
+            warn$1(
+              "<transition> can only be used on a single element or component. Use <transition-group> for lists."
+            );
+            break;
+          }
+          child = c;
+          hasFound = true;
+        }
       }
-      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
+    return child;
+  }
+  const BaseTransition = BaseTransitionImpl;
+  function getLeavingNodesForType(state, vnode) {
+    const { leavingVNodes } = state;
+    let leavingVNodesCache = leavingVNodes.get(vnode.type);
+    if (!leavingVNodesCache) {
+      leavingVNodesCache = /* @__PURE__ */ Object.create(null);
+      leavingVNodes.set(vnode.type, leavingVNodesCache);
+    }
+    return leavingVNodesCache;
+  }
+  function resolveTransitionHooks(vnode, props, state, instance, postClone) {
+    const {
+      appear,
+      mode,
+      persisted = false,
+      onBeforeEnter,
+      onEnter,
+      onAfterEnter,
+      onEnterCancelled,
+      onBeforeLeave,
+      onLeave,
+      onAfterLeave,
+      onLeaveCancelled,
+      onBeforeAppear,
+      onAppear,
+      onAfterAppear,
+      onAppearCancelled
+    } = props;
+    const key = String(vnode.key);
+    const leavingVNodesCache = getLeavingNodesForType(state, vnode);
+    const callHook = (hook, args) => {
+      hook && callWithAsyncErrorHandling(
+        hook,
+        instance,
+        9,
+        args
       );
-    },
-
-    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);
+    };
+    const callAsyncHook = (hook, args) => {
+      const done = args[1];
+      callHook(hook, args);
+      if (isArray(hook)) {
+        if (hook.every((hook2) => hook2.length <= 1)) done();
+      } else if (hook.length <= 1) {
+        done();
+      }
+    };
+    const hooks = {
+      mode,
+      persisted,
+      beforeEnter(el) {
+        let hook = onBeforeEnter;
+        if (!state.isMounted) {
+          if (appear) {
+            hook = onBeforeAppear || onBeforeEnter;
+          } else {
+            return;
+          }
+        }
+        if (el[leaveCbKey]) {
+          el[leaveCbKey](
+            true
+            /* cancelled */
+          );
+        }
+        const leavingVNode = leavingVNodesCache[key];
+        if (leavingVNode && isSameVNodeType(vnode, leavingVNode) && leavingVNode.el[leaveCbKey]) {
+          leavingVNode.el[leaveCbKey]();
+        }
+        callHook(hook, [el]);
+      },
+      enter(el) {
+        let hook = onEnter;
+        let afterHook = onAfterEnter;
+        let cancelHook = onEnterCancelled;
+        if (!state.isMounted) {
+          if (appear) {
+            hook = onAppear || onEnter;
+            afterHook = onAfterAppear || onAfterEnter;
+            cancelHook = onAppearCancelled || onEnterCancelled;
+          } else {
+            return;
+          }
+        }
+        let called = false;
+        const done = el[enterCbKey$1] = (cancelled) => {
+          if (called) return;
+          called = true;
+          if (cancelled) {
+            callHook(cancelHook, [el]);
+          } else {
+            callHook(afterHook, [el]);
+          }
+          if (hooks.delayedLeave) {
+            hooks.delayedLeave();
+          }
+          el[enterCbKey$1] = void 0;
+        };
+        if (hook) {
+          callAsyncHook(hook, [el, done]);
         } else {
-          activateChildComponent(componentInstance, true /* direct */);
+          done();
         }
-      }
-    },
-
-    destroy: function destroy (vnode) {
-      var componentInstance = vnode.componentInstance;
-      if (!componentInstance._isDestroyed) {
-        if (!vnode.data.keepAlive) {
-          componentInstance.$destroy();
+      },
+      leave(el, remove) {
+        const key2 = String(vnode.key);
+        if (el[enterCbKey$1]) {
+          el[enterCbKey$1](
+            true
+            /* cancelled */
+          );
+        }
+        if (state.isUnmounting) {
+          return remove();
+        }
+        callHook(onBeforeLeave, [el]);
+        let called = false;
+        const done = el[leaveCbKey] = (cancelled) => {
+          if (called) return;
+          called = true;
+          remove();
+          if (cancelled) {
+            callHook(onLeaveCancelled, [el]);
+          } else {
+            callHook(onAfterLeave, [el]);
+          }
+          el[leaveCbKey] = void 0;
+          if (leavingVNodesCache[key2] === vnode) {
+            delete leavingVNodesCache[key2];
+          }
+        };
+        leavingVNodesCache[key2] = vnode;
+        if (onLeave) {
+          callAsyncHook(onLeave, [el, done]);
         } else {
-          deactivateChildComponent(componentInstance, true /* direct */);
+          done();
         }
+      },
+      clone(vnode2) {
+        const hooks2 = resolveTransitionHooks(
+          vnode2,
+          props,
+          state,
+          instance,
+          postClone
+        );
+        if (postClone) postClone(hooks2);
+        return hooks2;
       }
+    };
+    return hooks;
+  }
+  function emptyPlaceholder(vnode) {
+    if (isKeepAlive(vnode)) {
+      vnode = cloneVNode(vnode);
+      vnode.children = null;
+      return vnode;
     }
-  };
-
-  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
-        )
+  }
+  function getInnerChild$1(vnode) {
+    if (!isKeepAlive(vnode)) {
+      if (isTeleport(vnode.type) && vnode.children) {
+        return findNonCommentChild(vnode.children);
       }
+      return vnode;
     }
-
-    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)
+    if (vnode.component) {
+      return vnode.component.subTree;
     }
-
-    // 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;
+    const { shapeFlag, children } = vnode;
+    if (children) {
+      if (shapeFlag & 16) {
+        return children[0];
+      }
+      if (shapeFlag & 32 && isFunction(children.default)) {
+        return children.default();
       }
     }
-
-    // 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;
+  function setTransitionHooks(vnode, hooks) {
+    if (vnode.shapeFlag & 6 && vnode.component) {
+      vnode.transition = hooks;
+      setTransitionHooks(vnode.component.subTree, hooks);
+    } else if (vnode.shapeFlag & 128) {
+      vnode.ssContent.transition = hooks.clone(vnode.ssContent);
+      vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
+    } else {
+      vnode.transition = hooks;
+    }
+  }
+  function getTransitionRawChildren(children, keepComment = false, parentKey) {
+    let ret = [];
+    let keyedFragmentCount = 0;
+    for (let i = 0; i < children.length; i++) {
+      let child = children[i];
+      const key = parentKey == null ? child.key : String(parentKey) + String(child.key != null ? child.key : i);
+      if (child.type === Fragment) {
+        if (child.patchFlag & 128) keyedFragmentCount++;
+        ret = ret.concat(
+          getTransitionRawChildren(child.children, keepComment, key)
+        );
+      } else if (keepComment || child.type !== Comment) {
+        ret.push(key != null ? cloneVNode(child, { key }) : child);
+      }
     }
-    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;
+    if (keyedFragmentCount > 1) {
+      for (let i = 0; i < ret.length; i++) {
+        ret[i].patchFlag = -2;
       }
     }
+    return ret;
   }
 
-  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
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineComponent(options, extraOptions) {
+    return isFunction(options) ? (
+      // #8236: extend call and options.name access are considered side-effects
+      // by Rollup, so we have to wrap it in a pure-annotated IIFE.
+      /* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
+    ) : options;
   }
 
-  // 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);
-      }
+  function useId() {
+    const i = getCurrentInstance();
+    if (i) {
+      return (i.appContext.config.idPrefix || "v") + "-" + i.ids[0] + i.ids[1]++;
     } else {
-      on[event] = callback;
+      warn$1(
+        `useId() is called when there is no active component instance to be associated with.`
+      );
     }
+    return "";
   }
-
-  /*  */
-
-  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 markAsyncBoundary(instance) {
+    instance.ids = [instance.ids[0] + instance.ids[2]++ + "-", 0, 0];
   }
 
-  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
-        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);
+  const knownTemplateRefs = /* @__PURE__ */ new WeakSet();
+  function useTemplateRef(key) {
+    const i = getCurrentInstance();
+    const r = shallowRef(null);
+    if (i) {
+      const refs = i.refs === EMPTY_OBJ ? i.refs = {} : i.refs;
+      let desc;
+      if ((desc = Object.getOwnPropertyDescriptor(refs, key)) && !desc.configurable) {
+        warn$1(`useTemplateRef('${key}') already exists.`);
       } 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
-        );
+        Object.defineProperty(refs, key, {
+          enumerable: true,
+          get: () => r.value,
+          set: (val) => r.value = val
+        });
       }
     } 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;
+      warn$1(
+        `useTemplateRef() is called when there is no active component instance to be associated with.`
+      );
     }
-    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);
-        }
-      }
+    const ret = readonly(r) ;
+    {
+      knownTemplateRefs.add(ret);
     }
+    return ret;
   }
 
-  // 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);
+  function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
+    if (isArray(rawRef)) {
+      rawRef.forEach(
+        (r, i) => setRef(
+          r,
+          oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef),
+          parentSuspense,
+          vnode,
+          isUnmount
+        )
+      );
+      return;
     }
-    if (isObject(data.class)) {
-      traverse(data.class);
+    if (isAsyncWrapper(vnode) && !isUnmount) {
+      if (vnode.shapeFlag & 512 && vnode.type.__asyncResolved && vnode.component.subTree.component) {
+        setRef(rawRef, oldRawRef, parentSuspense, vnode.component.subTree);
+      }
+      return;
     }
-  }
-
-  /*  */
-
-  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);
+    const refValue = vnode.shapeFlag & 4 ? getComponentPublicInstance(vnode.component) : vnode.el;
+    const value = isUnmount ? null : refValue;
+    const { i: owner, r: ref } = rawRef;
+    if (!owner) {
+      warn$1(
+        `Missing ref owner context. ref cannot be used on hoisted vnodes. A vnode with ref must be created inside the render function.`
+      );
+      return;
     }
-  }
-
-  var currentRenderingInstance = null;
-
-  function renderMixin (Vue) {
-    // install runtime convenience helpers
-    installRenderHelpers(Vue.prototype);
-
-    Vue.prototype.$nextTick = function (fn) {
-      return nextTick(fn, this)
+    const oldRef = oldRawRef && oldRawRef.r;
+    const refs = owner.refs === EMPTY_OBJ ? owner.refs = {} : owner.refs;
+    const setupState = owner.setupState;
+    const rawSetupState = toRaw(setupState);
+    const canSetSetupRef = setupState === EMPTY_OBJ ? () => false : (key) => {
+      {
+        if (hasOwn(rawSetupState, key) && !isRef(rawSetupState[key])) {
+          warn$1(
+            `Template ref "${key}" used on a non-ref value. It will not work in the production build.`
+          );
+        }
+        if (knownTemplateRefs.has(rawSetupState[key])) {
+          return false;
+        }
+      }
+      return hasOwn(rawSetupState, key);
     };
-
-    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
-        );
+    if (oldRef != null && oldRef !== ref) {
+      if (isString(oldRef)) {
+        refs[oldRef] = null;
+        if (canSetSetupRef(oldRef)) {
+          setupState[oldRef] = null;
+        }
+      } else if (isRef(oldRef)) {
+        oldRef.value = 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 becaues 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;
+    }
+    if (isFunction(ref)) {
+      callWithErrorHandling(ref, owner, 12, [value, refs]);
+    } else {
+      const _isString = isString(ref);
+      const _isRef = isRef(ref);
+      if (_isString || _isRef) {
+        const doSet = () => {
+          if (rawRef.f) {
+            const existing = _isString ? canSetSetupRef(ref) ? setupState[ref] : refs[ref] : ref.value;
+            if (isUnmount) {
+              isArray(existing) && remove(existing, refValue);
+            } else {
+              if (!isArray(existing)) {
+                if (_isString) {
+                  refs[ref] = [refValue];
+                  if (canSetSetupRef(ref)) {
+                    setupState[ref] = refs[ref];
+                  }
+                } else {
+                  ref.value = [refValue];
+                  if (rawRef.k) refs[rawRef.k] = ref.value;
+                }
+              } else if (!existing.includes(refValue)) {
+                existing.push(refValue);
+              }
+            }
+          } else if (_isString) {
+            refs[ref] = value;
+            if (canSetSetupRef(ref)) {
+              setupState[ref] = value;
+            }
+          } else if (_isRef) {
+            ref.value = value;
+            if (rawRef.k) refs[rawRef.k] = value;
+          } else {
+            warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
           }
+        };
+        if (value) {
+          doSet.id = -1;
+          queuePostRenderEffect(doSet, parentSuspense);
         } 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
-          );
+          doSet();
         }
-        vnode = createEmptyVNode();
+      } else {
+        warn$1("Invalid template ref type:", ref, `(${typeof ref})`);
       }
-      // 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);
+  let hasLoggedMismatchError = false;
+  const logMismatchError = () => {
+    if (hasLoggedMismatchError) {
+      return;
     }
-
-    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) : '')
+    console.error("Hydration completed but contains mismatches.");
+    hasLoggedMismatchError = true;
+  };
+  const isSVGContainer = (container) => container.namespaceURI.includes("svg") && container.tagName !== "foreignObject";
+  const isMathMLContainer = (container) => container.namespaceURI.includes("MathML");
+  const getContainerType = (container) => {
+    if (container.nodeType !== 1) return void 0;
+    if (isSVGContainer(container)) return "svg";
+    if (isMathMLContainer(container)) return "mathml";
+    return void 0;
+  };
+  const isComment = (node) => node.nodeType === 8;
+  function createHydrationFunctions(rendererInternals) {
+    const {
+      mt: mountComponent,
+      p: patch,
+      o: {
+        patchProp,
+        createText,
+        nextSibling,
+        parentNode,
+        remove,
+        insert,
+        createComment
+      }
+    } = rendererInternals;
+    const hydrate = (vnode, container) => {
+      if (!container.hasChildNodes()) {
+        warn$1(
+          `Attempting to hydrate existing markup but container is empty. Performing full mount instead.`
         );
-        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);
+        patch(null, vnode, container);
+        flushPostFlushCbs();
+        container._vnode = vnode;
+        return;
+      }
+      hydrateNode(container.firstChild, vnode, null, null, null);
+      flushPostFlushCbs();
+      container._vnode = vnode;
+    };
+    const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
+      optimized = optimized || !!vnode.dynamicChildren;
+      const isFragmentStart = isComment(node) && node.data === "[";
+      const onMismatch = () => handleMismatch(
+        node,
+        vnode,
+        parentComponent,
+        parentSuspense,
+        slotScopeIds,
+        isFragmentStart
+      );
+      const { type, ref, shapeFlag, patchFlag } = vnode;
+      let domType = node.nodeType;
+      vnode.el = node;
+      {
+        def(node, "__vnode", vnode, true);
+        def(node, "__vueParentComponent", parentComponent, true);
+      }
+      if (patchFlag === -2) {
+        optimized = false;
+        vnode.dynamicChildren = null;
+      }
+      let nextNode = null;
+      switch (type) {
+        case Text:
+          if (domType !== 3) {
+            if (vnode.children === "") {
+              insert(vnode.el = createText(""), parentNode(node), node);
+              nextNode = node;
+            } else {
+              nextNode = onMismatch();
+            }
+          } else {
+            if (node.data !== vnode.children) {
+              warn$1(
+                `Hydration text mismatch in`,
+                node.parentNode,
+                `
+  - rendered on server: ${JSON.stringify(
+                node.data
+              )}
+  - expected on client: ${JSON.stringify(vnode.children)}`
+              );
+              logMismatchError();
+              node.data = vnode.children;
+            }
+            nextNode = nextSibling(node);
           }
-        } else if (isPromise(res.component)) {
-          res.component.then(resolve, reject);
-
-          if (isDef(res.error)) {
-            factory.errorComp = ensureCtor(res.error, baseCtor);
+          break;
+        case Comment:
+          if (isTemplateNode(node)) {
+            nextNode = nextSibling(node);
+            replaceNode(
+              vnode.el = node.content.firstChild,
+              node,
+              parentComponent
+            );
+          } else if (domType !== 8 || isFragmentStart) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = nextSibling(node);
           }
-
-          if (isDef(res.loading)) {
-            factory.loadingComp = ensureCtor(res.loading, baseCtor);
-            if (res.delay === 0) {
-              factory.loading = true;
+          break;
+        case Static:
+          if (isFragmentStart) {
+            node = nextSibling(node);
+            domType = node.nodeType;
+          }
+          if (domType === 1 || domType === 3) {
+            nextNode = node;
+            const needToAdoptContent = !vnode.children.length;
+            for (let i = 0; i < vnode.staticCount; i++) {
+              if (needToAdoptContent)
+                vnode.children += nextNode.nodeType === 1 ? nextNode.outerHTML : nextNode.data;
+              if (i === vnode.staticCount - 1) {
+                vnode.anchor = nextNode;
+              }
+              nextNode = nextSibling(nextNode);
+            }
+            return isFragmentStart ? nextSibling(nextNode) : nextNode;
+          } else {
+            onMismatch();
+          }
+          break;
+        case Fragment:
+          if (!isFragmentStart) {
+            nextNode = onMismatch();
+          } else {
+            nextNode = hydrateFragment(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              slotScopeIds,
+              optimized
+            );
+          }
+          break;
+        default:
+          if (shapeFlag & 1) {
+            if ((domType !== 1 || vnode.type.toLowerCase() !== node.tagName.toLowerCase()) && !isTemplateNode(node)) {
+              nextNode = onMismatch();
             } else {
-              timerLoading = setTimeout(function () {
-                timerLoading = null;
-                if (isUndef(factory.resolved) && isUndef(factory.error)) {
-                  factory.loading = true;
-                  forceRender(false);
-                }
-              }, res.delay || 200);
+              nextNode = hydrateElement(
+                node,
+                vnode,
+                parentComponent,
+                parentSuspense,
+                slotScopeIds,
+                optimized
+              );
+            }
+          } else if (shapeFlag & 6) {
+            vnode.slotScopeIds = slotScopeIds;
+            const container = parentNode(node);
+            if (isFragmentStart) {
+              nextNode = locateClosingAnchor(node);
+            } else if (isComment(node) && node.data === "teleport start") {
+              nextNode = locateClosingAnchor(node, node.data, "teleport end");
+            } else {
+              nextNode = nextSibling(node);
+            }
+            mountComponent(
+              vnode,
+              container,
+              null,
+              parentComponent,
+              parentSuspense,
+              getContainerType(container),
+              optimized
+            );
+            if (isAsyncWrapper(vnode) && !vnode.type.__asyncResolved) {
+              let subTree;
+              if (isFragmentStart) {
+                subTree = createVNode(Fragment);
+                subTree.anchor = nextNode ? nextNode.previousSibling : container.lastChild;
+              } else {
+                subTree = node.nodeType === 3 ? createTextVNode("") : createVNode("div");
+              }
+              subTree.el = node;
+              vnode.component.subTree = subTree;
+            }
+          } else if (shapeFlag & 64) {
+            if (domType !== 8) {
+              nextNode = onMismatch();
+            } else {
+              nextNode = vnode.type.hydrate(
+                node,
+                vnode,
+                parentComponent,
+                parentSuspense,
+                slotScopeIds,
+                optimized,
+                rendererInternals,
+                hydrateChildren
+              );
             }
+          } else if (shapeFlag & 128) {
+            nextNode = vnode.type.hydrate(
+              node,
+              vnode,
+              parentComponent,
+              parentSuspense,
+              getContainerType(parentNode(node)),
+              slotScopeIds,
+              optimized,
+              rendererInternals,
+              hydrateNode
+            );
+          } else {
+            warn$1("Invalid HostVNode type:", type, `(${typeof type})`);
           }
-
-          if (isDef(res.timeout)) {
-            timerTimeout = setTimeout(function () {
-              timerTimeout = null;
-              if (isUndef(factory.resolved)) {
-                reject(
-                  "timeout (" + (res.timeout) + "ms)"
+      }
+      if (ref != null) {
+        setRef(ref, null, parentSuspense, vnode);
+      }
+      return nextNode;
+    };
+    const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+      optimized = optimized || !!vnode.dynamicChildren;
+      const { type, props, patchFlag, shapeFlag, dirs, transition } = vnode;
+      const forcePatch = type === "input" || type === "option";
+      {
+        if (dirs) {
+          invokeDirectiveHook(vnode, null, parentComponent, "created");
+        }
+        let needCallTransitionHooks = false;
+        if (isTemplateNode(el)) {
+          needCallTransitionHooks = needTransition(
+            null,
+            // no need check parentSuspense in hydration
+            transition
+          ) && parentComponent && parentComponent.vnode.props && parentComponent.vnode.props.appear;
+          const content = el.content.firstChild;
+          if (needCallTransitionHooks) {
+            const cls = content.getAttribute("class");
+            if (cls) content.$cls = cls;
+            transition.beforeEnter(content);
+          }
+          replaceNode(content, el, parentComponent);
+          vnode.el = el = content;
+        }
+        if (shapeFlag & 16 && // skip if element has innerHTML / textContent
+        !(props && (props.innerHTML || props.textContent))) {
+          let next = hydrateChildren(
+            el.firstChild,
+            vnode,
+            el,
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
+          let hasWarned = false;
+          while (next) {
+            if (!isMismatchAllowed(el, 1 /* CHILDREN */)) {
+              if (!hasWarned) {
+                warn$1(
+                  `Hydration children mismatch on`,
+                  el,
+                  `
+Server rendered element contains more child nodes than client vdom.`
                 );
+                hasWarned = true;
               }
-            }, res.timeout);
+              logMismatchError();
+            }
+            const cur = next;
+            next = next.nextSibling;
+            remove(cur);
+          }
+        } else if (shapeFlag & 8) {
+          let clientText = vnode.children;
+          if (clientText[0] === "\n" && (el.tagName === "PRE" || el.tagName === "TEXTAREA")) {
+            clientText = clientText.slice(1);
+          }
+          if (el.textContent !== clientText) {
+            if (!isMismatchAllowed(el, 0 /* TEXT */)) {
+              warn$1(
+                `Hydration text content mismatch on`,
+                el,
+                `
+  - rendered on server: ${el.textContent}
+  - expected on client: ${vnode.children}`
+              );
+              logMismatchError();
+            }
+            el.textContent = vnode.children;
           }
         }
-      }
-
-      sync = false;
-      // return in case resolved synchronously
-      return factory.loading
-        ? factory.loadingComp
-        : factory.resolved
-    }
-  }
-
-  /*  */
-
-  function isAsyncPlaceholder (node) {
-    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;
-
-  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);
+        if (props) {
+          {
+            const isCustomElement = el.tagName.includes("-");
+            for (const key in props) {
+              if (// #11189 skip if this node has directives that have created hooks
+              // as it could have mutated the DOM in any possible way
+              !(dirs && dirs.some((d) => d.dir.created)) && propHasMismatch(el, key, props[key], vnode, parentComponent)) {
+                logMismatchError();
+              }
+              if (forcePatch && (key.endsWith("value") || key === "indeterminate") || isOn(key) && !isReservedProp(key) || // force hydrate v-bind with .prop modifiers
+              key[0] === "." || isCustomElement) {
+                patchProp(el, key, null, props[key], void 0, parentComponent);
+              }
+            }
+          }
         }
-      } 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;
+        let vnodeHooks;
+        if (vnodeHooks = props && props.onVnodeBeforeMount) {
+          invokeVNodeHook(vnodeHooks, parentComponent, vnode);
         }
-      }
-      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);
+        if (dirs) {
+          invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
         }
-        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
+        if ((vnodeHooks = props && props.onVnodeMounted) || dirs || needCallTransitionHooks) {
+          queueEffectWithSuspense(() => {
+            vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode);
+            needCallTransitionHooks && transition.enter(el);
+            dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+          }, parentSuspense);
         }
       }
-      return vm
+      return el.nextSibling;
     };
-
-    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 + "\"."
+    const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+      optimized = optimized || !!parentVNode.dynamicChildren;
+      const children = parentVNode.children;
+      const l = children.length;
+      let hasWarned = false;
+      for (let i = 0; i < l; i++) {
+        const vnode = optimized ? children[i] : children[i] = normalizeVNode(children[i]);
+        const isText = vnode.type === Text;
+        if (node) {
+          if (isText && !optimized) {
+            if (i + 1 < l && normalizeVNode(children[i + 1]).type === Text) {
+              insert(
+                createText(
+                  node.data.slice(vnode.children.length)
+                ),
+                container,
+                nextSibling(node)
+              );
+              node.data = vnode.children;
+            }
+          }
+          node = hydrateNode(
+            node,
+            vnode,
+            parentComponent,
+            parentSuspense,
+            slotScopeIds,
+            optimized
+          );
+        } else if (isText && !vnode.children) {
+          insert(vnode.el = createText(""), container);
+        } else {
+          if (!isMismatchAllowed(container, 1 /* CHILDREN */)) {
+            if (!hasWarned) {
+              warn$1(
+                `Hydration children mismatch on`,
+                container,
+                `
+Server rendered element contains fewer child nodes than client vdom.`
+              );
+              hasWarned = true;
+            }
+            logMismatchError();
+          }
+          patch(
+            null,
+            vnode,
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            getContainerType(container),
+            slotScopeIds
           );
         }
       }
-      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
+      return node;
     };
-  }
-
-  /*  */
-
-  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 */);
+    const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => {
+      const { slotScopeIds: fragmentSlotScopeIds } = vnode;
+      if (fragmentSlotScopeIds) {
+        slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+      }
+      const container = parentNode(node);
+      const next = hydrateChildren(
+        nextSibling(node),
+        vnode,
+        container,
+        parentComponent,
+        parentSuspense,
+        slotScopeIds,
+        optimized
+      );
+      if (next && isComment(next) && next.data === "]") {
+        return nextSibling(vnode.anchor = next);
       } else {
-        // updates
-        vm.$el = vm.__patch__(prevVnode, vnode);
+        logMismatchError();
+        insert(vnode.anchor = createComment(`]`), container, next);
+        return next;
       }
-      restoreActiveInstance();
-      // update __vue__ reference
-      if (prevEl) {
-        prevEl.__vue__ = null;
-      }
-      if (vm.$el) {
-        vm.$el.__vue__ = vm;
+    };
+    const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
+      if (!isMismatchAllowed(node.parentElement, 1 /* CHILDREN */)) {
+        warn$1(
+          `Hydration node mismatch:
+- rendered on server:`,
+          node,
+          node.nodeType === 3 ? `(text)` : isComment(node) && node.data === "[" ? `(start of fragment)` : ``,
+          `
+- expected on client:`,
+          vnode.type
+        );
+        logMismatchError();
+      }
+      vnode.el = null;
+      if (isFragment) {
+        const end = locateClosingAnchor(node);
+        while (true) {
+          const next2 = nextSibling(node);
+          if (next2 && next2 !== end) {
+            remove(next2);
+          } else {
+            break;
+          }
+        }
       }
-      // 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;
+      const next = nextSibling(node);
+      const container = parentNode(node);
+      remove(node);
+      patch(
+        null,
+        vnode,
+        container,
+        next,
+        parentComponent,
+        parentSuspense,
+        getContainerType(container),
+        slotScopeIds
+      );
+      if (parentComponent) {
+        parentComponent.vnode.el = vnode.el;
+        updateHOCHostEl(parentComponent, vnode.el);
       }
-      // updated hook is called by the scheduler to ensure that children are
-      // updated in a parent's updated hook.
+      return next;
     };
-
-    Vue.prototype.$forceUpdate = function () {
-      var vm = this;
-      if (vm._watcher) {
-        vm._watcher.update();
+    const locateClosingAnchor = (node, open = "[", close = "]") => {
+      let match = 0;
+      while (node) {
+        node = nextSibling(node);
+        if (node && isComment(node)) {
+          if (node.data === open) match++;
+          if (node.data === close) {
+            if (match === 0) {
+              return nextSibling(node);
+            } else {
+              match--;
+            }
+          }
+        }
       }
+      return node;
     };
-
-    Vue.prototype.$destroy = function () {
-      var vm = this;
-      if (vm._isBeingDestroyed) {
-        return
+    const replaceNode = (newNode, oldNode, parentComponent) => {
+      const parentNode2 = oldNode.parentNode;
+      if (parentNode2) {
+        parentNode2.replaceChild(newNode, oldNode);
       }
-      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();
+      let parent = parentComponent;
+      while (parent) {
+        if (parent.vnode.el === oldNode) {
+          parent.vnode.el = parent.subTree.el = newNode;
+        }
+        parent = parent.parent;
       }
-      // remove reference from data ob
-      // frozen object may not have observer.
-      if (vm._data.__ob__) {
-        vm._data.__ob__.vmCount--;
+    };
+    const isTemplateNode = (node) => {
+      return node.nodeType === 1 && node.tagName === "TEMPLATE";
+    };
+    return [hydrate, hydrateNode];
+  }
+  function propHasMismatch(el, key, clientValue, vnode, instance) {
+    let mismatchType;
+    let mismatchKey;
+    let actual;
+    let expected;
+    if (key === "class") {
+      if (el.$cls) {
+        actual = el.$cls;
+        delete el.$cls;
+      } else {
+        actual = el.getAttribute("class");
+      }
+      expected = normalizeClass(clientValue);
+      if (!isSetEqual(toClassSet(actual || ""), toClassSet(expected))) {
+        mismatchType = 2 /* CLASS */;
+        mismatchKey = `class`;
+      }
+    } else if (key === "style") {
+      actual = el.getAttribute("style") || "";
+      expected = isString(clientValue) ? clientValue : stringifyStyle(normalizeStyle(clientValue));
+      const actualMap = toStyleMap(actual);
+      const expectedMap = toStyleMap(expected);
+      if (vnode.dirs) {
+        for (const { dir, value } of vnode.dirs) {
+          if (dir.name === "show" && !value) {
+            expectedMap.set("display", "none");
+          }
+        }
       }
-      // 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;
+      if (instance) {
+        resolveCssVars(instance, vnode, expectedMap);
       }
-      // release circular reference (#6759)
-      if (vm.$vnode) {
-        vm.$vnode.parent = null;
+      if (!isMapEqual(actualMap, expectedMap)) {
+        mismatchType = 3 /* STYLE */;
+        mismatchKey = "style";
       }
-    };
-  }
-
-  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 if (el instanceof SVGElement && isKnownSvgAttr(key) || el instanceof HTMLElement && (isBooleanAttr(key) || isKnownHtmlAttr(key))) {
+      if (isBooleanAttr(key)) {
+        actual = el.hasAttribute(key);
+        expected = includeBooleanAttr(clientValue);
+      } else if (clientValue == null) {
+        actual = el.hasAttribute(key);
+        expected = false;
+      } else {
+        if (el.hasAttribute(key)) {
+          actual = el.getAttribute(key);
+        } else if (key === "value" && el.tagName === "TEXTAREA") {
+          actual = el.value;
         } else {
-          warn(
-            'Failed to mount component: template or render function not defined.',
-            vm
-          );
+          actual = false;
         }
+        expected = isRenderableAttrValue(clientValue) ? String(clientValue) : false;
       }
-    }
-    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');
-        }
+      if (actual !== expected) {
+        mismatchType = 4 /* ATTRIBUTE */;
+        mismatchKey = key;
       }
-    }, 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 (mismatchType != null && !isMismatchAllowed(el, mismatchType)) {
+      const format = (v) => v === false ? `(not rendered)` : `${mismatchKey}="${v}"`;
+      const preSegment = `Hydration ${MismatchTypeString[mismatchType]} mismatch on`;
+      const postSegment = `
+  - rendered on server: ${format(actual)}
+  - expected on client: ${format(expected)}
+  Note: this mismatch is check-only. The DOM will not be rectified in production due to performance overhead.
+  You should fix the source of the mismatch.`;
+      {
+        warn$1(preSegment, el, postSegment);
       }
-      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;
+      return true;
     }
+    return false;
   }
-
-  function isInInactiveTree (vm) {
-    while (vm && (vm = vm.$parent)) {
-      if (vm._inactive) { return true }
-    }
-    return false
+  function toClassSet(str) {
+    return new Set(str.trim().split(/\s+/));
   }
-
-  function activateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = false;
-      if (isInInactiveTree(vm)) {
-        return
-      }
-    } else if (vm._directInactive) {
-      return
+  function isSetEqual(a, b) {
+    if (a.size !== b.size) {
+      return false;
     }
-    if (vm._inactive || vm._inactive === null) {
-      vm._inactive = false;
-      for (var i = 0; i < vm.$children.length; i++) {
-        activateChildComponent(vm.$children[i]);
+    for (const s of a) {
+      if (!b.has(s)) {
+        return false;
       }
-      callHook(vm, 'activated');
     }
+    return true;
   }
-
-  function deactivateChildComponent (vm, direct) {
-    if (direct) {
-      vm._directInactive = true;
-      if (isInInactiveTree(vm)) {
-        return
+  function toStyleMap(str) {
+    const styleMap = /* @__PURE__ */ new Map();
+    for (const item of str.split(";")) {
+      let [key, value] = item.split(":");
+      key = key.trim();
+      value = value && value.trim();
+      if (key && value) {
+        styleMap.set(key, value);
       }
     }
-    if (!vm._inactive) {
-      vm._inactive = true;
-      for (var i = 0; i < vm.$children.length; i++) {
-        deactivateChildComponent(vm.$children[i]);
-      }
-      callHook(vm, 'deactivated');
-    }
+    return styleMap;
   }
-
-  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 isMapEqual(a, b) {
+    if (a.size !== b.size) {
+      return false;
     }
-    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 = {};
+    for (const [key, value] of a) {
+      if (value !== b.get(key)) {
+        return false;
+      }
     }
-    waiting = flushing = false;
+    return true;
   }
-
-  // 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 resolveCssVars(instance, vnode, expectedMap) {
+    const root = instance.subTree;
+    if (instance.getCssVars && (vnode === root || root && root.type === Fragment && root.children.includes(vnode))) {
+      const cssVars = instance.getCssVars();
+      for (const key in cssVars) {
+        expectedMap.set(
+          `--${getEscapedCssVarName(key)}`,
+          String(cssVars[key])
+        );
       }
     }
-
-    // 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');
+    if (vnode === root && instance.parent) {
+      resolveCssVars(instance.parent, instance.vnode, expectedMap);
     }
   }
-
-  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');
+  const allowMismatchAttr = "data-allow-mismatch";
+  const MismatchTypeString = {
+    [0 /* TEXT */]: "text",
+    [1 /* CHILDREN */]: "children",
+    [2 /* CLASS */]: "class",
+    [3 /* STYLE */]: "style",
+    [4 /* ATTRIBUTE */]: "attribute"
+  };
+  function isMismatchAllowed(el, allowedType) {
+    if (allowedType === 0 /* TEXT */ || allowedType === 1 /* CHILDREN */) {
+      while (el && !el.hasAttribute(allowMismatchAttr)) {
+        el = el.parentElement;
       }
     }
-  }
-
-  /**
-   * 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 */);
+    const allowedAttr = el && el.getAttribute(allowMismatchAttr);
+    if (allowedAttr == null) {
+      return false;
+    } else if (allowedAttr === "") {
+      return true;
+    } else {
+      const list = allowedAttr.split(",");
+      if (allowedType === 0 /* TEXT */ && list.includes("children")) {
+        return true;
+      }
+      return list.includes(MismatchTypeString[allowedType]);
     }
   }
 
-  /**
-   * 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);
+  const requestIdleCallback = getGlobalThis().requestIdleCallback || ((cb) => setTimeout(cb, 1));
+  const cancelIdleCallback = getGlobalThis().cancelIdleCallback || ((id) => clearTimeout(id));
+  const hydrateOnIdle = (timeout = 1e4) => (hydrate) => {
+    const id = requestIdleCallback(hydrate, { timeout });
+    return () => cancelIdleCallback(id);
+  };
+  function elementIsVisibleInViewport(el) {
+    const { top, left, bottom, right } = el.getBoundingClientRect();
+    const { innerHeight, innerWidth } = window;
+    return (top > 0 && top < innerHeight || bottom > 0 && bottom < innerHeight) && (left > 0 && left < innerWidth || right > 0 && right < innerWidth);
+  }
+  const hydrateOnVisible = (opts) => (hydrate, forEach) => {
+    const ob = new IntersectionObserver((entries) => {
+      for (const e of entries) {
+        if (!e.isIntersecting) continue;
+        ob.disconnect();
+        hydrate();
+        break;
+      }
+    }, opts);
+    forEach((el) => {
+      if (!(el instanceof Element)) return;
+      if (elementIsVisibleInViewport(el)) {
+        hydrate();
+        ob.disconnect();
+        return false;
+      }
+      ob.observe(el);
+    });
+    return () => ob.disconnect();
+  };
+  const hydrateOnMediaQuery = (query) => (hydrate) => {
+    if (query) {
+      const mql = matchMedia(query);
+      if (mql.matches) {
+        hydrate();
       } 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);
+        mql.addEventListener("change", hydrate, { once: true });
+        return () => mql.removeEventListener("change", hydrate);
       }
     }
-  }
-
-  /*  */
-
-
-
-  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();
   };
-
-  /**
-   * 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
+  const hydrateOnInteraction = (interactions = []) => (hydrate, forEach) => {
+    if (isString(interactions)) interactions = [interactions];
+    let hasHydrated = false;
+    const doHydrate = (e) => {
+      if (!hasHydrated) {
+        hasHydrated = true;
+        teardown();
+        hydrate();
+        e.target.dispatchEvent(new e.constructor(e.type, e));
       }
-    } finally {
-      // "touch" every property so they are all tracked as
-      // dependencies for deep watching
-      if (this.deep) {
-        traverse(value);
+    };
+    const teardown = () => {
+      forEach((el) => {
+        for (const i of interactions) {
+          el.removeEventListener(i, doHydrate);
+        }
+      });
+    };
+    forEach((el) => {
+      for (const i of interactions) {
+        el.addEventListener(i, doHydrate, { once: true });
       }
-      popTarget();
-      this.cleanupDeps();
-    }
-    return value
+    });
+    return teardown;
   };
-
-  /**
-   * 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);
+  function forEachElement(node, cb) {
+    if (isComment(node) && node.data === "[") {
+      let depth = 1;
+      let next = node.nextSibling;
+      while (next) {
+        if (next.nodeType === 1) {
+          const result = cb(next);
+          if (result === false) {
+            break;
+          }
+        } else if (isComment(next)) {
+          if (next.data === "]") {
+            if (--depth === 0) break;
+          } else if (next.data === "[") {
+            depth++;
+          }
+        }
+        next = next.nextSibling;
       }
-    }
-  };
-
-  /**
-   * 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) {
-          try {
-            this.cb.call(this.vm, value, oldValue);
-          } catch (e) {
-            handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
+      cb(node);
+    }
+  }
+
+  const isAsyncWrapper = (i) => !!i.type.__asyncLoader;
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineAsyncComponent(source) {
+    if (isFunction(source)) {
+      source = { loader: source };
+    }
+    const {
+      loader,
+      loadingComponent,
+      errorComponent,
+      delay = 200,
+      hydrate: hydrateStrategy,
+      timeout,
+      // undefined = never times out
+      suspensible = true,
+      onError: userOnError
+    } = source;
+    let pendingRequest = null;
+    let resolvedComp;
+    let retries = 0;
+    const retry = () => {
+      retries++;
+      pendingRequest = null;
+      return load();
+    };
+    const load = () => {
+      let thisRequest;
+      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) => {
+        if (thisRequest !== pendingRequest && pendingRequest) {
+          return pendingRequest;
+        }
+        if (!comp) {
+          warn$1(
+            `Async component loader resolved to undefined. If you are using retry(), make sure to return its return value.`
+          );
+        }
+        if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
+          comp = comp.default;
+        }
+        if (comp && !isObject(comp) && !isFunction(comp)) {
+          throw new Error(`Invalid async component load result: ${comp}`);
+        }
+        resolvedComp = comp;
+        return comp;
+      }));
+    };
+    return defineComponent({
+      name: "AsyncComponentWrapper",
+      __asyncLoader: load,
+      __asyncHydrate(el, instance, hydrate) {
+        let patched = false;
+        const doHydrate = hydrateStrategy ? () => {
+          const performHydrate = () => {
+            if (patched) {
+              warn$1(
+                `Skipping lazy hydration for component '${getComponentName(resolvedComp)}': it was updated before lazy hydration performed.`
+              );
+              return;
+            }
+            hydrate();
+          };
+          const teardown = hydrateStrategy(
+            performHydrate,
+            (cb) => forEachElement(el, cb)
+          );
+          if (teardown) {
+            (instance.bum || (instance.bum = [])).push(teardown);
           }
+          (instance.u || (instance.u = [])).push(() => patched = true);
+        } : hydrate;
+        if (resolvedComp) {
+          doHydrate();
         } else {
-          this.cb.call(this.vm, value, oldValue);
+          load().then(() => !instance.isUnmounted && doHydrate());
+        }
+      },
+      get __asyncResolved() {
+        return resolvedComp;
+      },
+      setup() {
+        const instance = currentInstance;
+        markAsyncBoundary(instance);
+        if (resolvedComp) {
+          return () => createInnerComp(resolvedComp, instance);
+        }
+        const onError = (err) => {
+          pendingRequest = null;
+          handleError(
+            err,
+            instance,
+            13,
+            !errorComponent
+          );
+        };
+        if (suspensible && instance.suspense || false) {
+          return load().then((comp) => {
+            return () => createInnerComp(comp, instance);
+          }).catch((err) => {
+            onError(err);
+            return () => errorComponent ? createVNode(errorComponent, {
+              error: err
+            }) : null;
+          });
+        }
+        const loaded = ref(false);
+        const error = ref();
+        const delayed = ref(!!delay);
+        if (delay) {
+          setTimeout(() => {
+            delayed.value = false;
+          }, delay);
+        }
+        if (timeout != null) {
+          setTimeout(() => {
+            if (!loaded.value && !error.value) {
+              const err = new Error(
+                `Async component timed out after ${timeout}ms.`
+              );
+              onError(err);
+              error.value = err;
+            }
+          }, timeout);
         }
+        load().then(() => {
+          loaded.value = true;
+          if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+            instance.parent.update();
+          }
+        }).catch((err) => {
+          onError(err);
+          error.value = err;
+        });
+        return () => {
+          if (loaded.value && resolvedComp) {
+            return createInnerComp(resolvedComp, instance);
+          } else if (error.value && errorComponent) {
+            return createVNode(errorComponent, {
+              error: error.value
+            });
+          } else if (loadingComponent && !delayed.value) {
+            return createVNode(loadingComponent);
+          }
+        };
+      }
+    });
+  }
+  function createInnerComp(comp, parent) {
+    const { ref: ref2, props, children, ce } = parent.vnode;
+    const vnode = createVNode(comp, props, children);
+    vnode.ref = ref2;
+    vnode.ce = ce;
+    delete parent.vnode.ce;
+    return vnode;
+  }
+
+  const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
+  const KeepAliveImpl = {
+    name: `KeepAlive`,
+    // Marker for special handling inside the renderer. We are not using a ===
+    // check directly on KeepAlive in the renderer, because importing it directly
+    // would prevent it from being tree-shaken.
+    __isKeepAlive: true,
+    props: {
+      include: [String, RegExp, Array],
+      exclude: [String, RegExp, Array],
+      max: [String, Number]
+    },
+    setup(props, { slots }) {
+      const instance = getCurrentInstance();
+      const sharedContext = instance.ctx;
+      const cache = /* @__PURE__ */ new Map();
+      const keys = /* @__PURE__ */ new Set();
+      let current = null;
+      {
+        instance.__v_cache = cache;
+      }
+      const parentSuspense = instance.suspense;
+      const {
+        renderer: {
+          p: patch,
+          m: move,
+          um: _unmount,
+          o: { createElement }
+        }
+      } = sharedContext;
+      const storageContainer = createElement("div");
+      sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
+        const instance2 = vnode.component;
+        move(vnode, container, anchor, 0, parentSuspense);
+        patch(
+          instance2.vnode,
+          vnode,
+          container,
+          anchor,
+          instance2,
+          parentSuspense,
+          namespace,
+          vnode.slotScopeIds,
+          optimized
+        );
+        queuePostRenderEffect(() => {
+          instance2.isDeactivated = false;
+          if (instance2.a) {
+            invokeArrayFns(instance2.a);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeMounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+          }
+        }, parentSuspense);
+        {
+          devtoolsComponentAdded(instance2);
+        }
+      };
+      sharedContext.deactivate = (vnode) => {
+        const instance2 = vnode.component;
+        invalidateMount(instance2.m);
+        invalidateMount(instance2.a);
+        move(vnode, storageContainer, null, 1, parentSuspense);
+        queuePostRenderEffect(() => {
+          if (instance2.da) {
+            invokeArrayFns(instance2.da);
+          }
+          const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted;
+          if (vnodeHook) {
+            invokeVNodeHook(vnodeHook, instance2.parent, vnode);
+          }
+          instance2.isDeactivated = true;
+        }, parentSuspense);
+        {
+          devtoolsComponentAdded(instance2);
+        }
+        {
+          instance2.__keepAliveStorageContainer = storageContainer;
+        }
+      };
+      function unmount(vnode) {
+        resetShapeFlag(vnode);
+        _unmount(vnode, instance, parentSuspense, true);
+      }
+      function pruneCache(filter) {
+        cache.forEach((vnode, key) => {
+          const name = getComponentName(vnode.type);
+          if (name && !filter(name)) {
+            pruneCacheEntry(key);
+          }
+        });
       }
+      function pruneCacheEntry(key) {
+        const cached = cache.get(key);
+        if (cached && (!current || !isSameVNodeType(cached, current))) {
+          unmount(cached);
+        } else if (current) {
+          resetShapeFlag(current);
+        }
+        cache.delete(key);
+        keys.delete(key);
+      }
+      watch(
+        () => [props.include, props.exclude],
+        ([include, exclude]) => {
+          include && pruneCache((name) => matches(include, name));
+          exclude && pruneCache((name) => !matches(exclude, name));
+        },
+        // prune post-render after `current` has been updated
+        { flush: "post", deep: true }
+      );
+      let pendingCacheKey = null;
+      const cacheSubtree = () => {
+        if (pendingCacheKey != null) {
+          if (isSuspense(instance.subTree.type)) {
+            queuePostRenderEffect(() => {
+              cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+            }, instance.subTree.suspense);
+          } else {
+            cache.set(pendingCacheKey, getInnerChild(instance.subTree));
+          }
+        }
+      };
+      onMounted(cacheSubtree);
+      onUpdated(cacheSubtree);
+      onBeforeUnmount(() => {
+        cache.forEach((cached) => {
+          const { subTree, suspense } = instance;
+          const vnode = getInnerChild(subTree);
+          if (cached.type === vnode.type && cached.key === vnode.key) {
+            resetShapeFlag(vnode);
+            const da = vnode.component.da;
+            da && queuePostRenderEffect(da, suspense);
+            return;
+          }
+          unmount(cached);
+        });
+      });
+      return () => {
+        pendingCacheKey = null;
+        if (!slots.default) {
+          return current = null;
+        }
+        const children = slots.default();
+        const rawVNode = children[0];
+        if (children.length > 1) {
+          {
+            warn$1(`KeepAlive should contain exactly one component child.`);
+          }
+          current = null;
+          return children;
+        } else if (!isVNode(rawVNode) || !(rawVNode.shapeFlag & 4) && !(rawVNode.shapeFlag & 128)) {
+          current = null;
+          return rawVNode;
+        }
+        let vnode = getInnerChild(rawVNode);
+        if (vnode.type === Comment) {
+          current = null;
+          return vnode;
+        }
+        const comp = vnode.type;
+        const name = getComponentName(
+          isAsyncWrapper(vnode) ? vnode.type.__asyncResolved || {} : comp
+        );
+        const { include, exclude, max } = props;
+        if (include && (!name || !matches(include, name)) || exclude && name && matches(exclude, name)) {
+          vnode.shapeFlag &= -257;
+          current = vnode;
+          return rawVNode;
+        }
+        const key = vnode.key == null ? comp : vnode.key;
+        const cachedVNode = cache.get(key);
+        if (vnode.el) {
+          vnode = cloneVNode(vnode);
+          if (rawVNode.shapeFlag & 128) {
+            rawVNode.ssContent = vnode;
+          }
+        }
+        pendingCacheKey = key;
+        if (cachedVNode) {
+          vnode.el = cachedVNode.el;
+          vnode.component = cachedVNode.component;
+          if (vnode.transition) {
+            setTransitionHooks(vnode, vnode.transition);
+          }
+          vnode.shapeFlag |= 512;
+          keys.delete(key);
+          keys.add(key);
+        } else {
+          keys.add(key);
+          if (max && keys.size > parseInt(max, 10)) {
+            pruneCacheEntry(keys.values().next().value);
+          }
+        }
+        vnode.shapeFlag |= 256;
+        current = vnode;
+        return isSuspense(rawVNode.type) ? rawVNode : vnode;
+      };
     }
   };
-
-  /**
-   * 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();
+  const KeepAlive = KeepAliveImpl;
+  function matches(pattern, name) {
+    if (isArray(pattern)) {
+      return pattern.some((p) => matches(p, name));
+    } else if (isString(pattern)) {
+      return pattern.split(",").includes(name);
+    } else if (isRegExp(pattern)) {
+      pattern.lastIndex = 0;
+      return pattern.test(name);
     }
-  };
-
-  /**
-   * 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);
+    return false;
+  }
+  function onActivated(hook, target) {
+    registerKeepAliveHook(hook, "a", target);
+  }
+  function onDeactivated(hook, target) {
+    registerKeepAliveHook(hook, "da", target);
+  }
+  function registerKeepAliveHook(hook, type, target = currentInstance) {
+    const wrappedHook = hook.__wdc || (hook.__wdc = () => {
+      let current = target;
+      while (current) {
+        if (current.isDeactivated) {
+          return;
+        }
+        current = current.parent;
       }
-      var i = this.deps.length;
-      while (i--) {
-        this.deps[i].removeSub(this);
+      return hook();
+    });
+    injectHook(type, wrappedHook, target);
+    if (target) {
+      let current = target.parent;
+      while (current && current.parent) {
+        if (isKeepAlive(current.parent.vnode)) {
+          injectToKeepAliveRoot(wrappedHook, type, target, current);
+        }
+        current = current.parent;
       }
-      this.active = false;
     }
-  };
-
-  /*  */
-
-  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 injectToKeepAliveRoot(hook, type, target, keepAliveRoot) {
+    const injected = injectHook(
+      type,
+      hook,
+      keepAliveRoot,
+      true
+      /* prepend */
+    );
+    onUnmounted(() => {
+      remove(keepAliveRoot[type], injected);
+    }, target);
+  }
+  function resetShapeFlag(vnode) {
+    vnode.shapeFlag &= -257;
+    vnode.shapeFlag &= -513;
+  }
+  function getInnerChild(vnode) {
+    return vnode.shapeFlag & 128 ? vnode.ssContent : vnode;
   }
 
-  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);
+  function injectHook(type, hook, target = currentInstance, prepend = false) {
+    if (target) {
+      const hooks = target[type] || (target[type] = []);
+      const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
+        pauseTracking();
+        const reset = setCurrentInstance(target);
+        const res = callWithAsyncErrorHandling(hook, target, type, args);
+        reset();
+        resetTracking();
+        return res;
+      });
+      if (prepend) {
+        hooks.unshift(wrappedHook);
+      } else {
+        hooks.push(wrappedHook);
+      }
+      return wrappedHook;
     } else {
-      observe(vm._data = {}, true /* asRootData */);
+      const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
+      warn$1(
+        `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )
+      );
     }
-    if (opts.computed) { initComputed(vm, opts.computed); }
-    if (opts.watch && opts.watch !== nativeWatch) {
-      initWatch(vm, opts.watch);
+  }
+  const createHook = (lifecycle) => (hook, target = currentInstance) => {
+    if (!isInSSRComponentSetup || lifecycle === "sp") {
+      injectHook(lifecycle, (...args) => hook(...args), target);
     }
+  };
+  const onBeforeMount = createHook("bm");
+  const onMounted = createHook("m");
+  const onBeforeUpdate = createHook(
+    "bu"
+  );
+  const onUpdated = createHook("u");
+  const onBeforeUnmount = createHook(
+    "bum"
+  );
+  const onUnmounted = createHook("um");
+  const onServerPrefetch = createHook(
+    "sp"
+  );
+  const onRenderTriggered = createHook("rtg");
+  const onRenderTracked = createHook("rtc");
+  function onErrorCaptured(hook, target = currentInstance) {
+    injectHook("ec", hook, target);
   }
 
-  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);
+  const COMPONENTS = "components";
+  const DIRECTIVES = "directives";
+  function resolveComponent(name, maybeSelfReference) {
+    return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+  }
+  const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
+  function resolveDynamicComponent(component) {
+    if (isString(component)) {
+      return resolveAsset(COMPONENTS, component, false) || component;
+    } else {
+      return component || NULL_DYNAMIC_COMPONENT;
     }
-    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
-          );
+  }
+  function resolveDirective(name) {
+    return resolveAsset(DIRECTIVES, name);
+  }
+  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+    const instance = currentRenderingInstance || currentInstance;
+    if (instance) {
+      const Component = instance.type;
+      if (type === COMPONENTS) {
+        const selfName = getComponentName(
+          Component,
+          false
+        );
+        if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
+          return Component;
         }
-        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);
+      const res = (
+        // local registration
+        // check instance[type] first which is resolved for options API
+        resolve(instance[type] || Component[type], name) || // global registration
+        resolve(instance.appContext[type], name)
+      );
+      if (!res && maybeSelfReference) {
+        return Component;
       }
-    };
-
-    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
+      if (warnMissing && !res) {
+        const extra = type === COMPONENTS ? `
+If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
+        warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
+      }
+      return res;
+    } else {
+      warn$1(
+        `resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
       );
     }
-    // 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 resolve(registry, name) {
+    return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
+  }
+
+  function renderList(source, renderItem, cache, index) {
+    let ret;
+    const cached = cache && cache[index];
+    const sourceIsArray = isArray(source);
+    if (sourceIsArray || isString(source)) {
+      const sourceIsReactiveArray = sourceIsArray && isReactive(source);
+      let needsWrap = false;
+      let isReadonlySource = false;
+      if (sourceIsReactiveArray) {
+        needsWrap = !isShallow(source);
+        isReadonlySource = isReadonly(source);
+        source = shallowReadArray(source);
+      }
+      ret = new Array(source.length);
+      for (let i = 0, l = source.length; i < l; i++) {
+        ret[i] = renderItem(
+          needsWrap ? isReadonlySource ? toReadonly(toReactive(source[i])) : toReactive(source[i]) : source[i],
+          i,
+          void 0,
+          cached && cached[i]
+        );
       }
-      if (props && hasOwn(props, key)) {
-        warn(
-          "The data property \"" + key + "\" is already declared as a prop. " +
-          "Use prop default value instead.",
-          vm
+    } else if (typeof source === "number") {
+      if (!Number.isInteger(source)) {
+        warn$1(`The v-for range expect an integer value but got ${source}.`);
+      }
+      ret = new Array(source);
+      for (let i = 0; i < source; i++) {
+        ret[i] = renderItem(i + 1, i, void 0, cached && cached[i]);
+      }
+    } else if (isObject(source)) {
+      if (source[Symbol.iterator]) {
+        ret = Array.from(
+          source,
+          (item, i) => renderItem(item, i, void 0, cached && cached[i])
         );
-      } else if (!isReserved(key)) {
-        proxy(vm, "_data", key);
+      } else {
+        const keys = Object.keys(source);
+        ret = new Array(keys.length);
+        for (let i = 0, l = keys.length; i < l; i++) {
+          const key = keys[i];
+          ret[i] = renderItem(source[key], key, i, cached && cached[i]);
+        }
       }
+    } else {
+      ret = [];
+    }
+    if (cache) {
+      cache[index] = ret;
     }
-    // observe data
-    observe(data, true /* asRootData */);
+    return ret;
   }
 
-  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 createSlots(slots, dynamicSlots) {
+    for (let i = 0; i < dynamicSlots.length; i++) {
+      const slot = dynamicSlots[i];
+      if (isArray(slot)) {
+        for (let j = 0; j < slot.length; j++) {
+          slots[slot[j].name] = slot[j].fn;
+        }
+      } else if (slot) {
+        slots[slot.name] = slot.key ? (...args) => {
+          const res = slot.fn(...args);
+          if (res) res.key = slot.key;
+          return res;
+        } : slot.fn;
+      }
     }
+    return slots;
   }
 
-  var computedWatcherOptions = { lazy: true };
+  function renderSlot(slots, name, props = {}, fallback, noSlotted) {
+    if (currentRenderingInstance.ce || currentRenderingInstance.parent && isAsyncWrapper(currentRenderingInstance.parent) && currentRenderingInstance.parent.ce) {
+      if (name !== "default") props.name = name;
+      return openBlock(), createBlock(
+        Fragment,
+        null,
+        [createVNode("slot", props, fallback && fallback())],
+        64
+      );
+    }
+    let slot = slots[name];
+    if (slot && slot.length > 1) {
+      warn$1(
+        `SSR-optimized slot function detected in a non-SSR-optimized render function. You need to mark this component with $dynamic-slots in the parent template.`
+      );
+      slot = () => [];
+    }
+    if (slot && slot._c) {
+      slot._d = false;
+    }
+    openBlock();
+    const validSlotContent = slot && ensureValidVNode(slot(props));
+    const slotKey = props.key || // slot content array of a dynamic conditional slot may have a branch
+    // key attached in the `createSlots` helper, respect that
+    validSlotContent && validSlotContent.key;
+    const rendered = createBlock(
+      Fragment,
+      {
+        key: (slotKey && !isSymbol(slotKey) ? slotKey : `_${name}`) + // #7256 force differentiate fallback content from actual content
+        (!validSlotContent && fallback ? "_fb" : "")
+      },
+      validSlotContent || (fallback ? fallback() : []),
+      validSlotContent && slots._ === 1 ? 64 : -2
+    );
+    if (!noSlotted && rendered.scopeId) {
+      rendered.slotScopeIds = [rendered.scopeId + "-s"];
+    }
+    if (slot && slot._c) {
+      slot._d = true;
+    }
+    return rendered;
+  }
+  function ensureValidVNode(vnodes) {
+    return vnodes.some((child) => {
+      if (!isVNode(child)) return true;
+      if (child.type === Comment) return false;
+      if (child.type === Fragment && !ensureValidVNode(child.children))
+        return false;
+      return true;
+    }) ? vnodes : null;
+  }
 
-  function initComputed (vm, computed) {
-    // $flow-disable-line
-    var watchers = vm._computedWatchers = Object.create(null);
-    // computed properties are just getters during SSR
-    var isSSR = isServerRendering();
+  function toHandlers(obj, preserveCaseIfNecessary) {
+    const ret = {};
+    if (!isObject(obj)) {
+      warn$1(`v-on with no argument expects an object value.`);
+      return ret;
+    }
+    for (const key in obj) {
+      ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
+    }
+    return ret;
+  }
 
-    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
-        );
+  const getPublicInstance = (i) => {
+    if (!i) return null;
+    if (isStatefulComponent(i)) return getComponentPublicInstance(i);
+    return getPublicInstance(i.parent);
+  };
+  const publicPropertiesMap = (
+    // Move PURE marker to new line to workaround compiler discarding it
+    // due to type annotation
+    /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
+      $: (i) => i,
+      $el: (i) => i.vnode.el,
+      $data: (i) => i.data,
+      $props: (i) => shallowReadonly(i.props) ,
+      $attrs: (i) => shallowReadonly(i.attrs) ,
+      $slots: (i) => shallowReadonly(i.slots) ,
+      $refs: (i) => shallowReadonly(i.refs) ,
+      $parent: (i) => getPublicInstance(i.parent),
+      $root: (i) => getPublicInstance(i.root),
+      $host: (i) => i.ce,
+      $emit: (i) => i.emit,
+      $options: (i) => resolveMergedOptions(i) ,
+      $forceUpdate: (i) => i.f || (i.f = () => {
+        queueJob(i.update);
+      }),
+      $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
+      $watch: (i) => instanceWatch.bind(i) 
+    })
+  );
+  const isReservedPrefix = (key) => key === "_" || key === "$";
+  const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
+  const PublicInstanceProxyHandlers = {
+    get({ _: instance }, key) {
+      if (key === "__v_skip") {
+        return true;
+      }
+      const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+      if (key === "__isVue") {
+        return true;
+      }
+      let normalizedProps;
+      if (key[0] !== "$") {
+        const n = accessCache[key];
+        if (n !== void 0) {
+          switch (n) {
+            case 1 /* SETUP */:
+              return setupState[key];
+            case 2 /* DATA */:
+              return data[key];
+            case 4 /* CONTEXT */:
+              return ctx[key];
+            case 3 /* PROPS */:
+              return props[key];
+          }
+        } else if (hasSetupBinding(setupState, key)) {
+          accessCache[key] = 1 /* SETUP */;
+          return setupState[key];
+        } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+          accessCache[key] = 2 /* DATA */;
+          return data[key];
+        } else if (
+          // only cache other properties when instance has declared (thus stable)
+          // props
+          (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key)
+        ) {
+          accessCache[key] = 3 /* PROPS */;
+          return props[key];
+        } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+          accessCache[key] = 4 /* CONTEXT */;
+          return ctx[key];
+        } else if (shouldCacheAccess) {
+          accessCache[key] = 0 /* OTHER */;
+        }
       }
-
-      if (!isSSR) {
-        // create internal watcher for the computed property.
-        watchers[key] = new Watcher(
-          vm,
-          getter || noop,
-          noop,
-          computedWatcherOptions
-        );
+      const publicGetter = publicPropertiesMap[key];
+      let cssModule, globalProperties;
+      if (publicGetter) {
+        if (key === "$attrs") {
+          track(instance.attrs, "get", "");
+          markAttrsAccessed();
+        } else if (key === "$slots") {
+          track(instance, "get", key);
+        }
+        return publicGetter(instance);
+      } else if (
+        // css module (injected by vue-loader)
+        (cssModule = type.__cssModules) && (cssModule = cssModule[key])
+      ) {
+        return cssModule;
+      } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+        accessCache[key] = 4 /* CONTEXT */;
+        return ctx[key];
+      } else if (
+        // global properties
+        globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
+      ) {
+        {
+          return globalProperties[key];
+        }
+      } else if (currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
+      // to infinite warning loop
+      key.indexOf("__v") !== 0)) {
+        if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) {
+          warn$1(
+            `Property ${JSON.stringify(
+            key
+          )} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`
+          );
+        } else if (instance === currentRenderingInstance) {
+          warn$1(
+            `Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
+          );
+        }
       }
-
-      // 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);
+    },
+    set({ _: instance }, key, value) {
+      const { data, setupState, ctx } = instance;
+      if (hasSetupBinding(setupState, key)) {
+        setupState[key] = value;
+        return true;
+      } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
+        warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
+        return false;
+      } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+        data[key] = value;
+        return true;
+      } else if (hasOwn(instance.props, key)) {
+        warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
+        return false;
+      }
+      if (key[0] === "$" && key.slice(1) in instance) {
+        warn$1(
+          `Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
+        );
+        return false;
       } 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);
+        if (key in instance.appContext.config.globalProperties) {
+          Object.defineProperty(ctx, key, {
+            enumerable: true,
+            configurable: true,
+            value
+          });
+        } else {
+          ctx[key] = value;
         }
       }
+      return true;
+    },
+    has({
+      _: { data, setupState, accessCache, ctx, appContext, propsOptions }
+    }, key) {
+      let normalizedProps;
+      return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
+    },
+    defineProperty(target, key, descriptor) {
+      if (descriptor.get != null) {
+        target._.accessCache[key] = 0;
+      } else if (hasOwn(descriptor, "value")) {
+        this.set(target, key, descriptor.value, null);
+      }
+      return Reflect.defineProperty(target, key, descriptor);
     }
+  };
+  {
+    PublicInstanceProxyHandlers.ownKeys = (target) => {
+      warn$1(
+        `Avoid app logic that relies on enumerating keys on a component instance. The keys will be empty in production mode to avoid performance overhead.`
+      );
+      return Reflect.ownKeys(target);
+    };
   }
-
-  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
+  const RuntimeCompiledPublicInstanceProxyHandlers = /* @__PURE__ */ extend({}, PublicInstanceProxyHandlers, {
+    get(target, key) {
+      if (key === Symbol.unscopables) {
+        return;
+      }
+      return PublicInstanceProxyHandlers.get(target, key, target);
+    },
+    has(_, key) {
+      const has = key[0] !== "_" && !isGloballyAllowed(key);
+      if (!has && PublicInstanceProxyHandlers.has(_, key)) {
+        warn$1(
+          `Property ${JSON.stringify(
+          key
+        )} should not start with _ which is a reserved prefix for Vue internals.`
         );
-      };
+      }
+      return has;
     }
-    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();
+  });
+  function createDevRenderContext(instance) {
+    const target = {};
+    Object.defineProperty(target, `_`, {
+      configurable: true,
+      enumerable: false,
+      get: () => instance
+    });
+    Object.keys(publicPropertiesMap).forEach((key) => {
+      Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: false,
+        get: () => publicPropertiesMap[key](instance),
+        // intercepted by the proxy so no need for implementation,
+        // but needed to prevent set errors
+        set: NOOP
+      });
+    });
+    return target;
+  }
+  function exposePropsOnRenderContext(instance) {
+    const {
+      ctx,
+      propsOptions: [propsOptions]
+    } = instance;
+    if (propsOptions) {
+      Object.keys(propsOptions).forEach((key) => {
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => instance.props[key],
+          set: NOOP
+        });
+      });
+    }
+  }
+  function exposeSetupStateOnRenderContext(instance) {
+    const { ctx, setupState } = instance;
+    Object.keys(toRaw(setupState)).forEach((key) => {
+      if (!setupState.__isScriptSetup) {
+        if (isReservedPrefix(key[0])) {
+          warn$1(
+            `setup() return property ${JSON.stringify(
+            key
+          )} should not start with "$" or "_" which are reserved prefixes for Vue internals.`
+          );
+          return;
+        }
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => setupState[key],
+          set: NOOP
+        });
+      }
+    });
+  }
+
+  const warnRuntimeUsage = (method) => warn$1(
+    `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
+  );
+  function defineProps() {
+    {
+      warnRuntimeUsage(`defineProps`);
+    }
+    return null;
+  }
+  function defineEmits() {
+    {
+      warnRuntimeUsage(`defineEmits`);
+    }
+    return null;
+  }
+  function defineExpose(exposed) {
+    {
+      warnRuntimeUsage(`defineExpose`);
+    }
+  }
+  function defineOptions(options) {
+    {
+      warnRuntimeUsage(`defineOptions`);
+    }
+  }
+  function defineSlots() {
+    {
+      warnRuntimeUsage(`defineSlots`);
+    }
+    return null;
+  }
+  function defineModel() {
+    {
+      warnRuntimeUsage("defineModel");
+    }
+  }
+  function withDefaults(props, defaults) {
+    {
+      warnRuntimeUsage(`withDefaults`);
+    }
+    return null;
+  }
+  function useSlots() {
+    return getContext().slots;
+  }
+  function useAttrs() {
+    return getContext().attrs;
+  }
+  function getContext() {
+    const i = getCurrentInstance();
+    if (!i) {
+      warn$1(`useContext() called without active instance.`);
+    }
+    return i.setupContext || (i.setupContext = createSetupContext(i));
+  }
+  function normalizePropsOrEmits(props) {
+    return isArray(props) ? props.reduce(
+      (normalized, p) => (normalized[p] = null, normalized),
+      {}
+    ) : props;
+  }
+  function mergeDefaults(raw, defaults) {
+    const props = normalizePropsOrEmits(raw);
+    for (const key in defaults) {
+      if (key.startsWith("__skip")) continue;
+      let opt = props[key];
+      if (opt) {
+        if (isArray(opt) || isFunction(opt)) {
+          opt = props[key] = { type: opt, default: defaults[key] };
+        } else {
+          opt.default = defaults[key];
+        }
+      } else if (opt === null) {
+        opt = props[key] = { default: defaults[key] };
+      } else {
+        warn$1(`props default key "${key}" has no corresponding declaration.`);
+      }
+      if (opt && defaults[`__skip_${key}`]) {
+        opt.skipFactory = true;
+      }
+    }
+    return props;
+  }
+  function mergeModels(a, b) {
+    if (!a || !b) return a || b;
+    if (isArray(a) && isArray(b)) return a.concat(b);
+    return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+  }
+  function createPropsRestProxy(props, excludedKeys) {
+    const ret = {};
+    for (const key in props) {
+      if (!excludedKeys.includes(key)) {
+        Object.defineProperty(ret, key, {
+          enumerable: true,
+          get: () => props[key]
+        });
+      }
+    }
+    return ret;
+  }
+  function withAsyncContext(getAwaitable) {
+    const ctx = getCurrentInstance();
+    if (!ctx) {
+      warn$1(
+        `withAsyncContext called without active current instance. This is likely a bug.`
+      );
+    }
+    let awaitable = getAwaitable();
+    unsetCurrentInstance();
+    if (isPromise(awaitable)) {
+      awaitable = awaitable.catch((e) => {
+        setCurrentInstance(ctx);
+        throw e;
+      });
+    }
+    return [awaitable, () => setCurrentInstance(ctx)];
+  }
+
+  function createDuplicateChecker() {
+    const cache = /* @__PURE__ */ Object.create(null);
+    return (type, key) => {
+      if (cache[key]) {
+        warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
+      } else {
+        cache[key] = type;
+      }
+    };
+  }
+  let shouldCacheAccess = true;
+  function applyOptions(instance) {
+    const options = resolveMergedOptions(instance);
+    const publicThis = instance.proxy;
+    const ctx = instance.ctx;
+    shouldCacheAccess = false;
+    if (options.beforeCreate) {
+      callHook$1(options.beforeCreate, instance, "bc");
+    }
+    const {
+      // state
+      data: dataOptions,
+      computed: computedOptions,
+      methods,
+      watch: watchOptions,
+      provide: provideOptions,
+      inject: injectOptions,
+      // lifecycle
+      created,
+      beforeMount,
+      mounted,
+      beforeUpdate,
+      updated,
+      activated,
+      deactivated,
+      beforeDestroy,
+      beforeUnmount,
+      destroyed,
+      unmounted,
+      render,
+      renderTracked,
+      renderTriggered,
+      errorCaptured,
+      serverPrefetch,
+      // public API
+      expose,
+      inheritAttrs,
+      // assets
+      components,
+      directives,
+      filters
+    } = options;
+    const checkDuplicateProperties = createDuplicateChecker() ;
+    {
+      const [propsOptions] = instance.propsOptions;
+      if (propsOptions) {
+        for (const key in propsOptions) {
+          checkDuplicateProperties("Props" /* PROPS */, key);
+        }
+      }
+    }
+    if (injectOptions) {
+      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+    }
+    if (methods) {
+      for (const key in methods) {
+        const methodHandler = methods[key];
+        if (isFunction(methodHandler)) {
+          {
+            Object.defineProperty(ctx, key, {
+              value: methodHandler.bind(publicThis),
+              configurable: true,
+              enumerable: true,
+              writable: true
+            });
+          }
+          {
+            checkDuplicateProperties("Methods" /* METHODS */, key);
+          }
+        } else {
+          warn$1(
+            `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+          );
+        }
+      }
+    }
+    if (dataOptions) {
+      if (!isFunction(dataOptions)) {
+        warn$1(
+          `The data option must be a function. Plain object usage is no longer supported.`
+        );
+      }
+      const data = dataOptions.call(publicThis, publicThis);
+      if (isPromise(data)) {
+        warn$1(
+          `data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
+        );
+      }
+      if (!isObject(data)) {
+        warn$1(`data() should return an object.`);
+      } else {
+        instance.data = reactive(data);
+        {
+          for (const key in data) {
+            checkDuplicateProperties("Data" /* DATA */, key);
+            if (!isReservedPrefix(key[0])) {
+              Object.defineProperty(ctx, key, {
+                configurable: true,
+                enumerable: true,
+                get: () => data[key],
+                set: NOOP
+              });
+            }
+          }
+        }
+      }
+    }
+    shouldCacheAccess = true;
+    if (computedOptions) {
+      for (const key in computedOptions) {
+        const opt = computedOptions[key];
+        const get = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP;
+        if (get === NOOP) {
+          warn$1(`Computed property "${key}" has no getter.`);
+        }
+        const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : () => {
+          warn$1(
+            `Write operation failed: computed property "${key}" is readonly.`
+          );
+        } ;
+        const c = computed({
+          get,
+          set
+        });
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => c.value,
+          set: (v) => c.value = v
+        });
+        {
+          checkDuplicateProperties("Computed" /* COMPUTED */, key);
+        }
+      }
+    }
+    if (watchOptions) {
+      for (const key in watchOptions) {
+        createWatcher(watchOptions[key], ctx, publicThis, key);
+      }
+    }
+    if (provideOptions) {
+      const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
+      Reflect.ownKeys(provides).forEach((key) => {
+        provide(key, provides[key]);
+      });
+    }
+    if (created) {
+      callHook$1(created, instance, "c");
+    }
+    function registerLifecycleHook(register, hook) {
+      if (isArray(hook)) {
+        hook.forEach((_hook) => register(_hook.bind(publicThis)));
+      } else if (hook) {
+        register(hook.bind(publicThis));
+      }
+    }
+    registerLifecycleHook(onBeforeMount, beforeMount);
+    registerLifecycleHook(onMounted, mounted);
+    registerLifecycleHook(onBeforeUpdate, beforeUpdate);
+    registerLifecycleHook(onUpdated, updated);
+    registerLifecycleHook(onActivated, activated);
+    registerLifecycleHook(onDeactivated, deactivated);
+    registerLifecycleHook(onErrorCaptured, errorCaptured);
+    registerLifecycleHook(onRenderTracked, renderTracked);
+    registerLifecycleHook(onRenderTriggered, renderTriggered);
+    registerLifecycleHook(onBeforeUnmount, beforeUnmount);
+    registerLifecycleHook(onUnmounted, unmounted);
+    registerLifecycleHook(onServerPrefetch, serverPrefetch);
+    if (isArray(expose)) {
+      if (expose.length) {
+        const exposed = instance.exposed || (instance.exposed = {});
+        expose.forEach((key) => {
+          Object.defineProperty(exposed, key, {
+            get: () => publicThis[key],
+            set: (val) => publicThis[key] = val
+          });
+        });
+      } else if (!instance.exposed) {
+        instance.exposed = {};
+      }
+    }
+    if (render && instance.render === NOOP) {
+      instance.render = render;
+    }
+    if (inheritAttrs != null) {
+      instance.inheritAttrs = inheritAttrs;
+    }
+    if (components) instance.components = components;
+    if (directives) instance.directives = directives;
+  }
+  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
+    if (isArray(injectOptions)) {
+      injectOptions = normalizeInject(injectOptions);
+    }
+    for (const key in injectOptions) {
+      const opt = injectOptions[key];
+      let injected;
+      if (isObject(opt)) {
+        if ("default" in opt) {
+          injected = inject(
+            opt.from || key,
+            opt.default,
+            true
+          );
+        } else {
+          injected = inject(opt.from || key);
+        }
+      } else {
+        injected = inject(opt);
+      }
+      if (isRef(injected)) {
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => injected.value,
+          set: (v) => injected.value = v
+        });
+      } else {
+        ctx[key] = injected;
+      }
+      {
+        checkDuplicateProperties("Inject" /* INJECT */, key);
+      }
+    }
+  }
+  function callHook$1(hook, instance, type) {
+    callWithAsyncErrorHandling(
+      isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
+      instance,
+      type
+    );
+  }
+  function createWatcher(raw, ctx, publicThis, key) {
+    let getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
+    if (isString(raw)) {
+      const handler = ctx[raw];
+      if (isFunction(handler)) {
+        {
+          watch(getter, handler);
+        }
+      } else {
+        warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
+      }
+    } else if (isFunction(raw)) {
+      {
+        watch(getter, raw.bind(publicThis));
+      }
+    } else if (isObject(raw)) {
+      if (isArray(raw)) {
+        raw.forEach((r) => createWatcher(r, ctx, publicThis, key));
+      } else {
+        const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler];
+        if (isFunction(handler)) {
+          watch(getter, handler, raw);
+        } else {
+          warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler);
+        }
+      }
+    } else {
+      warn$1(`Invalid watch option: "${key}"`, raw);
+    }
+  }
+  function resolveMergedOptions(instance) {
+    const base = instance.type;
+    const { mixins, extends: extendsOptions } = base;
+    const {
+      mixins: globalMixins,
+      optionsCache: cache,
+      config: { optionMergeStrategies }
+    } = instance.appContext;
+    const cached = cache.get(base);
+    let resolved;
+    if (cached) {
+      resolved = cached;
+    } else if (!globalMixins.length && !mixins && !extendsOptions) {
+      {
+        resolved = base;
+      }
+    } else {
+      resolved = {};
+      if (globalMixins.length) {
+        globalMixins.forEach(
+          (m) => mergeOptions(resolved, m, optionMergeStrategies, true)
+        );
+      }
+      mergeOptions(resolved, base, optionMergeStrategies);
+    }
+    if (isObject(base)) {
+      cache.set(base, resolved);
+    }
+    return resolved;
+  }
+  function mergeOptions(to, from, strats, asMixin = false) {
+    const { mixins, extends: extendsOptions } = from;
+    if (extendsOptions) {
+      mergeOptions(to, extendsOptions, strats, true);
+    }
+    if (mixins) {
+      mixins.forEach(
+        (m) => mergeOptions(to, m, strats, true)
+      );
+    }
+    for (const key in from) {
+      if (asMixin && key === "expose") {
+        warn$1(
+          `"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
+        );
+      } else {
+        const strat = internalOptionMergeStrats[key] || strats && strats[key];
+        to[key] = strat ? strat(to[key], from[key]) : from[key];
+      }
+    }
+    return to;
+  }
+  const internalOptionMergeStrats = {
+    data: mergeDataFn,
+    props: mergeEmitsOrPropsOptions,
+    emits: mergeEmitsOrPropsOptions,
+    // objects
+    methods: mergeObjectOptions,
+    computed: mergeObjectOptions,
+    // lifecycle
+    beforeCreate: mergeAsArray$1,
+    created: mergeAsArray$1,
+    beforeMount: mergeAsArray$1,
+    mounted: mergeAsArray$1,
+    beforeUpdate: mergeAsArray$1,
+    updated: mergeAsArray$1,
+    beforeDestroy: mergeAsArray$1,
+    beforeUnmount: mergeAsArray$1,
+    destroyed: mergeAsArray$1,
+    unmounted: mergeAsArray$1,
+    activated: mergeAsArray$1,
+    deactivated: mergeAsArray$1,
+    errorCaptured: mergeAsArray$1,
+    serverPrefetch: mergeAsArray$1,
+    // assets
+    components: mergeObjectOptions,
+    directives: mergeObjectOptions,
+    // watch
+    watch: mergeWatchOptions,
+    // provide / inject
+    provide: mergeDataFn,
+    inject: mergeInject
+  };
+  function mergeDataFn(to, from) {
+    if (!from) {
+      return to;
+    }
+    if (!to) {
+      return from;
+    }
+    return function mergedDataFn() {
+      return (extend)(
+        isFunction(to) ? to.call(this, this) : to,
+        isFunction(from) ? from.call(this, this) : from
+      );
+    };
+  }
+  function mergeInject(to, from) {
+    return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
+  }
+  function normalizeInject(raw) {
+    if (isArray(raw)) {
+      const res = {};
+      for (let i = 0; i < raw.length; i++) {
+        res[raw[i]] = raw[i];
+      }
+      return res;
+    }
+    return raw;
+  }
+  function mergeAsArray$1(to, from) {
+    return to ? [...new Set([].concat(to, from))] : from;
+  }
+  function mergeObjectOptions(to, from) {
+    return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+  }
+  function mergeEmitsOrPropsOptions(to, from) {
+    if (to) {
+      if (isArray(to) && isArray(from)) {
+        return [.../* @__PURE__ */ new Set([...to, ...from])];
+      }
+      return extend(
+        /* @__PURE__ */ Object.create(null),
+        normalizePropsOrEmits(to),
+        normalizePropsOrEmits(from != null ? from : {})
+      );
+    } else {
+      return from;
+    }
+  }
+  function mergeWatchOptions(to, from) {
+    if (!to) return from;
+    if (!from) return to;
+    const merged = extend(/* @__PURE__ */ Object.create(null), to);
+    for (const key in from) {
+      merged[key] = mergeAsArray$1(to[key], from[key]);
+    }
+    return merged;
+  }
+
+  function createAppContext() {
+    return {
+      app: null,
+      config: {
+        isNativeTag: NO,
+        performance: false,
+        globalProperties: {},
+        optionMergeStrategies: {},
+        errorHandler: void 0,
+        warnHandler: void 0,
+        compilerOptions: {}
+      },
+      mixins: [],
+      components: {},
+      directives: {},
+      provides: /* @__PURE__ */ Object.create(null),
+      optionsCache: /* @__PURE__ */ new WeakMap(),
+      propsCache: /* @__PURE__ */ new WeakMap(),
+      emitsCache: /* @__PURE__ */ new WeakMap()
+    };
+  }
+  let uid$1 = 0;
+  function createAppAPI(render, hydrate) {
+    return function createApp(rootComponent, rootProps = null) {
+      if (!isFunction(rootComponent)) {
+        rootComponent = extend({}, rootComponent);
+      }
+      if (rootProps != null && !isObject(rootProps)) {
+        warn$1(`root props passed to app.mount() must be an object.`);
+        rootProps = null;
+      }
+      const context = createAppContext();
+      const installedPlugins = /* @__PURE__ */ new WeakSet();
+      const pluginCleanupFns = [];
+      let isMounted = false;
+      const app = context.app = {
+        _uid: uid$1++,
+        _component: rootComponent,
+        _props: rootProps,
+        _container: null,
+        _context: context,
+        _instance: null,
+        version,
+        get config() {
+          return context.config;
+        },
+        set config(v) {
+          {
+            warn$1(
+              `app.config cannot be replaced. Modify individual options instead.`
+            );
+          }
+        },
+        use(plugin, ...options) {
+          if (installedPlugins.has(plugin)) {
+            warn$1(`Plugin has already been applied to target app.`);
+          } else if (plugin && isFunction(plugin.install)) {
+            installedPlugins.add(plugin);
+            plugin.install(app, ...options);
+          } else if (isFunction(plugin)) {
+            installedPlugins.add(plugin);
+            plugin(app, ...options);
+          } else {
+            warn$1(
+              `A plugin must either be a function or an object with an "install" function.`
+            );
+          }
+          return app;
+        },
+        mixin(mixin) {
+          {
+            if (!context.mixins.includes(mixin)) {
+              context.mixins.push(mixin);
+            } else {
+              warn$1(
+                "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+              );
+            }
+          }
+          return app;
+        },
+        component(name, component) {
+          {
+            validateComponentName(name, context.config);
+          }
+          if (!component) {
+            return context.components[name];
+          }
+          if (context.components[name]) {
+            warn$1(`Component "${name}" has already been registered in target app.`);
+          }
+          context.components[name] = component;
+          return app;
+        },
+        directive(name, directive) {
+          {
+            validateDirectiveName(name);
+          }
+          if (!directive) {
+            return context.directives[name];
+          }
+          if (context.directives[name]) {
+            warn$1(`Directive "${name}" has already been registered in target app.`);
+          }
+          context.directives[name] = directive;
+          return app;
+        },
+        mount(rootContainer, isHydrate, namespace) {
+          if (!isMounted) {
+            if (rootContainer.__vue_app__) {
+              warn$1(
+                `There is already an app instance mounted on the host container.
+ If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
+              );
+            }
+            const vnode = app._ceVNode || createVNode(rootComponent, rootProps);
+            vnode.appContext = context;
+            if (namespace === true) {
+              namespace = "svg";
+            } else if (namespace === false) {
+              namespace = void 0;
+            }
+            {
+              context.reload = () => {
+                const cloned = cloneVNode(vnode);
+                cloned.el = null;
+                render(cloned, rootContainer, namespace);
+              };
+            }
+            if (isHydrate && hydrate) {
+              hydrate(vnode, rootContainer);
+            } else {
+              render(vnode, rootContainer, namespace);
+            }
+            isMounted = true;
+            app._container = rootContainer;
+            rootContainer.__vue_app__ = app;
+            {
+              app._instance = vnode.component;
+              devtoolsInitApp(app, version);
+            }
+            return getComponentPublicInstance(vnode.component);
+          } else {
+            warn$1(
+              `App has already been mounted.
+If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
+            );
+          }
+        },
+        onUnmount(cleanupFn) {
+          if (typeof cleanupFn !== "function") {
+            warn$1(
+              `Expected function as first argument to app.onUnmount(), but got ${typeof cleanupFn}`
+            );
+          }
+          pluginCleanupFns.push(cleanupFn);
+        },
+        unmount() {
+          if (isMounted) {
+            callWithAsyncErrorHandling(
+              pluginCleanupFns,
+              app._instance,
+              16
+            );
+            render(null, app._container);
+            {
+              app._instance = null;
+              devtoolsUnmountApp(app);
+            }
+            delete app._container.__vue_app__;
+          } else {
+            warn$1(`Cannot unmount an app that is not mounted.`);
+          }
+        },
+        provide(key, value) {
+          if (key in context.provides) {
+            if (hasOwn(context.provides, key)) {
+              warn$1(
+                `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+              );
+            } else {
+              warn$1(
+                `App already provides property with key "${String(key)}" inherited from its parent element. It will be overwritten with the new value.`
+              );
+            }
+          }
+          context.provides[key] = value;
+          return app;
+        },
+        runWithContext(fn) {
+          const lastApp = currentApp;
+          currentApp = app;
+          try {
+            return fn();
+          } finally {
+            currentApp = lastApp;
+          }
+        }
+      };
+      return app;
+    };
+  }
+  let currentApp = null;
+
+  function provide(key, value) {
+    if (!currentInstance) {
+      {
+        warn$1(`provide() can only be used inside setup().`);
+      }
+    } else {
+      let provides = currentInstance.provides;
+      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+      if (parentProvides === provides) {
+        provides = currentInstance.provides = Object.create(parentProvides);
+      }
+      provides[key] = value;
+    }
+  }
+  function inject(key, defaultValue, treatDefaultAsFactory = false) {
+    const instance = currentInstance || currentRenderingInstance;
+    if (instance || currentApp) {
+      let provides = currentApp ? currentApp._context.provides : instance ? instance.parent == null || instance.ce ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : void 0;
+      if (provides && key in provides) {
+        return provides[key];
+      } else if (arguments.length > 1) {
+        return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+      } else {
+        warn$1(`injection "${String(key)}" not found.`);
+      }
+    } else {
+      warn$1(`inject() can only be used inside setup() or functional components.`);
+    }
+  }
+  function hasInjectionContext() {
+    return !!(currentInstance || currentRenderingInstance || currentApp);
+  }
+
+  const internalObjectProto = {};
+  const createInternalObject = () => Object.create(internalObjectProto);
+  const isInternalObject = (obj) => Object.getPrototypeOf(obj) === internalObjectProto;
+
+  function initProps(instance, rawProps, isStateful, isSSR = false) {
+    const props = {};
+    const attrs = createInternalObject();
+    instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+    setFullProps(instance, rawProps, props, attrs);
+    for (const key in instance.propsOptions[0]) {
+      if (!(key in props)) {
+        props[key] = void 0;
+      }
+    }
+    {
+      validateProps(rawProps || {}, props, instance);
+    }
+    if (isStateful) {
+      instance.props = isSSR ? props : shallowReactive(props);
+    } else {
+      if (!instance.type.props) {
+        instance.props = attrs;
+      } else {
+        instance.props = props;
+      }
+    }
+    instance.attrs = attrs;
+  }
+  function isInHmrContext(instance) {
+    while (instance) {
+      if (instance.type.__hmrId) return true;
+      instance = instance.parent;
+    }
+  }
+  function updateProps(instance, rawProps, rawPrevProps, optimized) {
+    const {
+      props,
+      attrs,
+      vnode: { patchFlag }
+    } = instance;
+    const rawCurrentProps = toRaw(props);
+    const [options] = instance.propsOptions;
+    let hasAttrsChanged = false;
+    if (
+      // always force full diff in dev
+      // - #1942 if hmr is enabled with sfc component
+      // - vite#872 non-sfc component used by sfc component
+      !isInHmrContext(instance) && (optimized || patchFlag > 0) && !(patchFlag & 16)
+    ) {
+      if (patchFlag & 8) {
+        const propsToUpdate = instance.vnode.dynamicProps;
+        for (let i = 0; i < propsToUpdate.length; i++) {
+          let key = propsToUpdate[i];
+          if (isEmitListener(instance.emitsOptions, key)) {
+            continue;
+          }
+          const value = rawProps[key];
+          if (options) {
+            if (hasOwn(attrs, key)) {
+              if (value !== attrs[key]) {
+                attrs[key] = value;
+                hasAttrsChanged = true;
+              }
+            } else {
+              const camelizedKey = camelize(key);
+              props[camelizedKey] = resolvePropValue(
+                options,
+                rawCurrentProps,
+                camelizedKey,
+                value,
+                instance,
+                false
+              );
+            }
+          } else {
+            if (value !== attrs[key]) {
+              attrs[key] = value;
+              hasAttrsChanged = true;
+            }
+          }
+        }
+      }
+    } else {
+      if (setFullProps(instance, rawProps, props, attrs)) {
+        hasAttrsChanged = true;
+      }
+      let kebabKey;
+      for (const key in rawCurrentProps) {
+        if (!rawProps || // for camelCase
+        !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+        // and converted to camelCase (#955)
+        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
+          if (options) {
+            if (rawPrevProps && // for camelCase
+            (rawPrevProps[key] !== void 0 || // for kebab-case
+            rawPrevProps[kebabKey] !== void 0)) {
+              props[key] = resolvePropValue(
+                options,
+                rawCurrentProps,
+                key,
+                void 0,
+                instance,
+                true
+              );
+            }
+          } else {
+            delete props[key];
+          }
+        }
+      }
+      if (attrs !== rawCurrentProps) {
+        for (const key in attrs) {
+          if (!rawProps || !hasOwn(rawProps, key) && true) {
+            delete attrs[key];
+            hasAttrsChanged = true;
+          }
+        }
+      }
+    }
+    if (hasAttrsChanged) {
+      trigger(instance.attrs, "set", "");
+    }
+    {
+      validateProps(rawProps || {}, props, instance);
+    }
+  }
+  function setFullProps(instance, rawProps, props, attrs) {
+    const [options, needCastKeys] = instance.propsOptions;
+    let hasAttrsChanged = false;
+    let rawCastValues;
+    if (rawProps) {
+      for (let key in rawProps) {
+        if (isReservedProp(key)) {
+          continue;
+        }
+        const value = rawProps[key];
+        let camelKey;
+        if (options && hasOwn(options, camelKey = camelize(key))) {
+          if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+            props[camelKey] = value;
+          } else {
+            (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+          }
+        } else if (!isEmitListener(instance.emitsOptions, key)) {
+          if (!(key in attrs) || value !== attrs[key]) {
+            attrs[key] = value;
+            hasAttrsChanged = true;
+          }
+        }
+      }
+    }
+    if (needCastKeys) {
+      const rawCurrentProps = toRaw(props);
+      const castValues = rawCastValues || EMPTY_OBJ;
+      for (let i = 0; i < needCastKeys.length; i++) {
+        const key = needCastKeys[i];
+        props[key] = resolvePropValue(
+          options,
+          rawCurrentProps,
+          key,
+          castValues[key],
+          instance,
+          !hasOwn(castValues, key)
+        );
+      }
+    }
+    return hasAttrsChanged;
+  }
+  function resolvePropValue(options, props, key, value, instance, isAbsent) {
+    const opt = options[key];
+    if (opt != null) {
+      const hasDefault = hasOwn(opt, "default");
+      if (hasDefault && value === void 0) {
+        const defaultValue = opt.default;
+        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
+          const { propsDefaults } = instance;
+          if (key in propsDefaults) {
+            value = propsDefaults[key];
+          } else {
+            const reset = setCurrentInstance(instance);
+            value = propsDefaults[key] = defaultValue.call(
+              null,
+              props
+            );
+            reset();
+          }
+        } else {
+          value = defaultValue;
+        }
+        if (instance.ce) {
+          instance.ce._setProp(key, value);
+        }
+      }
+      if (opt[0 /* shouldCast */]) {
+        if (isAbsent && !hasDefault) {
+          value = false;
+        } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
+          value = true;
+        }
+      }
+    }
+    return value;
+  }
+  const mixinPropsCache = /* @__PURE__ */ new WeakMap();
+  function normalizePropsOptions(comp, appContext, asMixin = false) {
+    const cache = asMixin ? mixinPropsCache : appContext.propsCache;
+    const cached = cache.get(comp);
+    if (cached) {
+      return cached;
+    }
+    const raw = comp.props;
+    const normalized = {};
+    const needCastKeys = [];
+    let hasExtends = false;
+    if (!isFunction(comp)) {
+      const extendProps = (raw2) => {
+        hasExtends = true;
+        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+        extend(normalized, props);
+        if (keys) needCastKeys.push(...keys);
+      };
+      if (!asMixin && appContext.mixins.length) {
+        appContext.mixins.forEach(extendProps);
+      }
+      if (comp.extends) {
+        extendProps(comp.extends);
+      }
+      if (comp.mixins) {
+        comp.mixins.forEach(extendProps);
+      }
+    }
+    if (!raw && !hasExtends) {
+      if (isObject(comp)) {
+        cache.set(comp, EMPTY_ARR);
+      }
+      return EMPTY_ARR;
+    }
+    if (isArray(raw)) {
+      for (let i = 0; i < raw.length; i++) {
+        if (!isString(raw[i])) {
+          warn$1(`props must be strings when using array syntax.`, raw[i]);
+        }
+        const normalizedKey = camelize(raw[i]);
+        if (validatePropName(normalizedKey)) {
+          normalized[normalizedKey] = EMPTY_OBJ;
+        }
+      }
+    } else if (raw) {
+      if (!isObject(raw)) {
+        warn$1(`invalid props options`, raw);
+      }
+      for (const key in raw) {
+        const normalizedKey = camelize(key);
+        if (validatePropName(normalizedKey)) {
+          const opt = raw[key];
+          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
+          const propType = prop.type;
+          let shouldCast = false;
+          let shouldCastTrue = true;
+          if (isArray(propType)) {
+            for (let index = 0; index < propType.length; ++index) {
+              const type = propType[index];
+              const typeName = isFunction(type) && type.name;
+              if (typeName === "Boolean") {
+                shouldCast = true;
+                break;
+              } else if (typeName === "String") {
+                shouldCastTrue = false;
+              }
+            }
+          } else {
+            shouldCast = isFunction(propType) && propType.name === "Boolean";
+          }
+          prop[0 /* shouldCast */] = shouldCast;
+          prop[1 /* shouldCastTrue */] = shouldCastTrue;
+          if (shouldCast || hasOwn(prop, "default")) {
+            needCastKeys.push(normalizedKey);
+          }
+        }
+      }
+    }
+    const res = [normalized, needCastKeys];
+    if (isObject(comp)) {
+      cache.set(comp, res);
+    }
+    return res;
+  }
+  function validatePropName(key) {
+    if (key[0] !== "$" && !isReservedProp(key)) {
+      return true;
+    } else {
+      warn$1(`Invalid prop name: "${key}" is a reserved property.`);
+    }
+    return false;
+  }
+  function getType(ctor) {
+    if (ctor === null) {
+      return "null";
+    }
+    if (typeof ctor === "function") {
+      return ctor.name || "";
+    } else if (typeof ctor === "object") {
+      const name = ctor.constructor && ctor.constructor.name;
+      return name || "";
+    }
+    return "";
+  }
+  function validateProps(rawProps, props, instance) {
+    const resolvedValues = toRaw(props);
+    const options = instance.propsOptions[0];
+    const camelizePropsKey = Object.keys(rawProps).map((key) => camelize(key));
+    for (const key in options) {
+      let opt = options[key];
+      if (opt == null) continue;
+      validateProp(
+        key,
+        resolvedValues[key],
+        opt,
+        shallowReadonly(resolvedValues) ,
+        !camelizePropsKey.includes(key)
+      );
+    }
+  }
+  function validateProp(name, value, prop, props, isAbsent) {
+    const { type, required, validator, skipCheck } = prop;
+    if (required && isAbsent) {
+      warn$1('Missing required prop: "' + name + '"');
+      return;
+    }
+    if (value == null && !required) {
+      return;
+    }
+    if (type != null && type !== true && !skipCheck) {
+      let isValid = false;
+      const types = isArray(type) ? type : [type];
+      const expectedTypes = [];
+      for (let i = 0; i < types.length && !isValid; i++) {
+        const { valid, expectedType } = assertType(value, types[i]);
+        expectedTypes.push(expectedType || "");
+        isValid = valid;
+      }
+      if (!isValid) {
+        warn$1(getInvalidTypeMessage(name, value, expectedTypes));
+        return;
+      }
+    }
+    if (validator && !validator(value, props)) {
+      warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
+    }
+  }
+  const isSimpleType = /* @__PURE__ */ makeMap(
+    "String,Number,Boolean,Function,Symbol,BigInt"
+  );
+  function assertType(value, type) {
+    let valid;
+    const expectedType = getType(type);
+    if (expectedType === "null") {
+      valid = value === null;
+    } else if (isSimpleType(expectedType)) {
+      const t = typeof value;
+      valid = t === expectedType.toLowerCase();
+      if (!valid && t === "object") {
+        valid = value instanceof type;
+      }
+    } else if (expectedType === "Object") {
+      valid = isObject(value);
+    } else if (expectedType === "Array") {
+      valid = isArray(value);
+    } else {
+      valid = value instanceof type;
+    }
+    return {
+      valid,
+      expectedType
+    };
+  }
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+    if (expectedTypes.length === 0) {
+      return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
+    }
+    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);
+    if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+      message += ` with value ${expectedValue}`;
+    }
+    message += `, got ${receivedType} `;
+    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(type) {
+    const explicitTypes = ["string", "number", "boolean"];
+    return explicitTypes.some((elem) => type.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === "boolean");
+  }
+
+  const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+  const normalizeSlot = (key, rawSlot, ctx) => {
+    if (rawSlot._n) {
+      return rawSlot;
+    }
+    const normalized = withCtx((...args) => {
+      if (currentInstance && !(ctx === null && currentRenderingInstance) && !(ctx && ctx.root !== currentInstance.root)) {
+        warn$1(
+          `Slot "${key}" invoked outside of the render function: this will not track dependencies used in the slot. Invoke the slot function inside the render function instead.`
+        );
+      }
+      return normalizeSlotValue(rawSlot(...args));
+    }, ctx);
+    normalized._c = false;
+    return normalized;
+  };
+  const normalizeObjectSlots = (rawSlots, slots, instance) => {
+    const ctx = rawSlots._ctx;
+    for (const key in rawSlots) {
+      if (isInternalKey(key)) continue;
+      const value = rawSlots[key];
+      if (isFunction(value)) {
+        slots[key] = normalizeSlot(key, value, ctx);
+      } else if (value != null) {
+        {
+          warn$1(
+            `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
+          );
+        }
+        const normalized = normalizeSlotValue(value);
+        slots[key] = () => normalized;
+      }
+    }
+  };
+  const normalizeVNodeSlots = (instance, children) => {
+    if (!isKeepAlive(instance.vnode) && true) {
+      warn$1(
+        `Non-function value encountered for default slot. Prefer function slots for better performance.`
+      );
+    }
+    const normalized = normalizeSlotValue(children);
+    instance.slots.default = () => normalized;
+  };
+  const assignSlots = (slots, children, optimized) => {
+    for (const key in children) {
+      if (optimized || !isInternalKey(key)) {
+        slots[key] = children[key];
+      }
+    }
+  };
+  const initSlots = (instance, children, optimized) => {
+    const slots = instance.slots = createInternalObject();
+    if (instance.vnode.shapeFlag & 32) {
+      const cacheIndexes = children.__;
+      if (cacheIndexes) def(slots, "__", cacheIndexes, true);
+      const type = children._;
+      if (type) {
+        assignSlots(slots, children, optimized);
+        if (optimized) {
+          def(slots, "_", type, true);
+        }
+      } else {
+        normalizeObjectSlots(children, slots);
+      }
+    } else if (children) {
+      normalizeVNodeSlots(instance, children);
+    }
+  };
+  const updateSlots = (instance, children, optimized) => {
+    const { vnode, slots } = instance;
+    let needDeletionCheck = true;
+    let deletionComparisonTarget = EMPTY_OBJ;
+    if (vnode.shapeFlag & 32) {
+      const type = children._;
+      if (type) {
+        if (isHmrUpdating) {
+          assignSlots(slots, children, optimized);
+          trigger(instance, "set", "$slots");
+        } else if (optimized && type === 1) {
+          needDeletionCheck = false;
+        } else {
+          assignSlots(slots, children, optimized);
+        }
+      } else {
+        needDeletionCheck = !children.$stable;
+        normalizeObjectSlots(children, slots);
+      }
+      deletionComparisonTarget = children;
+    } else if (children) {
+      normalizeVNodeSlots(instance, children);
+      deletionComparisonTarget = { default: 1 };
+    }
+    if (needDeletionCheck) {
+      for (const key in slots) {
+        if (!isInternalKey(key) && deletionComparisonTarget[key] == null) {
+          delete slots[key];
+        }
+      }
+    }
+  };
+
+  let supported;
+  let perf;
+  function startMeasure(instance, type) {
+    if (instance.appContext.config.performance && isSupported()) {
+      perf.mark(`vue-${type}-${instance.uid}`);
+    }
+    {
+      devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
+    }
+  }
+  function endMeasure(instance, type) {
+    if (instance.appContext.config.performance && isSupported()) {
+      const startTag = `vue-${type}-${instance.uid}`;
+      const endTag = startTag + `:end`;
+      perf.mark(endTag);
+      perf.measure(
+        `<${formatComponentName(instance, instance.type)}> ${type}`,
+        startTag,
+        endTag
+      );
+      perf.clearMarks(startTag);
+      perf.clearMarks(endTag);
+    }
+    {
+      devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
+    }
+  }
+  function isSupported() {
+    if (supported !== void 0) {
+      return supported;
+    }
+    if (typeof window !== "undefined" && window.performance) {
+      supported = true;
+      perf = window.performance;
+    } else {
+      supported = false;
+    }
+    return supported;
+  }
+
+  const queuePostRenderEffect = queueEffectWithSuspense ;
+  function createRenderer(options) {
+    return baseCreateRenderer(options);
+  }
+  function createHydrationRenderer(options) {
+    return baseCreateRenderer(options, createHydrationFunctions);
+  }
+  function baseCreateRenderer(options, createHydrationFns) {
+    const target = getGlobalThis();
+    target.__VUE__ = true;
+    {
+      setDevtoolsHook$1(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
+    }
+    const {
+      insert: hostInsert,
+      remove: hostRemove,
+      patchProp: hostPatchProp,
+      createElement: hostCreateElement,
+      createText: hostCreateText,
+      createComment: hostCreateComment,
+      setText: hostSetText,
+      setElementText: hostSetElementText,
+      parentNode: hostParentNode,
+      nextSibling: hostNextSibling,
+      setScopeId: hostSetScopeId = NOOP,
+      insertStaticContent: hostInsertStaticContent
+    } = options;
+    const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, namespace = void 0, slotScopeIds = null, optimized = isHmrUpdating ? false : !!n2.dynamicChildren) => {
+      if (n1 === n2) {
+        return;
+      }
+      if (n1 && !isSameVNodeType(n1, n2)) {
+        anchor = getNextHostNode(n1);
+        unmount(n1, parentComponent, parentSuspense, true);
+        n1 = null;
+      }
+      if (n2.patchFlag === -2) {
+        optimized = false;
+        n2.dynamicChildren = null;
+      }
+      const { type, ref, shapeFlag } = n2;
+      switch (type) {
+        case Text:
+          processText(n1, n2, container, anchor);
+          break;
+        case Comment:
+          processCommentNode(n1, n2, container, anchor);
+          break;
+        case Static:
+          if (n1 == null) {
+            mountStaticNode(n2, container, anchor, namespace);
+          } else {
+            patchStaticNode(n1, n2, container, namespace);
+          }
+          break;
+        case Fragment:
+          processFragment(
+            n1,
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          break;
+        default:
+          if (shapeFlag & 1) {
+            processElement(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          } else if (shapeFlag & 6) {
+            processComponent(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          } else if (shapeFlag & 64) {
+            type.process(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized,
+              internals
+            );
+          } else if (shapeFlag & 128) {
+            type.process(
+              n1,
+              n2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized,
+              internals
+            );
+          } else {
+            warn$1("Invalid VNode type:", type, `(${typeof type})`);
+          }
+      }
+      if (ref != null && parentComponent) {
+        setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2);
+      } else if (ref == null && n1 && n1.ref != null) {
+        setRef(n1.ref, null, parentSuspense, n1, true);
+      }
+    };
+    const processText = (n1, n2, container, anchor) => {
+      if (n1 == null) {
+        hostInsert(
+          n2.el = hostCreateText(n2.children),
+          container,
+          anchor
+        );
+      } else {
+        const el = n2.el = n1.el;
+        if (n2.children !== n1.children) {
+          hostSetText(el, n2.children);
+        }
+      }
+    };
+    const processCommentNode = (n1, n2, container, anchor) => {
+      if (n1 == null) {
+        hostInsert(
+          n2.el = hostCreateComment(n2.children || ""),
+          container,
+          anchor
+        );
+      } else {
+        n2.el = n1.el;
+      }
+    };
+    const mountStaticNode = (n2, container, anchor, namespace) => {
+      [n2.el, n2.anchor] = hostInsertStaticContent(
+        n2.children,
+        container,
+        anchor,
+        namespace,
+        n2.el,
+        n2.anchor
+      );
+    };
+    const patchStaticNode = (n1, n2, container, namespace) => {
+      if (n2.children !== n1.children) {
+        const anchor = hostNextSibling(n1.anchor);
+        removeStaticNode(n1);
+        [n2.el, n2.anchor] = hostInsertStaticContent(
+          n2.children,
+          container,
+          anchor,
+          namespace
+        );
+      } else {
+        n2.el = n1.el;
+        n2.anchor = n1.anchor;
+      }
+    };
+    const moveStaticNode = ({ el, anchor }, container, nextSibling) => {
+      let next;
+      while (el && el !== anchor) {
+        next = hostNextSibling(el);
+        hostInsert(el, container, nextSibling);
+        el = next;
+      }
+      hostInsert(anchor, container, nextSibling);
+    };
+    const removeStaticNode = ({ el, anchor }) => {
+      let next;
+      while (el && el !== anchor) {
+        next = hostNextSibling(el);
+        hostRemove(el);
+        el = next;
+      }
+      hostRemove(anchor);
+    };
+    const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      if (n2.type === "svg") {
+        namespace = "svg";
+      } else if (n2.type === "math") {
+        namespace = "mathml";
+      }
+      if (n1 == null) {
+        mountElement(
+          n2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      } else {
+        patchElement(
+          n1,
+          n2,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      }
+    };
+    const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      let el;
+      let vnodeHook;
+      const { props, shapeFlag, transition, dirs } = vnode;
+      el = vnode.el = hostCreateElement(
+        vnode.type,
+        namespace,
+        props && props.is,
+        props
+      );
+      if (shapeFlag & 8) {
+        hostSetElementText(el, vnode.children);
+      } else if (shapeFlag & 16) {
+        mountChildren(
+          vnode.children,
+          el,
+          null,
+          parentComponent,
+          parentSuspense,
+          resolveChildrenNamespace(vnode, namespace),
+          slotScopeIds,
+          optimized
+        );
+      }
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "created");
+      }
+      setScopeId(el, vnode, vnode.scopeId, slotScopeIds, parentComponent);
+      if (props) {
+        for (const key in props) {
+          if (key !== "value" && !isReservedProp(key)) {
+            hostPatchProp(el, key, null, props[key], namespace, parentComponent);
+          }
+        }
+        if ("value" in props) {
+          hostPatchProp(el, "value", null, props.value, namespace);
+        }
+        if (vnodeHook = props.onVnodeBeforeMount) {
+          invokeVNodeHook(vnodeHook, parentComponent, vnode);
+        }
+      }
+      {
+        def(el, "__vnode", vnode, true);
+        def(el, "__vueParentComponent", parentComponent, true);
+      }
+      if (dirs) {
+        invokeDirectiveHook(vnode, null, parentComponent, "beforeMount");
+      }
+      const needCallTransitionHooks = needTransition(parentSuspense, transition);
+      if (needCallTransitionHooks) {
+        transition.beforeEnter(el);
+      }
+      hostInsert(el, container, anchor);
+      if ((vnodeHook = props && props.onVnodeMounted) || needCallTransitionHooks || dirs) {
+        queuePostRenderEffect(() => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+          needCallTransitionHooks && transition.enter(el);
+          dirs && invokeDirectiveHook(vnode, null, parentComponent, "mounted");
+        }, parentSuspense);
+      }
+    };
+    const setScopeId = (el, vnode, scopeId, slotScopeIds, parentComponent) => {
+      if (scopeId) {
+        hostSetScopeId(el, scopeId);
+      }
+      if (slotScopeIds) {
+        for (let i = 0; i < slotScopeIds.length; i++) {
+          hostSetScopeId(el, slotScopeIds[i]);
+        }
+      }
+      if (parentComponent) {
+        let subTree = parentComponent.subTree;
+        if (subTree.patchFlag > 0 && subTree.patchFlag & 2048) {
+          subTree = filterSingleRoot(subTree.children) || subTree;
+        }
+        if (vnode === subTree || isSuspense(subTree.type) && (subTree.ssContent === vnode || subTree.ssFallback === vnode)) {
+          const parentVNode = parentComponent.vnode;
+          setScopeId(
+            el,
+            parentVNode,
+            parentVNode.scopeId,
+            parentVNode.slotScopeIds,
+            parentComponent.parent
+          );
+        }
+      }
+    };
+    const mountChildren = (children, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, start = 0) => {
+      for (let i = start; i < children.length; i++) {
+        const child = children[i] = optimized ? cloneIfMounted(children[i]) : normalizeVNode(children[i]);
+        patch(
+          null,
+          child,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      }
+    };
+    const patchElement = (n1, n2, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      const el = n2.el = n1.el;
+      {
+        el.__vnode = n2;
+      }
+      let { patchFlag, dynamicChildren, dirs } = n2;
+      patchFlag |= n1.patchFlag & 16;
+      const oldProps = n1.props || EMPTY_OBJ;
+      const newProps = n2.props || EMPTY_OBJ;
+      let vnodeHook;
+      parentComponent && toggleRecurse(parentComponent, false);
+      if (vnodeHook = newProps.onVnodeBeforeUpdate) {
+        invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+      }
+      if (dirs) {
+        invokeDirectiveHook(n2, n1, parentComponent, "beforeUpdate");
+      }
+      parentComponent && toggleRecurse(parentComponent, true);
+      if (isHmrUpdating) {
+        patchFlag = 0;
+        optimized = false;
+        dynamicChildren = null;
+      }
+      if (oldProps.innerHTML && newProps.innerHTML == null || oldProps.textContent && newProps.textContent == null) {
+        hostSetElementText(el, "");
+      }
+      if (dynamicChildren) {
+        patchBlockChildren(
+          n1.dynamicChildren,
+          dynamicChildren,
+          el,
+          parentComponent,
+          parentSuspense,
+          resolveChildrenNamespace(n2, namespace),
+          slotScopeIds
+        );
+        {
+          traverseStaticChildren(n1, n2);
+        }
+      } else if (!optimized) {
+        patchChildren(
+          n1,
+          n2,
+          el,
+          null,
+          parentComponent,
+          parentSuspense,
+          resolveChildrenNamespace(n2, namespace),
+          slotScopeIds,
+          false
+        );
+      }
+      if (patchFlag > 0) {
+        if (patchFlag & 16) {
+          patchProps(el, oldProps, newProps, parentComponent, namespace);
+        } else {
+          if (patchFlag & 2) {
+            if (oldProps.class !== newProps.class) {
+              hostPatchProp(el, "class", null, newProps.class, namespace);
+            }
+          }
+          if (patchFlag & 4) {
+            hostPatchProp(el, "style", oldProps.style, newProps.style, namespace);
+          }
+          if (patchFlag & 8) {
+            const propsToUpdate = n2.dynamicProps;
+            for (let i = 0; i < propsToUpdate.length; i++) {
+              const key = propsToUpdate[i];
+              const prev = oldProps[key];
+              const next = newProps[key];
+              if (next !== prev || key === "value") {
+                hostPatchProp(el, key, prev, next, namespace, parentComponent);
+              }
+            }
+          }
+        }
+        if (patchFlag & 1) {
+          if (n1.children !== n2.children) {
+            hostSetElementText(el, n2.children);
+          }
+        }
+      } else if (!optimized && dynamicChildren == null) {
+        patchProps(el, oldProps, newProps, parentComponent, namespace);
+      }
+      if ((vnodeHook = newProps.onVnodeUpdated) || dirs) {
+        queuePostRenderEffect(() => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1);
+          dirs && invokeDirectiveHook(n2, n1, parentComponent, "updated");
+        }, parentSuspense);
+      }
+    };
+    const patchBlockChildren = (oldChildren, newChildren, fallbackContainer, parentComponent, parentSuspense, namespace, slotScopeIds) => {
+      for (let i = 0; i < newChildren.length; i++) {
+        const oldVNode = oldChildren[i];
+        const newVNode = newChildren[i];
+        const container = (
+          // oldVNode may be an errored async setup() component inside Suspense
+          // which will not have a mounted element
+          oldVNode.el && // - In the case of a Fragment, we need to provide the actual parent
+          // of the Fragment itself so it can move its children.
+          (oldVNode.type === Fragment || // - In the case of different nodes, there is going to be a replacement
+          // which also requires the correct parent container
+          !isSameVNodeType(oldVNode, newVNode) || // - In the case of a component, it could contain anything.
+          oldVNode.shapeFlag & (6 | 64 | 128)) ? hostParentNode(oldVNode.el) : (
+            // In other cases, the parent container is not actually used so we
+            // just pass the block element here to avoid a DOM parentNode call.
+            fallbackContainer
+          )
+        );
+        patch(
+          oldVNode,
+          newVNode,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          true
+        );
+      }
+    };
+    const patchProps = (el, oldProps, newProps, parentComponent, namespace) => {
+      if (oldProps !== newProps) {
+        if (oldProps !== EMPTY_OBJ) {
+          for (const key in oldProps) {
+            if (!isReservedProp(key) && !(key in newProps)) {
+              hostPatchProp(
+                el,
+                key,
+                oldProps[key],
+                null,
+                namespace,
+                parentComponent
+              );
+            }
+          }
+        }
+        for (const key in newProps) {
+          if (isReservedProp(key)) continue;
+          const next = newProps[key];
+          const prev = oldProps[key];
+          if (next !== prev && key !== "value") {
+            hostPatchProp(el, key, prev, next, namespace, parentComponent);
+          }
+        }
+        if ("value" in newProps) {
+          hostPatchProp(el, "value", oldProps.value, newProps.value, namespace);
+        }
+      }
+    };
+    const processFragment = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      const fragmentStartAnchor = n2.el = n1 ? n1.el : hostCreateText("");
+      const fragmentEndAnchor = n2.anchor = n1 ? n1.anchor : hostCreateText("");
+      let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
+      if (
+        // #5523 dev root fragment may inherit directives
+        isHmrUpdating || patchFlag & 2048
+      ) {
+        patchFlag = 0;
+        optimized = false;
+        dynamicChildren = null;
+      }
+      if (fragmentSlotScopeIds) {
+        slotScopeIds = slotScopeIds ? slotScopeIds.concat(fragmentSlotScopeIds) : fragmentSlotScopeIds;
+      }
+      if (n1 == null) {
+        hostInsert(fragmentStartAnchor, container, anchor);
+        hostInsert(fragmentEndAnchor, container, anchor);
+        mountChildren(
+          // #10007
+          // such fragment like `<></>` will be compiled into
+          // a fragment which doesn't have a children.
+          // In this case fallback to an empty array
+          n2.children || [],
+          container,
+          fragmentEndAnchor,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      } else {
+        if (patchFlag > 0 && patchFlag & 64 && dynamicChildren && // #2715 the previous fragment could've been a BAILed one as a result
+        // of renderSlot() with no valid children
+        n1.dynamicChildren) {
+          patchBlockChildren(
+            n1.dynamicChildren,
+            dynamicChildren,
+            container,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds
+          );
+          {
+            traverseStaticChildren(n1, n2);
+          }
+        } else {
+          patchChildren(
+            n1,
+            n2,
+            container,
+            fragmentEndAnchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+        }
+      }
+    };
+    const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      n2.slotScopeIds = slotScopeIds;
+      if (n1 == null) {
+        if (n2.shapeFlag & 512) {
+          parentComponent.ctx.activate(
+            n2,
+            container,
+            anchor,
+            namespace,
+            optimized
+          );
+        } else {
+          mountComponent(
+            n2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            optimized
+          );
+        }
+      } else {
+        updateComponent(n1, n2, optimized);
+      }
+    };
+    const mountComponent = (initialVNode, container, anchor, parentComponent, parentSuspense, namespace, optimized) => {
+      const instance = (initialVNode.component = createComponentInstance(
+        initialVNode,
+        parentComponent,
+        parentSuspense
+      ));
+      if (instance.type.__hmrId) {
+        registerHMR(instance);
+      }
+      {
+        pushWarningContext(initialVNode);
+        startMeasure(instance, `mount`);
+      }
+      if (isKeepAlive(initialVNode)) {
+        instance.ctx.renderer = internals;
+      }
+      {
+        {
+          startMeasure(instance, `init`);
+        }
+        setupComponent(instance, false, optimized);
+        {
+          endMeasure(instance, `init`);
+        }
+      }
+      if (isHmrUpdating) initialVNode.el = null;
+      if (instance.asyncDep) {
+        parentSuspense && parentSuspense.registerDep(instance, setupRenderEffect, optimized);
+        if (!initialVNode.el) {
+          const placeholder = instance.subTree = createVNode(Comment);
+          processCommentNode(null, placeholder, container, anchor);
+        }
+      } else {
+        setupRenderEffect(
+          instance,
+          initialVNode,
+          container,
+          anchor,
+          parentSuspense,
+          namespace,
+          optimized
+        );
+      }
+      {
+        popWarningContext();
+        endMeasure(instance, `mount`);
+      }
+    };
+    const updateComponent = (n1, n2, optimized) => {
+      const instance = n2.component = n1.component;
+      if (shouldUpdateComponent(n1, n2, optimized)) {
+        if (instance.asyncDep && !instance.asyncResolved) {
+          {
+            pushWarningContext(n2);
+          }
+          updateComponentPreRender(instance, n2, optimized);
+          {
+            popWarningContext();
+          }
+          return;
+        } else {
+          instance.next = n2;
+          instance.update();
+        }
+      } else {
+        n2.el = n1.el;
+        instance.vnode = n2;
+      }
+    };
+    const setupRenderEffect = (instance, initialVNode, container, anchor, parentSuspense, namespace, optimized) => {
+      const componentUpdateFn = () => {
+        if (!instance.isMounted) {
+          let vnodeHook;
+          const { el, props } = initialVNode;
+          const { bm, m, parent, root, type } = instance;
+          const isAsyncWrapperVNode = isAsyncWrapper(initialVNode);
+          toggleRecurse(instance, false);
+          if (bm) {
+            invokeArrayFns(bm);
+          }
+          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeBeforeMount)) {
+            invokeVNodeHook(vnodeHook, parent, initialVNode);
+          }
+          toggleRecurse(instance, true);
+          if (el && hydrateNode) {
+            const hydrateSubTree = () => {
+              {
+                startMeasure(instance, `render`);
+              }
+              instance.subTree = renderComponentRoot(instance);
+              {
+                endMeasure(instance, `render`);
+              }
+              {
+                startMeasure(instance, `hydrate`);
+              }
+              hydrateNode(
+                el,
+                instance.subTree,
+                instance,
+                parentSuspense,
+                null
+              );
+              {
+                endMeasure(instance, `hydrate`);
+              }
+            };
+            if (isAsyncWrapperVNode && type.__asyncHydrate) {
+              type.__asyncHydrate(
+                el,
+                instance,
+                hydrateSubTree
+              );
+            } else {
+              hydrateSubTree();
+            }
+          } else {
+            if (root.ce && // @ts-expect-error _def is private
+            root.ce._def.shadowRoot !== false) {
+              root.ce._injectChildStyle(type);
+            }
+            {
+              startMeasure(instance, `render`);
+            }
+            const subTree = instance.subTree = renderComponentRoot(instance);
+            {
+              endMeasure(instance, `render`);
+            }
+            {
+              startMeasure(instance, `patch`);
+            }
+            patch(
+              null,
+              subTree,
+              container,
+              anchor,
+              instance,
+              parentSuspense,
+              namespace
+            );
+            {
+              endMeasure(instance, `patch`);
+            }
+            initialVNode.el = subTree.el;
+          }
+          if (m) {
+            queuePostRenderEffect(m, parentSuspense);
+          }
+          if (!isAsyncWrapperVNode && (vnodeHook = props && props.onVnodeMounted)) {
+            const scopedInitialVNode = initialVNode;
+            queuePostRenderEffect(
+              () => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode),
+              parentSuspense
+            );
+          }
+          if (initialVNode.shapeFlag & 256 || parent && isAsyncWrapper(parent.vnode) && parent.vnode.shapeFlag & 256) {
+            instance.a && queuePostRenderEffect(instance.a, parentSuspense);
+          }
+          instance.isMounted = true;
+          {
+            devtoolsComponentAdded(instance);
+          }
+          initialVNode = container = anchor = null;
+        } else {
+          let { next, bu, u, parent, vnode } = instance;
+          {
+            const nonHydratedAsyncRoot = locateNonHydratedAsyncRoot(instance);
+            if (nonHydratedAsyncRoot) {
+              if (next) {
+                next.el = vnode.el;
+                updateComponentPreRender(instance, next, optimized);
+              }
+              nonHydratedAsyncRoot.asyncDep.then(() => {
+                if (!instance.isUnmounted) {
+                  componentUpdateFn();
+                }
+              });
+              return;
+            }
+          }
+          let originNext = next;
+          let vnodeHook;
+          {
+            pushWarningContext(next || instance.vnode);
+          }
+          toggleRecurse(instance, false);
+          if (next) {
+            next.el = vnode.el;
+            updateComponentPreRender(instance, next, optimized);
+          } else {
+            next = vnode;
+          }
+          if (bu) {
+            invokeArrayFns(bu);
+          }
+          if (vnodeHook = next.props && next.props.onVnodeBeforeUpdate) {
+            invokeVNodeHook(vnodeHook, parent, next, vnode);
+          }
+          toggleRecurse(instance, true);
+          {
+            startMeasure(instance, `render`);
+          }
+          const nextTree = renderComponentRoot(instance);
+          {
+            endMeasure(instance, `render`);
+          }
+          const prevTree = instance.subTree;
+          instance.subTree = nextTree;
+          {
+            startMeasure(instance, `patch`);
+          }
+          patch(
+            prevTree,
+            nextTree,
+            // parent may have changed if it's in a teleport
+            hostParentNode(prevTree.el),
+            // anchor may have changed if it's in a fragment
+            getNextHostNode(prevTree),
+            instance,
+            parentSuspense,
+            namespace
+          );
+          {
+            endMeasure(instance, `patch`);
+          }
+          next.el = nextTree.el;
+          if (originNext === null) {
+            updateHOCHostEl(instance, nextTree.el);
+          }
+          if (u) {
+            queuePostRenderEffect(u, parentSuspense);
+          }
+          if (vnodeHook = next.props && next.props.onVnodeUpdated) {
+            queuePostRenderEffect(
+              () => invokeVNodeHook(vnodeHook, parent, next, vnode),
+              parentSuspense
+            );
+          }
+          {
+            devtoolsComponentUpdated(instance);
+          }
+          {
+            popWarningContext();
+          }
+        }
+      };
+      instance.scope.on();
+      const effect = instance.effect = new ReactiveEffect(componentUpdateFn);
+      instance.scope.off();
+      const update = instance.update = effect.run.bind(effect);
+      const job = instance.job = effect.runIfDirty.bind(effect);
+      job.i = instance;
+      job.id = instance.uid;
+      effect.scheduler = () => queueJob(job);
+      toggleRecurse(instance, true);
+      {
+        effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
+        effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
+      }
+      update();
+    };
+    const updateComponentPreRender = (instance, nextVNode, optimized) => {
+      nextVNode.component = instance;
+      const prevProps = instance.vnode.props;
+      instance.vnode = nextVNode;
+      instance.next = null;
+      updateProps(instance, nextVNode.props, prevProps, optimized);
+      updateSlots(instance, nextVNode.children, optimized);
+      pauseTracking();
+      flushPreFlushCbs(instance);
+      resetTracking();
+    };
+    const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized = false) => {
+      const c1 = n1 && n1.children;
+      const prevShapeFlag = n1 ? n1.shapeFlag : 0;
+      const c2 = n2.children;
+      const { patchFlag, shapeFlag } = n2;
+      if (patchFlag > 0) {
+        if (patchFlag & 128) {
+          patchKeyedChildren(
+            c1,
+            c2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          return;
+        } else if (patchFlag & 256) {
+          patchUnkeyedChildren(
+            c1,
+            c2,
+            container,
+            anchor,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          return;
+        }
+      }
+      if (shapeFlag & 8) {
+        if (prevShapeFlag & 16) {
+          unmountChildren(c1, parentComponent, parentSuspense);
+        }
+        if (c2 !== c1) {
+          hostSetElementText(container, c2);
+        }
+      } else {
+        if (prevShapeFlag & 16) {
+          if (shapeFlag & 16) {
+            patchKeyedChildren(
+              c1,
+              c2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          } else {
+            unmountChildren(c1, parentComponent, parentSuspense, true);
+          }
+        } else {
+          if (prevShapeFlag & 8) {
+            hostSetElementText(container, "");
+          }
+          if (shapeFlag & 16) {
+            mountChildren(
+              c2,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          }
+        }
+      }
+    };
+    const patchUnkeyedChildren = (c1, c2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      c1 = c1 || EMPTY_ARR;
+      c2 = c2 || EMPTY_ARR;
+      const oldLength = c1.length;
+      const newLength = c2.length;
+      const commonLength = Math.min(oldLength, newLength);
+      let i;
+      for (i = 0; i < commonLength; i++) {
+        const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+        patch(
+          c1[i],
+          nextChild,
+          container,
+          null,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+      }
+      if (oldLength > newLength) {
+        unmountChildren(
+          c1,
+          parentComponent,
+          parentSuspense,
+          true,
+          false,
+          commonLength
+        );
+      } else {
+        mountChildren(
+          c2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized,
+          commonLength
+        );
+      }
+    };
+    const patchKeyedChildren = (c1, c2, container, parentAnchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized) => {
+      let i = 0;
+      const l2 = c2.length;
+      let e1 = c1.length - 1;
+      let e2 = l2 - 1;
+      while (i <= e1 && i <= e2) {
+        const n1 = c1[i];
+        const n2 = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+        if (isSameVNodeType(n1, n2)) {
+          patch(
+            n1,
+            n2,
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+        } else {
+          break;
+        }
+        i++;
+      }
+      while (i <= e1 && i <= e2) {
+        const n1 = c1[e1];
+        const n2 = c2[e2] = optimized ? cloneIfMounted(c2[e2]) : normalizeVNode(c2[e2]);
+        if (isSameVNodeType(n1, n2)) {
+          patch(
+            n1,
+            n2,
+            container,
+            null,
+            parentComponent,
+            parentSuspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+        } else {
+          break;
+        }
+        e1--;
+        e2--;
+      }
+      if (i > e1) {
+        if (i <= e2) {
+          const nextPos = e2 + 1;
+          const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor;
+          while (i <= e2) {
+            patch(
+              null,
+              c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]),
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+            i++;
+          }
+        }
+      } else if (i > e2) {
+        while (i <= e1) {
+          unmount(c1[i], parentComponent, parentSuspense, true);
+          i++;
+        }
+      } else {
+        const s1 = i;
+        const s2 = i;
+        const keyToNewIndexMap = /* @__PURE__ */ new Map();
+        for (i = s2; i <= e2; i++) {
+          const nextChild = c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i]);
+          if (nextChild.key != null) {
+            if (keyToNewIndexMap.has(nextChild.key)) {
+              warn$1(
+                `Duplicate keys found during update:`,
+                JSON.stringify(nextChild.key),
+                `Make sure keys are unique.`
+              );
+            }
+            keyToNewIndexMap.set(nextChild.key, i);
+          }
+        }
+        let j;
+        let patched = 0;
+        const toBePatched = e2 - s2 + 1;
+        let moved = false;
+        let maxNewIndexSoFar = 0;
+        const newIndexToOldIndexMap = new Array(toBePatched);
+        for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0;
+        for (i = s1; i <= e1; i++) {
+          const prevChild = c1[i];
+          if (patched >= toBePatched) {
+            unmount(prevChild, parentComponent, parentSuspense, true);
+            continue;
+          }
+          let newIndex;
+          if (prevChild.key != null) {
+            newIndex = keyToNewIndexMap.get(prevChild.key);
+          } else {
+            for (j = s2; j <= e2; j++) {
+              if (newIndexToOldIndexMap[j - s2] === 0 && isSameVNodeType(prevChild, c2[j])) {
+                newIndex = j;
+                break;
+              }
+            }
+          }
+          if (newIndex === void 0) {
+            unmount(prevChild, parentComponent, parentSuspense, true);
+          } else {
+            newIndexToOldIndexMap[newIndex - s2] = i + 1;
+            if (newIndex >= maxNewIndexSoFar) {
+              maxNewIndexSoFar = newIndex;
+            } else {
+              moved = true;
+            }
+            patch(
+              prevChild,
+              c2[newIndex],
+              container,
+              null,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+            patched++;
+          }
+        }
+        const increasingNewIndexSequence = moved ? getSequence(newIndexToOldIndexMap) : EMPTY_ARR;
+        j = increasingNewIndexSequence.length - 1;
+        for (i = toBePatched - 1; i >= 0; i--) {
+          const nextIndex = s2 + i;
+          const nextChild = c2[nextIndex];
+          const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor;
+          if (newIndexToOldIndexMap[i] === 0) {
+            patch(
+              null,
+              nextChild,
+              container,
+              anchor,
+              parentComponent,
+              parentSuspense,
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+          } else if (moved) {
+            if (j < 0 || i !== increasingNewIndexSequence[j]) {
+              move(nextChild, container, anchor, 2);
+            } else {
+              j--;
+            }
+          }
+        }
+      }
+    };
+    const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
+      const { el, type, transition, children, shapeFlag } = vnode;
+      if (shapeFlag & 6) {
+        move(vnode.component.subTree, container, anchor, moveType);
+        return;
+      }
+      if (shapeFlag & 128) {
+        vnode.suspense.move(container, anchor, moveType);
+        return;
+      }
+      if (shapeFlag & 64) {
+        type.move(vnode, container, anchor, internals);
+        return;
+      }
+      if (type === Fragment) {
+        hostInsert(el, container, anchor);
+        for (let i = 0; i < children.length; i++) {
+          move(children[i], container, anchor, moveType);
+        }
+        hostInsert(vnode.anchor, container, anchor);
+        return;
+      }
+      if (type === Static) {
+        moveStaticNode(vnode, container, anchor);
+        return;
+      }
+      const needTransition2 = moveType !== 2 && shapeFlag & 1 && transition;
+      if (needTransition2) {
+        if (moveType === 0) {
+          transition.beforeEnter(el);
+          hostInsert(el, container, anchor);
+          queuePostRenderEffect(() => transition.enter(el), parentSuspense);
+        } else {
+          const { leave, delayLeave, afterLeave } = transition;
+          const remove2 = () => {
+            if (vnode.ctx.isUnmounted) {
+              hostRemove(el);
+            } else {
+              hostInsert(el, container, anchor);
+            }
+          };
+          const performLeave = () => {
+            leave(el, () => {
+              remove2();
+              afterLeave && afterLeave();
+            });
+          };
+          if (delayLeave) {
+            delayLeave(el, remove2, performLeave);
+          } else {
+            performLeave();
+          }
+        }
+      } else {
+        hostInsert(el, container, anchor);
+      }
+    };
+    const unmount = (vnode, parentComponent, parentSuspense, doRemove = false, optimized = false) => {
+      const {
+        type,
+        props,
+        ref,
+        children,
+        dynamicChildren,
+        shapeFlag,
+        patchFlag,
+        dirs,
+        cacheIndex
+      } = vnode;
+      if (patchFlag === -2) {
+        optimized = false;
+      }
+      if (ref != null) {
+        pauseTracking();
+        setRef(ref, null, parentSuspense, vnode, true);
+        resetTracking();
+      }
+      if (cacheIndex != null) {
+        parentComponent.renderCache[cacheIndex] = void 0;
+      }
+      if (shapeFlag & 256) {
+        parentComponent.ctx.deactivate(vnode);
+        return;
+      }
+      const shouldInvokeDirs = shapeFlag & 1 && dirs;
+      const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
+      let vnodeHook;
+      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeBeforeUnmount)) {
+        invokeVNodeHook(vnodeHook, parentComponent, vnode);
+      }
+      if (shapeFlag & 6) {
+        unmountComponent(vnode.component, parentSuspense, doRemove);
+      } else {
+        if (shapeFlag & 128) {
+          vnode.suspense.unmount(parentSuspense, doRemove);
+          return;
         }
-        if (Dep.target) {
-          watcher.depend();
+        if (shouldInvokeDirs) {
+          invokeDirectiveHook(vnode, null, parentComponent, "beforeUnmount");
         }
-        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 (typeof methods[key] !== 'function') {
-          warn(
-            "Method \"" + key + "\" has type \"" + (typeof methods[key]) + "\" in the component definition. " +
-            "Did you reference the function correctly?",
-            vm
+        if (shapeFlag & 64) {
+          vnode.type.remove(
+            vnode,
+            parentComponent,
+            parentSuspense,
+            internals,
+            doRemove
           );
-        }
-        if (props && hasOwn(props, key)) {
-          warn(
-            ("Method \"" + key + "\" has already been defined as a prop."),
-            vm
+        } else if (dynamicChildren && // #5154
+        // when v-once is used inside a block, setBlockTracking(-1) marks the
+        // parent block with hasOnce: true
+        // so that it doesn't take the fast path during unmount - otherwise
+        // components nested in v-once are never unmounted.
+        !dynamicChildren.hasOnce && // #1153: fast path should not be taken for non-stable (v-for) fragments
+        (type !== Fragment || patchFlag > 0 && patchFlag & 64)) {
+          unmountChildren(
+            dynamicChildren,
+            parentComponent,
+            parentSuspense,
+            false,
+            true
           );
+        } else if (type === Fragment && patchFlag & (128 | 256) || !optimized && shapeFlag & 16) {
+          unmountChildren(children, parentComponent, parentSuspense);
         }
-        if ((key in vm) && isReserved(key)) {
-          warn(
-            "Method \"" + key + "\" conflicts with an existing Vue instance method. " +
-            "Avoid defining component methods that start with _ or $."
-          );
+        if (doRemove) {
+          remove(vnode);
         }
       }
-      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]);
+      if (shouldInvokeVnodeHook && (vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) {
+        queuePostRenderEffect(() => {
+          vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode);
+          shouldInvokeDirs && invokeDirectiveHook(vnode, null, parentComponent, "unmounted");
+        }, parentSuspense);
+      }
+    };
+    const remove = (vnode) => {
+      const { type, el, anchor, transition } = vnode;
+      if (type === Fragment) {
+        if (vnode.patchFlag > 0 && vnode.patchFlag & 2048 && transition && !transition.persisted) {
+          vnode.children.forEach((child) => {
+            if (child.type === Comment) {
+              hostRemove(child.el);
+            } else {
+              remove(child);
+            }
+          });
+        } else {
+          removeFragment(el, anchor);
         }
-      } else {
-        createWatcher(vm, key, handler);
+        return;
       }
-    }
-  }
-
-  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
-        );
-      };
-      propsDef.set = function () {
-        warn("$props is readonly.", this);
+      if (type === Static) {
+        removeStaticNode(vnode);
+        return;
+      }
+      const performRemove = () => {
+        hostRemove(el);
+        if (transition && !transition.persisted && transition.afterLeave) {
+          transition.afterLeave();
+        }
       };
-    }
-    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) + "\""));
+      if (vnode.shapeFlag & 1 && transition && !transition.persisted) {
+        const { leave, delayLeave } = transition;
+        const performLeave = () => leave(el, performRemove);
+        if (delayLeave) {
+          delayLeave(vnode.el, performRemove, performLeave);
+        } else {
+          performLeave();
         }
-      }
-      return function unwatchFn () {
-        watcher.teardown();
+      } else {
+        performRemove();
       }
     };
-  }
-
-  /*  */
-
-  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);
+    const removeFragment = (cur, end) => {
+      let next;
+      while (cur !== end) {
+        next = hostNextSibling(cur);
+        hostRemove(cur);
+        cur = next;
+      }
+      hostRemove(end);
+    };
+    const unmountComponent = (instance, parentSuspense, doRemove) => {
+      if (instance.type.__hmrId) {
+        unregisterHMR(instance);
+      }
+      const {
+        bum,
+        scope,
+        job,
+        subTree,
+        um,
+        m,
+        a,
+        parent,
+        slots: { __: slotCacheKeys }
+      } = instance;
+      invalidateMount(m);
+      invalidateMount(a);
+      if (bum) {
+        invokeArrayFns(bum);
+      }
+      if (parent && isArray(slotCacheKeys)) {
+        slotCacheKeys.forEach((v) => {
+          parent.renderCache[v] = void 0;
+        });
       }
-
-      // 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
-        );
+      scope.stop();
+      if (job) {
+        job.flags |= 8;
+        unmount(subTree, instance, parentSuspense, doRemove);
+      }
+      if (um) {
+        queuePostRenderEffect(um, parentSuspense);
+      }
+      queuePostRenderEffect(() => {
+        instance.isUnmounted = true;
+      }, parentSuspense);
+      if (parentSuspense && parentSuspense.pendingBranch && !parentSuspense.isUnmounted && instance.asyncDep && !instance.asyncResolved && instance.suspenseId === parentSuspense.pendingId) {
+        parentSuspense.deps--;
+        if (parentSuspense.deps === 0) {
+          parentSuspense.resolve();
+        }
       }
-      /* istanbul ignore else */
       {
-        initProxy(vm);
+        devtoolsComponentRemoved(instance);
       }
-      // 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);
+    };
+    const unmountChildren = (children, parentComponent, parentSuspense, doRemove = false, optimized = false, start = 0) => {
+      for (let i = start; i < children.length; i++) {
+        unmount(children[i], parentComponent, parentSuspense, doRemove, optimized);
       }
-
-      if (vm.$options.el) {
-        vm.$mount(vm.$options.el);
+    };
+    const getNextHostNode = (vnode) => {
+      if (vnode.shapeFlag & 6) {
+        return getNextHostNode(vnode.component.subTree);
+      }
+      if (vnode.shapeFlag & 128) {
+        return vnode.suspense.next();
+      }
+      const el = hostNextSibling(vnode.anchor || vnode.el);
+      const teleportEnd = el && el[TeleportEndKey];
+      return teleportEnd ? hostNextSibling(teleportEnd) : el;
+    };
+    let isFlushing = false;
+    const render = (vnode, container, namespace) => {
+      if (vnode == null) {
+        if (container._vnode) {
+          unmount(container._vnode, null, null, true);
+        }
+      } else {
+        patch(
+          container._vnode || null,
+          vnode,
+          container,
+          null,
+          null,
+          null,
+          namespace
+        );
+      }
+      container._vnode = vnode;
+      if (!isFlushing) {
+        isFlushing = true;
+        flushPreFlushCbs();
+        flushPostFlushCbs();
+        isFlushing = false;
       }
     };
+    const internals = {
+      p: patch,
+      um: unmount,
+      m: move,
+      r: remove,
+      mt: mountComponent,
+      mc: mountChildren,
+      pc: patchChildren,
+      pbc: patchBlockChildren,
+      n: getNextHostNode,
+      o: options
+    };
+    let hydrate;
+    let hydrateNode;
+    if (createHydrationFns) {
+      [hydrate, hydrateNode] = createHydrationFns(
+        internals
+      );
+    }
+    return {
+      render,
+      hydrate,
+      createApp: createAppAPI(render, hydrate)
+    };
   }
-
-  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 resolveChildrenNamespace({ type, props }, currentNamespace) {
+    return currentNamespace === "svg" && type === "foreignObject" || currentNamespace === "mathml" && type === "annotation-xml" && props && props.encoding && props.encoding.includes("html") ? void 0 : currentNamespace;
+  }
+  function toggleRecurse({ effect, job }, allowed) {
+    if (allowed) {
+      effect.flags |= 32;
+      job.flags |= 4;
+    } else {
+      effect.flags &= -33;
+      job.flags &= -5;
+    }
+  }
+  function needTransition(parentSuspense, transition) {
+    return (!parentSuspense || parentSuspense && !parentSuspense.pendingBranch) && transition && !transition.persisted;
+  }
+  function traverseStaticChildren(n1, n2, shallow = false) {
+    const ch1 = n1.children;
+    const ch2 = n2.children;
+    if (isArray(ch1) && isArray(ch2)) {
+      for (let i = 0; i < ch1.length; i++) {
+        const c1 = ch1[i];
+        let c2 = ch2[i];
+        if (c2.shapeFlag & 1 && !c2.dynamicChildren) {
+          if (c2.patchFlag <= 0 || c2.patchFlag === 32) {
+            c2 = ch2[i] = cloneIfMounted(ch2[i]);
+            c2.el = c1.el;
+          }
+          if (!shallow && c2.patchFlag !== -2)
+            traverseStaticChildren(c1, c2);
+        }
+        if (c2.type === Text) {
+          c2.el = c1.el;
+        }
+        if (c2.type === Comment && !c2.el) {
+          c2.el = c1.el;
+        }
+        {
+          c2.el && (c2.el.__vnode = c2);
+        }
+      }
     }
   }
-
-  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);
+  function getSequence(arr) {
+    const p = arr.slice();
+    const result = [0];
+    let i, j, u, v, c;
+    const len = arr.length;
+    for (i = 0; i < len; i++) {
+      const arrI = arr[i];
+      if (arrI !== 0) {
+        j = result[result.length - 1];
+        if (arr[j] < arrI) {
+          p[i] = j;
+          result.push(i);
+          continue;
+        }
+        u = 0;
+        v = result.length - 1;
+        while (u < v) {
+          c = u + v >> 1;
+          if (arr[result[c]] < arrI) {
+            u = c + 1;
+          } else {
+            v = c;
+          }
         }
-        options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
-        if (options.name) {
-          options.components[options.name] = Ctor;
+        if (arrI < arr[result[u]]) {
+          if (u > 0) {
+            p[i] = result[u - 1];
+          }
+          result[u] = i;
         }
       }
     }
-    return options
+    u = result.length;
+    v = result[u - 1];
+    while (u-- > 0) {
+      result[u] = v;
+      v = p[v];
+    }
+    return result;
   }
-
-  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 locateNonHydratedAsyncRoot(instance) {
+    const subComponent = instance.subTree.component;
+    if (subComponent) {
+      if (subComponent.asyncDep && !subComponent.asyncResolved) {
+        return subComponent;
+      } else {
+        return locateNonHydratedAsyncRoot(subComponent);
       }
     }
-    return modified
   }
-
-  function Vue (options) {
-    if (!(this instanceof Vue)
-    ) {
-      warn('Vue is a constructor and should be called with the `new` keyword');
+  function invalidateMount(hooks) {
+    if (hooks) {
+      for (let i = 0; i < hooks.length; i++)
+        hooks[i].flags |= 8;
     }
-    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
-      }
+  const ssrContextKey = Symbol.for("v-scx");
+  const useSSRContext = () => {
+    {
+      warn$1(`useSSRContext() is not supported in the global build.`);
+    }
+  };
 
-      // 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 watchEffect(effect, options) {
+    return doWatch(effect, null, options);
   }
-
-  /*  */
-
-  function initMixin$1 (Vue) {
-    Vue.mixin = function (mixin) {
-      this.options = mergeOptions(this.options, mixin);
-      return this
-    };
+  function watchPostEffect(effect, options) {
+    return doWatch(
+      effect,
+      null,
+      extend({}, options, { flush: "post" }) 
+    );
   }
-
-  /*  */
-
-  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
+  function watchSyncEffect(effect, options) {
+    return doWatch(
+      effect,
+      null,
+      extend({}, options, { flush: "sync" }) 
+    );
+  }
+  function watch(source, cb, options) {
+    if (!isFunction(cb)) {
+      warn$1(
+        `\`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.`
       );
-      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);
+    }
+    return doWatch(source, cb, options);
+  }
+  function doWatch(source, cb, options = EMPTY_OBJ) {
+    const { immediate, deep, flush, once } = options;
+    if (!cb) {
+      if (immediate !== void 0) {
+        warn$1(
+          `watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
+        );
       }
-      if (Sub.options.computed) {
-        initComputed$1(Sub);
+      if (deep !== void 0) {
+        warn$1(
+          `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
+        );
       }
-
-      // 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;
+      if (once !== void 0) {
+        warn$1(
+          `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
+        );
       }
-
-      // 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]
+    const baseWatchOptions = extend({}, options);
+    baseWatchOptions.onWarn = warn$1;
+    const instance = currentInstance;
+    baseWatchOptions.call = (fn, type, args) => callWithAsyncErrorHandling(fn, instance, type, args);
+    let isPre = false;
+    if (flush === "post") {
+      baseWatchOptions.scheduler = (job) => {
+        queuePostRenderEffect(job, instance && instance.suspense);
+      };
+    } else if (flush !== "sync") {
+      isPre = true;
+      baseWatchOptions.scheduler = (job, isFirstRun) => {
+        if (isFirstRun) {
+          job();
         } else {
-          /* istanbul ignore if */
-          if (type === 'component') {
-            validateComponentName(id);
-          }
-          if (type === 'component' && isPlainObject(definition)) {
-            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
+          queueJob(job);
         }
       };
-    });
-  }
-
-  /*  */
-
-
-
-  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);
+    baseWatchOptions.augmentJob = (job) => {
+      if (cb) {
+        job.flags |= 4;
+      }
+      if (isPre) {
+        job.flags |= 2;
+        if (instance) {
+          job.id = instance.uid;
+          job.i = instance;
         }
       }
-    }
-  }
-
-  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);
+    };
+    const watchHandle = watch$1(source, cb, baseWatchOptions);
+    return watchHandle;
+  }
+  function instanceWatch(source, value, options) {
+    const publicThis = this.proxy;
+    const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
+    let cb;
+    if (isFunction(value)) {
+      cb = value;
+    } else {
+      cb = value.handler;
+      options = value;
+    }
+    const reset = setCurrentInstance(this);
+    const res = doWatch(getter, cb.bind(publicThis), options);
+    reset();
+    return res;
+  }
+  function createPathGetter(ctx, path) {
+    const segments = path.split(".");
+    return () => {
+      let cur = ctx;
+      for (let i = 0; i < segments.length && cur; i++) {
+        cur = cur[segments[i]];
+      }
+      return cur;
+    };
   }
 
-  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);
-      }
-    },
-
-    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); });
+  function useModel(props, name, options = EMPTY_OBJ) {
+    const i = getCurrentInstance();
+    if (!i) {
+      warn$1(`useModel() called without active instance.`);
+      return ref();
+    }
+    const camelizedName = camelize(name);
+    if (!i.propsOptions[0][camelizedName]) {
+      warn$1(`useModel() called with prop "${name}" which is not declared.`);
+      return ref();
+    }
+    const hyphenatedName = hyphenate(name);
+    const modifiers = getModelModifiers(props, camelizedName);
+    const res = customRef((track, trigger) => {
+      let localValue;
+      let prevSetValue = EMPTY_OBJ;
+      let prevEmittedValue;
+      watchSyncEffect(() => {
+        const propValue = props[camelizedName];
+        if (hasChanged(localValue, propValue)) {
+          localValue = propValue;
+          trigger();
+        }
       });
-    },
-
-    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);
+      return {
+        get() {
+          track();
+          return options.get ? options.get(localValue) : localValue;
+        },
+        set(value) {
+          const emittedValue = options.set ? options.set(value) : value;
+          if (!hasChanged(emittedValue, localValue) && !(prevSetValue !== EMPTY_OBJ && hasChanged(value, prevSetValue))) {
+            return;
+          }
+          const rawProps = i.vnode.props;
+          if (!(rawProps && // check if parent has passed v-model
+          (name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps))) {
+            localValue = value;
+            trigger();
+          }
+          i.emit(`update:${name}`, emittedValue);
+          if (hasChanged(value, emittedValue) && hasChanged(value, prevSetValue) && !hasChanged(emittedValue, prevEmittedValue)) {
+            trigger();
           }
+          prevSetValue = value;
+          prevEmittedValue = emittedValue;
         }
-
-        vnode.data.keepAlive = true;
-      }
-      return vnode || (slot && slot[0])
-    }
-  };
-
-  var builtInComponents = {
-    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$$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);
+    res[Symbol.iterator] = () => {
+      let i2 = 0;
+      return {
+        next() {
+          if (i2 < 2) {
+            return { value: i2++ ? modifiers || EMPTY_OBJ : res, done: false };
+          } else {
+            return { done: true };
+          }
+        }
+      };
+    };
+    return res;
   }
-
-  initGlobalAPI(Vue);
-
-  Object.defineProperty(Vue.prototype, '$isServer', {
-    get: isServerRendering
-  });
-
-  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
-  });
-
-  Vue.version = '2.6.10';
-
-  /*  */
-
-  // 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')
-    )
+  const getModelModifiers = (props, modelName) => {
+    return modelName === "modelValue" || modelName === "model-value" ? props.modelModifiers : props[`${modelName}Modifiers`] || props[`${camelize(modelName)}Modifiers`] || props[`${hyphenate(modelName)}Modifiers`];
   };
 
-  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,translate,' +
-    'truespeed,typemustmatch,visible'
-  );
-
-  var xlinkNS = 'http://www.w3.org/1999/xlink';
-
-  var isXlink = function (name) {
-    return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
-  };
-
-  var getXlinkProp = function (name) {
-    return isXlink(name) ? name.slice(6, name.length) : ''
-  };
-
-  var isFalsyAttrValue = function (val) {
-    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);
+  function emit(instance, event, ...rawArgs) {
+    if (instance.isUnmounted) return;
+    const props = instance.vnode.props || EMPTY_OBJ;
+    {
+      const {
+        emitsOptions,
+        propsOptions: [propsOptions]
+      } = instance;
+      if (emitsOptions) {
+        if (!(event in emitsOptions) && true) {
+          if (!propsOptions || !(toHandlerKey(camelize(event)) in propsOptions)) {
+            warn$1(
+              `Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(camelize(event))}" prop.`
+            );
+          }
+        } else {
+          const validator = emitsOptions[event];
+          if (isFunction(validator)) {
+            const isValid = validator(...rawArgs);
+            if (!isValid) {
+              warn$1(
+                `Invalid event arguments: event validation failed for event "${event}".`
+              );
+            }
+          }
+        }
       }
     }
-    while (isDef(parentNode = parentNode.parent)) {
-      if (parentNode && parentNode.data) {
-        data = mergeClassData(data, parentNode.data);
+    let args = rawArgs;
+    const isModelListener = event.startsWith("update:");
+    const modifiers = isModelListener && getModelModifiers(props, event.slice(7));
+    if (modifiers) {
+      if (modifiers.trim) {
+        args = rawArgs.map((a) => isString(a) ? a.trim() : a);
+      }
+      if (modifiers.number) {
+        args = rawArgs.map(looseToNumber);
       }
     }
-    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
+    {
+      devtoolsComponentEmit(instance, event, args);
     }
-  }
-
-  function renderClass (
-    staticClass,
-    dynamicClass
-  ) {
-    if (isDef(staticClass) || isDef(dynamicClass)) {
-      return concat(staticClass, stringifyClass(dynamicClass))
+    {
+      const lowerCaseEvent = event.toLowerCase();
+      if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
+        warn$1(
+          `Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
+          instance,
+          instance.type
+        )} 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}".`
+        );
+      }
     }
-    /* 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)
+    let handlerName;
+    let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
+    props[handlerName = toHandlerKey(camelize(event))];
+    if (!handler && isModelListener) {
+      handler = props[handlerName = toHandlerKey(hyphenate(event))];
     }
-    if (isObject(value)) {
-      return stringifyObject(value)
+    if (handler) {
+      callWithAsyncErrorHandling(
+        handler,
+        instance,
+        6,
+        args
+      );
     }
-    if (typeof value === 'string') {
-      return value
+    const onceHandler = props[handlerName + `Once`];
+    if (onceHandler) {
+      if (!instance.emitted) {
+        instance.emitted = {};
+      } else if (instance.emitted[handlerName]) {
+        return;
+      }
+      instance.emitted[handlerName] = true;
+      callWithAsyncErrorHandling(
+        onceHandler,
+        instance,
+        6,
+        args
+      );
     }
-    /* 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 normalizeEmitsOptions(comp, appContext, asMixin = false) {
+    const cache = appContext.emitsCache;
+    const cached = cache.get(comp);
+    if (cached !== void 0) {
+      return cached;
+    }
+    const raw = comp.emits;
+    let normalized = {};
+    let hasExtends = false;
+    if (!isFunction(comp)) {
+      const extendEmits = (raw2) => {
+        const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
+        if (normalizedFromExtend) {
+          hasExtends = true;
+          extend(normalized, normalizedFromExtend);
+        }
+      };
+      if (!asMixin && appContext.mixins.length) {
+        appContext.mixins.forEach(extendEmits);
+      }
+      if (comp.extends) {
+        extendEmits(comp.extends);
+      }
+      if (comp.mixins) {
+        comp.mixins.forEach(extendEmits);
       }
     }
-    return res
-  }
-
-  function stringifyObject (value) {
-    var res = '';
-    for (var key in value) {
-      if (value[key]) {
-        if (res) { res += ' '; }
-        res += key;
+    if (!raw && !hasExtends) {
+      if (isObject(comp)) {
+        cache.set(comp, null);
       }
+      return null;
     }
-    return res
-  }
-
-  /*  */
-
-  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,' +
-    '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'
+    if (isArray(raw)) {
+      raw.forEach((key) => normalized[key] = null);
+    } else {
+      extend(normalized, raw);
     }
-    // basic support for MathML
-    // note it doesn't support other MathML elements being component roots
-    if (tag === 'math') {
-      return 'math'
+    if (isObject(comp)) {
+      cache.set(comp, normalized);
     }
+    return normalized;
   }
-
-  var unknownElementCache = Object.create(null);
-  function isUnknownElement (tag) {
-    /* istanbul ignore if */
-    if (!inBrowser) {
-      return true
+  function isEmitListener(options, key) {
+    if (!options || !isOn(key)) {
+      return false;
     }
-    if (isReservedTag(tag)) {
-      return false
+    key = key.slice(2).replace(/Once$/, "");
+    return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
+  }
+
+  let accessedAttrs = false;
+  function markAttrsAccessed() {
+    accessedAttrs = true;
+  }
+  function renderComponentRoot(instance) {
+    const {
+      type: Component,
+      vnode,
+      proxy,
+      withProxy,
+      propsOptions: [propsOptions],
+      slots,
+      attrs,
+      emit,
+      render,
+      renderCache,
+      props,
+      data,
+      setupState,
+      ctx,
+      inheritAttrs
+    } = instance;
+    const prev = setCurrentRenderingInstance(instance);
+    let result;
+    let fallthroughAttrs;
+    {
+      accessedAttrs = false;
     }
-    tag = tag.toLowerCase();
-    /* istanbul ignore if */
-    if (unknownElementCache[tag] != null) {
-      return unknownElementCache[tag]
+    try {
+      if (vnode.shapeFlag & 4) {
+        const proxyToUse = withProxy || proxy;
+        const thisProxy = setupState.__isScriptSetup ? new Proxy(proxyToUse, {
+          get(target, key, receiver) {
+            warn$1(
+              `Property '${String(
+              key
+            )}' was accessed via 'this'. Avoid using 'this' in templates.`
+            );
+            return Reflect.get(target, key, receiver);
+          }
+        }) : proxyToUse;
+        result = normalizeVNode(
+          render.call(
+            thisProxy,
+            proxyToUse,
+            renderCache,
+            true ? shallowReadonly(props) : props,
+            setupState,
+            data,
+            ctx
+          )
+        );
+        fallthroughAttrs = attrs;
+      } else {
+        const render2 = Component;
+        if (attrs === props) {
+          markAttrsAccessed();
+        }
+        result = normalizeVNode(
+          render2.length > 1 ? render2(
+            true ? shallowReadonly(props) : props,
+            true ? {
+              get attrs() {
+                markAttrsAccessed();
+                return shallowReadonly(attrs);
+              },
+              slots,
+              emit
+            } : { attrs, slots, emit }
+          ) : render2(
+            true ? shallowReadonly(props) : props,
+            null
+          )
+        );
+        fallthroughAttrs = Component.props ? attrs : getFunctionalFallthrough(attrs);
+      }
+    } catch (err) {
+      blockStack.length = 0;
+      handleError(err, instance, 1);
+      result = createVNode(Comment);
+    }
+    let root = result;
+    let setRoot = void 0;
+    if (result.patchFlag > 0 && result.patchFlag & 2048) {
+      [root, setRoot] = getChildRoot(result);
+    }
+    if (fallthroughAttrs && inheritAttrs !== false) {
+      const keys = Object.keys(fallthroughAttrs);
+      const { shapeFlag } = root;
+      if (keys.length) {
+        if (shapeFlag & (1 | 6)) {
+          if (propsOptions && keys.some(isModelListener)) {
+            fallthroughAttrs = filterModelListeners(
+              fallthroughAttrs,
+              propsOptions
+            );
+          }
+          root = cloneVNode(root, fallthroughAttrs, false, true);
+        } else if (!accessedAttrs && root.type !== Comment) {
+          const allAttrs = Object.keys(attrs);
+          const eventAttrs = [];
+          const extraAttrs = [];
+          for (let i = 0, l = allAttrs.length; i < l; i++) {
+            const key = allAttrs[i];
+            if (isOn(key)) {
+              if (!isModelListener(key)) {
+                eventAttrs.push(key[2].toLowerCase() + key.slice(3));
+              }
+            } else {
+              extraAttrs.push(key);
+            }
+          }
+          if (extraAttrs.length) {
+            warn$1(
+              `Extraneous non-props attributes (${extraAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text or teleport root nodes.`
+            );
+          }
+          if (eventAttrs.length) {
+            warn$1(
+              `Extraneous non-emits event listeners (${eventAttrs.join(", ")}) were passed to component but could not be automatically inherited because component renders fragment or text root nodes. If the listener is intended to be a component custom event listener only, declare it using the "emits" option.`
+            );
+          }
+        }
+      }
     }
-    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()))
+    if (vnode.dirs) {
+      if (!isElementRoot(root)) {
+        warn$1(
+          `Runtime directive used on component with non-element root node. The directives will not function as intended.`
+        );
+      }
+      root = cloneVNode(root, null, false, true);
+      root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
     }
-  }
-
-  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
+    if (vnode.transition) {
+      if (!isElementRoot(root)) {
+        warn$1(
+          `Component inside <Transition> renders non-element root node that cannot be animated.`
         );
-        return document.createElement('div')
       }
-      return selected
+      setTransitionHooks(root, vnode.transition);
+    }
+    if (setRoot) {
+      setRoot(root);
     } else {
-      return el
+      result = root;
+    }
+    setCurrentRenderingInstance(prev);
+    return result;
+  }
+  const getChildRoot = (vnode) => {
+    const rawChildren = vnode.children;
+    const dynamicChildren = vnode.dynamicChildren;
+    const childRoot = filterSingleRoot(rawChildren, false);
+    if (!childRoot) {
+      return [vnode, void 0];
+    } else if (childRoot.patchFlag > 0 && childRoot.patchFlag & 2048) {
+      return getChildRoot(childRoot);
+    }
+    const index = rawChildren.indexOf(childRoot);
+    const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
+    const setRoot = (updatedRoot) => {
+      rawChildren[index] = updatedRoot;
+      if (dynamicChildren) {
+        if (dynamicIndex > -1) {
+          dynamicChildren[dynamicIndex] = updatedRoot;
+        } else if (updatedRoot.patchFlag > 0) {
+          vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
+        }
+      }
+    };
+    return [normalizeVNode(childRoot), setRoot];
+  };
+  function filterSingleRoot(children, recurse = true) {
+    let singleRoot;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (isVNode(child)) {
+        if (child.type !== Comment || child.children === "v-if") {
+          if (singleRoot) {
+            return;
+          } else {
+            singleRoot = child;
+            if (recurse && singleRoot.patchFlag > 0 && singleRoot.patchFlag & 2048) {
+              return filterSingleRoot(singleRoot.children);
+            }
+          }
+        }
+      } else {
+        return;
+      }
     }
+    return singleRoot;
   }
-
-  /*  */
-
-  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');
+  const getFunctionalFallthrough = (attrs) => {
+    let res;
+    for (const key in attrs) {
+      if (key === "class" || key === "style" || isOn(key)) {
+        (res || (res = {}))[key] = attrs[key];
+      }
     }
-    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({
-    createElement: createElement$1,
-    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: function create (_, vnode) {
-      registerRef(vnode);
-    },
-    update: function update (oldVnode, vnode) {
-      if (oldVnode.data.ref !== vnode.data.ref) {
-        registerRef(oldVnode, true);
-        registerRef(vnode);
+    return res;
+  };
+  const filterModelListeners = (attrs, props) => {
+    const res = {};
+    for (const key in attrs) {
+      if (!isModelListener(key) || !(key.slice(9) in props)) {
+        res[key] = attrs[key];
       }
-    },
-    destroy: function destroy (vnode) {
-      registerRef(vnode, true);
     }
+    return res;
   };
-
-  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;
+  const isElementRoot = (vnode) => {
+    return vnode.shapeFlag & (6 | 1) || vnode.type === Comment;
+  };
+  function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
+    const { props: prevProps, children: prevChildren, component } = prevVNode;
+    const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
+    const emits = component.emitsOptions;
+    if ((prevChildren || nextChildren) && isHmrUpdating) {
+      return true;
+    }
+    if (nextVNode.dirs || nextVNode.transition) {
+      return true;
+    }
+    if (optimized && patchFlag >= 0) {
+      if (patchFlag & 1024) {
+        return true;
+      }
+      if (patchFlag & 16) {
+        if (!prevProps) {
+          return !!nextProps;
+        }
+        return hasPropsChanged(prevProps, nextProps, emits);
+      } else if (patchFlag & 8) {
+        const dynamicProps = nextVNode.dynamicProps;
+        for (let i = 0; i < dynamicProps.length; i++) {
+          const key = dynamicProps[i];
+          if (nextProps[key] !== prevProps[key] && !isEmitListener(emits, key)) {
+            return true;
+          }
+        }
       }
     } 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);
+      if (prevChildren || nextChildren) {
+        if (!nextChildren || !nextChildren.$stable) {
+          return true;
         }
-      } else {
-        refs[key] = ref;
       }
+      if (prevProps === nextProps) {
+        return false;
+      }
+      if (!prevProps) {
+        return !!nextProps;
+      }
+      if (!nextProps) {
+        return true;
+      }
+      return hasPropsChanged(prevProps, nextProps, emits);
     }
+    return false;
   }
-
-  /**
-   * 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; }
+  function hasPropsChanged(prevProps, nextProps, emitsOptions) {
+    const nextKeys = Object.keys(nextProps);
+    if (nextKeys.length !== Object.keys(prevProps).length) {
+      return true;
+    }
+    for (let i = 0; i < nextKeys.length; i++) {
+      const key = nextKeys[i];
+      if (nextProps[key] !== prevProps[key] && !isEmitListener(emitsOptions, key)) {
+        return true;
+      }
     }
-    return map
+    return false;
   }
-
-  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 updateHOCHostEl({ vnode, parent }, el) {
+    while (parent) {
+      const root = parent.subTree;
+      if (root.suspense && root.suspense.activeBranch === vnode) {
+        root.el = vnode.el;
+      }
+      if (root === vnode) {
+        (vnode = parent.vnode).el = el;
+        parent = parent.parent;
+      } else {
+        break;
+      }
+    }
+  }
+
+  const isSuspense = (type) => type.__isSuspense;
+  let suspenseId = 0;
+  const SuspenseImpl = {
+    name: "Suspense",
+    // In order to make Suspense tree-shakable, we need to avoid importing it
+    // directly in the renderer. The renderer checks for the __isSuspense flag
+    // on a vnode's type and calls the `process` method, passing in renderer
+    // internals.
+    __isSuspense: true,
+    process(n1, n2, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
+      if (n1 == null) {
+        mountSuspense(
+          n2,
+          container,
+          anchor,
+          parentComponent,
+          parentSuspense,
+          namespace,
+          slotScopeIds,
+          optimized,
+          rendererInternals
+        );
+      } else {
+        if (parentSuspense && parentSuspense.deps > 0 && !n1.suspense.isInFallback) {
+          n2.suspense = n1.suspense;
+          n2.suspense.vnode = n2;
+          n2.el = n1.el;
+          return;
         }
+        patchSuspense(
+          n1,
+          n2,
+          container,
+          anchor,
+          parentComponent,
+          namespace,
+          slotScopeIds,
+          optimized,
+          rendererInternals
+        );
       }
-    }
-
-    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);
+    },
+    hydrate: hydrateSuspense,
+    normalize: normalizeSuspenseChildren
+  };
+  const Suspense = SuspenseImpl ;
+  function triggerEvent(vnode, name) {
+    const eventListener = vnode.props && vnode.props[name];
+    if (isFunction(eventListener)) {
+      eventListener();
+    }
+  }
+  function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals) {
+    const {
+      p: patch,
+      o: { createElement }
+    } = rendererInternals;
+    const hiddenContainer = createElement("div");
+    const suspense = vnode.suspense = createSuspenseBoundary(
+      vnode,
+      parentSuspense,
+      parentComponent,
+      container,
+      hiddenContainer,
+      anchor,
+      namespace,
+      slotScopeIds,
+      optimized,
+      rendererInternals
+    );
+    patch(
+      null,
+      suspense.pendingBranch = vnode.ssContent,
+      hiddenContainer,
+      null,
+      parentComponent,
+      suspense,
+      namespace,
+      slotScopeIds
+    );
+    if (suspense.deps > 0) {
+      triggerEvent(vnode, "onPending");
+      triggerEvent(vnode, "onFallback");
+      patch(
+        null,
+        vnode.ssFallback,
+        container,
+        anchor,
+        parentComponent,
+        null,
+        // fallback tree will not have suspense context
+        namespace,
+        slotScopeIds
+      );
+      setActiveBranch(suspense, vnode.ssFallback);
+    } else {
+      suspense.resolve(false, true);
+    }
+  }
+  function patchSuspense(n1, n2, container, anchor, parentComponent, namespace, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) {
+    const suspense = n2.suspense = n1.suspense;
+    suspense.vnode = n2;
+    n2.el = n1.el;
+    const newBranch = n2.ssContent;
+    const newFallback = n2.ssFallback;
+    const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense;
+    if (pendingBranch) {
+      suspense.pendingBranch = newBranch;
+      if (isSameVNodeType(newBranch, pendingBranch)) {
+        patch(
+          pendingBranch,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        } else if (isInFallback) {
+          if (!isHydrating) {
+            patch(
+              activeBranch,
+              newFallback,
+              container,
+              anchor,
+              parentComponent,
+              null,
+              // fallback tree will not have suspense context
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+            setActiveBranch(suspense, newFallback);
+          }
+        }
+      } else {
+        suspense.pendingId = suspenseId++;
+        if (isHydrating) {
+          suspense.isHydrating = false;
+          suspense.activeBranch = pendingBranch;
+        } else {
+          unmount(pendingBranch, parentComponent, suspense);
+        }
+        suspense.deps = 0;
+        suspense.effects.length = 0;
+        suspense.hiddenContainer = createElement("div");
+        if (isInFallback) {
+          patch(
+            null,
+            newBranch,
+            suspense.hiddenContainer,
+            null,
+            parentComponent,
+            suspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          if (suspense.deps <= 0) {
+            suspense.resolve();
+          } else {
+            patch(
+              activeBranch,
+              newFallback,
+              container,
+              anchor,
+              parentComponent,
+              null,
+              // fallback tree will not have suspense context
+              namespace,
+              slotScopeIds,
+              optimized
+            );
+            setActiveBranch(suspense, newFallback);
+          }
+        } else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+          patch(
+            activeBranch,
+            newBranch,
+            container,
+            anchor,
+            parentComponent,
+            suspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          suspense.resolve(true);
+        } else {
+          patch(
+            null,
+            newBranch,
+            suspense.hiddenContainer,
+            null,
+            parentComponent,
+            suspense,
+            namespace,
+            slotScopeIds,
+            optimized
+          );
+          if (suspense.deps <= 0) {
+            suspense.resolve();
+          }
         }
       }
-      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);
+    } else {
+      if (activeBranch && isSameVNodeType(newBranch, activeBranch)) {
+        patch(
+          activeBranch,
+          newBranch,
+          container,
+          anchor,
+          parentComponent,
+          suspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+        setActiveBranch(suspense, newBranch);
+      } else {
+        triggerEvent(n2, "onPending");
+        suspense.pendingBranch = newBranch;
+        if (newBranch.shapeFlag & 512) {
+          suspense.pendingId = newBranch.component.suspenseId;
+        } else {
+          suspense.pendingId = suspenseId++;
+        }
+        patch(
+          null,
+          newBranch,
+          suspense.hiddenContainer,
+          null,
+          parentComponent,
+          suspense,
+          namespace,
+          slotScopeIds,
+          optimized
+        );
+        if (suspense.deps <= 0) {
+          suspense.resolve();
+        } else {
+          const { timeout, pendingId } = suspense;
+          if (timeout > 0) {
+            setTimeout(() => {
+              if (suspense.pendingId === pendingId) {
+                suspense.fallback(newFallback);
+              }
+            }, timeout);
+          } else if (timeout === 0) {
+            suspense.fallback(newFallback);
+          }
+        }
       }
     }
-
-    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)
-      )
+  }
+  let hasWarned = false;
+  function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, namespace, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+    if (!hasWarned) {
+      hasWarned = true;
+      console[console.info ? "info" : "log"](
+        `<Suspense> is an experimental feature and its API will likely change.`
+      );
     }
-
-    var creatingElmInVPre = 0;
-
-    function createElm (
+    const {
+      p: patch,
+      m: move,
+      um: unmount,
+      n: next,
+      o: { parentNode, remove }
+    } = rendererInternals;
+    let parentSuspenseId;
+    const isSuspensible = isVNodeSuspensible(vnode);
+    if (isSuspensible) {
+      if (parentSuspense && parentSuspense.pendingBranch) {
+        parentSuspenseId = parentSuspense.pendingId;
+        parentSuspense.deps++;
+      }
+    }
+    const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
+    {
+      assertNumber(timeout, `Suspense timeout`);
+    }
+    const initialAnchor = anchor;
+    const suspense = {
       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)) {
+      parent: parentSuspense,
+      parentComponent,
+      namespace,
+      container,
+      hiddenContainer,
+      deps: 0,
+      pendingId: suspenseId++,
+      timeout: typeof timeout === "number" ? timeout : -1,
+      activeBranch: null,
+      pendingBranch: null,
+      isInFallback: !isHydrating,
+      isHydrating,
+      isUnmounted: false,
+      effects: [],
+      resolve(resume = false, sync = false) {
         {
-          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
+          if (!resume && !suspense.pendingBranch) {
+            throw new Error(
+              `suspense.resolve() is called without a pending branch.`
+            );
+          }
+          if (suspense.isUnmounted) {
+            throw new Error(
+              `suspense.resolve() is called on an already unmounted suspense boundary.`
             );
           }
         }
-
-        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);
+        const {
+          vnode: vnode2,
+          activeBranch,
+          pendingBranch,
+          pendingId,
+          effects,
+          parentComponent: parentComponent2,
+          container: container2
+        } = suspense;
+        let delayEnter = false;
+        if (suspense.isHydrating) {
+          suspense.isHydrating = false;
+        } else if (!resume) {
+          delayEnter = activeBranch && pendingBranch.transition && pendingBranch.transition.mode === "out-in";
+          if (delayEnter) {
+            activeBranch.transition.afterLeave = () => {
+              if (pendingId === suspense.pendingId) {
+                move(
+                  pendingBranch,
+                  container2,
+                  anchor === initialAnchor ? next(activeBranch) : anchor,
+                  0
+                );
+                queuePostFlushCb(effects);
+              }
+            };
+          }
+          if (activeBranch) {
+            if (parentNode(activeBranch.el) === container2) {
+              anchor = next(activeBranch);
+            }
+            unmount(activeBranch, parentComponent2, suspense, true);
+          }
+          if (!delayEnter) {
+            move(pendingBranch, container2, anchor, 0);
+          }
+        }
+        setActiveBranch(suspense, pendingBranch);
+        suspense.pendingBranch = null;
+        suspense.isInFallback = false;
+        let parent = suspense.parent;
+        let hasUnresolvedAncestor = false;
+        while (parent) {
+          if (parent.pendingBranch) {
+            parent.effects.push(...effects);
+            hasUnresolvedAncestor = true;
+            break;
+          }
+          parent = parent.parent;
+        }
+        if (!hasUnresolvedAncestor && !delayEnter) {
+          queuePostFlushCb(effects);
+        }
+        suspense.effects = [];
+        if (isSuspensible) {
+          if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+            parentSuspense.deps--;
+            if (parentSuspense.deps === 0 && !sync) {
+              parentSuspense.resolve();
+            }
+          }
+        }
+        triggerEvent(vnode2, "onResolve");
+      },
+      fallback(fallbackVNode) {
+        if (!suspense.pendingBranch) {
+          return;
+        }
+        const { vnode: vnode2, activeBranch, parentComponent: parentComponent2, container: container2, namespace: namespace2 } = suspense;
+        triggerEvent(vnode2, "onFallback");
+        const anchor2 = next(activeBranch);
+        const mountFallback = () => {
+          if (!suspense.isInFallback) {
+            return;
+          }
+          patch(
+            null,
+            fallbackVNode,
+            container2,
+            anchor2,
+            parentComponent2,
+            null,
+            // fallback tree will not have suspense context
+            namespace2,
+            slotScopeIds,
+            optimized
+          );
+          setActiveBranch(suspense, fallbackVNode);
+        };
+        const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === "out-in";
+        if (delayEnter) {
+          activeBranch.transition.afterLeave = mountFallback;
+        }
+        suspense.isInFallback = true;
+        unmount(
+          activeBranch,
+          parentComponent2,
+          null,
+          // no suspense so unmount hooks fire now
+          true
+          // shouldRemove
+        );
+        if (!delayEnter) {
+          mountFallback();
+        }
+      },
+      move(container2, anchor2, type) {
+        suspense.activeBranch && move(suspense.activeBranch, container2, anchor2, type);
+        suspense.container = container2;
+      },
+      next() {
+        return suspense.activeBranch && next(suspense.activeBranch);
+      },
+      registerDep(instance, setupRenderEffect, optimized2) {
+        const isInPendingSuspense = !!suspense.pendingBranch;
+        if (isInPendingSuspense) {
+          suspense.deps++;
+        }
+        const hydratedEl = instance.vnode.el;
+        instance.asyncDep.catch((err) => {
+          handleError(err, instance, 0);
+        }).then((asyncSetupResult) => {
+          if (instance.isUnmounted || suspense.isUnmounted || suspense.pendingId !== instance.suspenseId) {
+            return;
+          }
+          instance.asyncResolved = true;
+          const { vnode: vnode2 } = instance;
+          {
+            pushWarningContext(vnode2);
+          }
+          handleSetupResult(instance, asyncSetupResult, false);
+          if (hydratedEl) {
+            vnode2.el = hydratedEl;
+          }
+          const placeholder = !hydratedEl && instance.subTree.el;
+          setupRenderEffect(
+            instance,
+            vnode2,
+            // component may have been moved before resolve.
+            // if this is not a hydration, instance.subTree will be the comment
+            // placeholder.
+            parentNode(hydratedEl || instance.subTree.el),
+            // anchor will not be used if this is hydration, so only need to
+            // consider the comment placeholder case.
+            hydratedEl ? null : next(instance.subTree),
+            suspense,
+            namespace,
+            optimized2
+          );
+          if (placeholder) {
+            remove(placeholder);
+          }
+          updateHOCHostEl(instance, vnode2.el);
+          {
+            popWarningContext();
           }
-          insert(parentElm, vnode.elm, refElm);
+          if (isInPendingSuspense && --suspense.deps === 0) {
+            suspense.resolve();
+          }
+        });
+      },
+      unmount(parentSuspense2, doRemove) {
+        suspense.isUnmounted = true;
+        if (suspense.activeBranch) {
+          unmount(
+            suspense.activeBranch,
+            parentComponent,
+            parentSuspense2,
+            doRemove
+          );
         }
-
-        if (data && data.pre) {
-          creatingElmInVPre--;
+        if (suspense.pendingBranch) {
+          unmount(
+            suspense.pendingBranch,
+            parentComponent,
+            parentSuspense2,
+            doRemove
+          );
         }
-      } 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 suspense;
+  }
+  function hydrateSuspense(node, vnode, parentComponent, parentSuspense, namespace, slotScopeIds, optimized, rendererInternals, hydrateNode) {
+    const suspense = vnode.suspense = createSuspenseBoundary(
+      vnode,
+      parentSuspense,
+      parentComponent,
+      node.parentNode,
+      // eslint-disable-next-line no-restricted-globals
+      document.createElement("div"),
+      null,
+      namespace,
+      slotScopeIds,
+      optimized,
+      rendererInternals,
+      true
+    );
+    const result = hydrateNode(
+      node,
+      suspense.pendingBranch = vnode.ssContent,
+      parentComponent,
+      suspense,
+      slotScopeIds,
+      optimized
+    );
+    if (suspense.deps === 0) {
+      suspense.resolve(false, 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
-        }
+    return result;
+  }
+  function normalizeSuspenseChildren(vnode) {
+    const { shapeFlag, children } = vnode;
+    const isSlotChildren = shapeFlag & 32;
+    vnode.ssContent = normalizeSuspenseSlot(
+      isSlotChildren ? children.default : children
+    );
+    vnode.ssFallback = isSlotChildren ? normalizeSuspenseSlot(children.fallback) : createVNode(Comment);
+  }
+  function normalizeSuspenseSlot(s) {
+    let block;
+    if (isFunction(s)) {
+      const trackBlock = isBlockTreeEnabled && s._c;
+      if (trackBlock) {
+        s._d = false;
+        openBlock();
+      }
+      s = s();
+      if (trackBlock) {
+        s._d = true;
+        block = currentBlock;
+        closeBlock();
       }
     }
-
-    function initComponent (vnode, insertedVnodeQueue) {
-      if (isDef(vnode.data.pendingInsert)) {
-        insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
-        vnode.data.pendingInsert = null;
+    if (isArray(s)) {
+      const singleChild = filterSingleRoot(s);
+      if (!singleChild && s.filter((child) => child !== NULL_DYNAMIC_COMPONENT).length > 0) {
+        warn$1(`<Suspense> slots expect a single root node.`);
       }
-      vnode.elm = vnode.componentInstance.$el;
-      if (isPatchable(vnode)) {
-        invokeCreateHooks(vnode, insertedVnodeQueue);
-        setScope(vnode);
+      s = singleChild;
+    }
+    s = normalizeVNode(s);
+    if (block && !s.dynamicChildren) {
+      s.dynamicChildren = block.filter((c) => c !== s);
+    }
+    return s;
+  }
+  function queueEffectWithSuspense(fn, suspense) {
+    if (suspense && suspense.pendingBranch) {
+      if (isArray(fn)) {
+        suspense.effects.push(...fn);
       } 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);
+        suspense.effects.push(fn);
       }
-    }
-
-    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
-        }
+    } else {
+      queuePostFlushCb(fn);
+    }
+  }
+  function setActiveBranch(suspense, branch) {
+    suspense.activeBranch = branch;
+    const { vnode, parentComponent } = suspense;
+    let el = branch.el;
+    while (!el && branch.component) {
+      branch = branch.component.subTree;
+      el = branch.el;
+    }
+    vnode.el = el;
+    if (parentComponent && parentComponent.subTree === vnode) {
+      parentComponent.vnode.el = el;
+      updateHOCHostEl(parentComponent, el);
+    }
+  }
+  function isVNodeSuspensible(vnode) {
+    const suspensible = vnode.props && vnode.props.suspensible;
+    return suspensible != null && suspensible !== false;
+  }
+
+  const Fragment = Symbol.for("v-fgt");
+  const Text = Symbol.for("v-txt");
+  const Comment = Symbol.for("v-cmt");
+  const Static = Symbol.for("v-stc");
+  const blockStack = [];
+  let currentBlock = null;
+  function openBlock(disableTracking = false) {
+    blockStack.push(currentBlock = disableTracking ? null : []);
+  }
+  function closeBlock() {
+    blockStack.pop();
+    currentBlock = blockStack[blockStack.length - 1] || null;
+  }
+  let isBlockTreeEnabled = 1;
+  function setBlockTracking(value, inVOnce = false) {
+    isBlockTreeEnabled += value;
+    if (value < 0 && currentBlock && inVOnce) {
+      currentBlock.hasOnce = true;
+    }
+  }
+  function setupBlock(vnode) {
+    vnode.dynamicChildren = isBlockTreeEnabled > 0 ? currentBlock || EMPTY_ARR : null;
+    closeBlock();
+    if (isBlockTreeEnabled > 0 && currentBlock) {
+      currentBlock.push(vnode);
+    }
+    return vnode;
+  }
+  function createElementBlock(type, props, children, patchFlag, dynamicProps, shapeFlag) {
+    return setupBlock(
+      createBaseVNode(
+        type,
+        props,
+        children,
+        patchFlag,
+        dynamicProps,
+        shapeFlag,
+        true
+      )
+    );
+  }
+  function createBlock(type, props, children, patchFlag, dynamicProps) {
+    return setupBlock(
+      createVNode(
+        type,
+        props,
+        children,
+        patchFlag,
+        dynamicProps,
+        true
+      )
+    );
+  }
+  function isVNode(value) {
+    return value ? value.__v_isVNode === true : false;
+  }
+  function isSameVNodeType(n1, n2) {
+    if (n2.shapeFlag & 6 && n1.component) {
+      const dirtyInstances = hmrDirtyComponents.get(n2.type);
+      if (dirtyInstances && dirtyInstances.has(n1.component)) {
+        n1.shapeFlag &= -257;
+        n2.shapeFlag &= -513;
+        return false;
       }
-      // 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);
-          }
+    return n1.type === n2.type && n1.key === n2.key;
+  }
+  let vnodeArgsTransformer;
+  function transformVNodeArgs(transformer) {
+    vnodeArgsTransformer = transformer;
+  }
+  const createVNodeWithArgsTransform = (...args) => {
+    return _createVNode(
+      ...vnodeArgsTransformer ? vnodeArgsTransformer(args, currentRenderingInstance) : args
+    );
+  };
+  const normalizeKey = ({ key }) => key != null ? key : null;
+  const normalizeRef = ({
+    ref,
+    ref_key,
+    ref_for
+  }) => {
+    if (typeof ref === "number") {
+      ref = "" + ref;
+    }
+    return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
+  };
+  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
+    const vnode = {
+      __v_isVNode: true,
+      __v_skip: true,
+      type,
+      props,
+      key: props && normalizeKey(props),
+      ref: props && normalizeRef(props),
+      scopeId: currentScopeId,
+      slotScopeIds: null,
+      children,
+      component: null,
+      suspense: null,
+      ssContent: null,
+      ssFallback: null,
+      dirs: null,
+      transition: null,
+      el: null,
+      anchor: null,
+      target: null,
+      targetStart: null,
+      targetAnchor: null,
+      staticCount: 0,
+      shapeFlag,
+      patchFlag,
+      dynamicProps,
+      dynamicChildren: null,
+      appContext: null,
+      ctx: currentRenderingInstance
+    };
+    if (needFullChildrenNormalization) {
+      normalizeChildren(vnode, children);
+      if (shapeFlag & 128) {
+        type.normalize(vnode);
+      }
+    } else if (children) {
+      vnode.shapeFlag |= isString(children) ? 8 : 16;
+    }
+    if (vnode.key !== vnode.key) {
+      warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
+    }
+    if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
+    !isBlockNode && // has current parent block
+    currentBlock && // presence of a patch flag indicates this node needs patching on updates.
+    // component nodes also should always be patched, because even if the
+    // component doesn't need to update, it needs to persist the instance on to
+    // the next vnode so that it can be properly unmounted later.
+    (vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
+    // vnode should not be considered dynamic due to handler caching.
+    vnode.patchFlag !== 32) {
+      currentBlock.push(vnode);
+    }
+    return vnode;
+  }
+  const createVNode = createVNodeWithArgsTransform ;
+  function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
+    if (!type || type === NULL_DYNAMIC_COMPONENT) {
+      if (!type) {
+        warn$1(`Invalid vnode type when creating vnode: ${type}.`);
+      }
+      type = Comment;
+    }
+    if (isVNode(type)) {
+      const cloned = cloneVNode(
+        type,
+        props,
+        true
+        /* mergeRef: true */
+      );
+      if (children) {
+        normalizeChildren(cloned, children);
+      }
+      if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
+        if (cloned.shapeFlag & 6) {
+          currentBlock[currentBlock.indexOf(type)] = cloned;
         } else {
-          nodeOps.appendChild(parent, elm);
+          currentBlock.push(cloned);
         }
       }
+      cloned.patchFlag = -2;
+      return cloned;
     }
-
-    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);
+    if (isClassComponent(type)) {
+      type = type.__vccOpts;
+    }
+    if (props) {
+      props = guardReactiveProps(props);
+      let { class: klass, style } = props;
+      if (klass && !isString(klass)) {
+        props.class = normalizeClass(klass);
+      }
+      if (isObject(style)) {
+        if (isProxy(style) && !isArray(style)) {
+          style = extend({}, style);
         }
-      } else if (isPrimitive(vnode.text)) {
-        nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(String(vnode.text)));
+        props.style = normalizeStyle(style);
       }
     }
-
-    function isPatchable (vnode) {
-      while (vnode.componentInstance) {
-        vnode = vnode.componentInstance._vnode;
-      }
-      return isDef(vnode.tag)
+    const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
+    if (shapeFlag & 4 && isProxy(type)) {
+      type = toRaw(type);
+      warn$1(
+        `Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
+        `
+Component that was made reactive: `,
+        type
+      );
     }
-
-    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); }
-      }
+    return createBaseVNode(
+      type,
+      props,
+      children,
+      patchFlag,
+      dynamicProps,
+      shapeFlag,
+      isBlockNode,
+      true
+    );
+  }
+  function guardReactiveProps(props) {
+    if (!props) return null;
+    return isProxy(props) || isInternalObject(props) ? extend({}, props) : props;
+  }
+  function cloneVNode(vnode, extraProps, mergeRef = false, cloneTransition = false) {
+    const { props, ref, patchFlag, children, transition } = vnode;
+    const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
+    const cloned = {
+      __v_isVNode: true,
+      __v_skip: true,
+      type: vnode.type,
+      props: mergedProps,
+      key: mergedProps && normalizeKey(mergedProps),
+      ref: extraProps && extraProps.ref ? (
+        // #2078 in the case of <component :is="vnode" ref="extra"/>
+        // if the vnode itself already has a ref, cloneVNode will need to merge
+        // the refs so the single vnode can be set on multiple refs
+        mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
+      ) : ref,
+      scopeId: vnode.scopeId,
+      slotScopeIds: vnode.slotScopeIds,
+      children: patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
+      target: vnode.target,
+      targetStart: vnode.targetStart,
+      targetAnchor: vnode.targetAnchor,
+      staticCount: vnode.staticCount,
+      shapeFlag: vnode.shapeFlag,
+      // if the vnode is cloned with extra props, we can no longer assume its
+      // existing patch flag to be reliable and need to add the FULL_PROPS flag.
+      // note: preserve flag for fragments since they use the flag for children
+      // fast paths only.
+      patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
+      dynamicProps: vnode.dynamicProps,
+      dynamicChildren: vnode.dynamicChildren,
+      appContext: vnode.appContext,
+      dirs: vnode.dirs,
+      transition,
+      // These should technically only be non-null on mounted VNodes. However,
+      // they *should* be copied for kept-alive vnodes. So we just always copy
+      // them since them being non-null during a mount doesn't affect the logic as
+      // they will simply be overwritten.
+      component: vnode.component,
+      suspense: vnode.suspense,
+      ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
+      ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
+      el: vnode.el,
+      anchor: vnode.anchor,
+      ctx: vnode.ctx,
+      ce: vnode.ce
+    };
+    if (transition && cloneTransition) {
+      setTransitionHooks(
+        cloned,
+        transition.clone(cloned)
+      );
     }
-
-    // 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);
+    return cloned;
+  }
+  function deepCloneVNode(vnode) {
+    const cloned = cloneVNode(vnode);
+    if (isArray(vnode.children)) {
+      cloned.children = vnode.children.map(deepCloneVNode);
+    }
+    return cloned;
+  }
+  function createTextVNode(text = " ", flag = 0) {
+    return createVNode(Text, null, text, flag);
+  }
+  function createStaticVNode(content, numberOfNodes) {
+    const vnode = createVNode(Static, null, content);
+    vnode.staticCount = numberOfNodes;
+    return vnode;
+  }
+  function createCommentVNode(text = "", asBlock = false) {
+    return asBlock ? (openBlock(), createBlock(Comment, null, text)) : createVNode(Comment, null, text);
+  }
+  function normalizeVNode(child) {
+    if (child == null || typeof child === "boolean") {
+      return createVNode(Comment);
+    } else if (isArray(child)) {
+      return createVNode(
+        Fragment,
+        null,
+        // #3666, avoid reference pollution when reusing vnode
+        child.slice()
+      );
+    } else if (isVNode(child)) {
+      return cloneIfMounted(child);
+    } else {
+      return createVNode(Text, null, String(child));
+    }
+  }
+  function cloneIfMounted(child) {
+    return child.el === null && child.patchFlag !== -1 || child.memo ? child : cloneVNode(child);
+  }
+  function normalizeChildren(vnode, children) {
+    let type = 0;
+    const { shapeFlag } = vnode;
+    if (children == null) {
+      children = null;
+    } else if (isArray(children)) {
+      type = 16;
+    } else if (typeof children === "object") {
+      if (shapeFlag & (1 | 64)) {
+        const slot = children.default;
+        if (slot) {
+          slot._c && (slot._d = false);
+          normalizeChildren(vnode, slot());
+          slot._c && (slot._d = true);
+        }
+        return;
       } else {
-        var ancestor = vnode;
-        while (ancestor) {
-          if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
-            nodeOps.setStyleScope(vnode.elm, i);
+        type = 32;
+        const slotFlag = children._;
+        if (!slotFlag && !isInternalObject(children)) {
+          children._ctx = currentRenderingInstance;
+        } else if (slotFlag === 3 && currentRenderingInstance) {
+          if (currentRenderingInstance.slots._ === 1) {
+            children._ = 1;
+          } else {
+            children._ = 2;
+            vnode.patchFlag |= 1024;
           }
-          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]);
-        }
+    } else if (isFunction(children)) {
+      children = { default: children, _ctx: currentRenderingInstance };
+      type = 32;
+    } else {
+      children = String(children);
+      if (shapeFlag & 64) {
+        type = 16;
+        children = [createTextVNode(children)];
+      } else {
+        type = 8;
       }
     }
-
-    function removeVnodes (parentElm, 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);
+    vnode.children = children;
+    vnode.shapeFlag |= type;
+  }
+  function mergeProps(...args) {
+    const ret = {};
+    for (let i = 0; i < args.length; i++) {
+      const toMerge = args[i];
+      for (const key in toMerge) {
+        if (key === "class") {
+          if (ret.class !== toMerge.class) {
+            ret.class = normalizeClass([ret.class, toMerge.class]);
+          }
+        } else if (key === "style") {
+          ret.style = normalizeStyle([ret.style, toMerge.style]);
+        } else if (isOn(key)) {
+          const existing = ret[key];
+          const incoming = toMerge[key];
+          if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
+            ret[key] = existing ? [].concat(existing, incoming) : incoming;
           }
+        } else if (key !== "") {
+          ret[key] = toMerge[key];
         }
       }
     }
+    return ret;
+  }
+  function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+    callWithAsyncErrorHandling(hook, instance, 7, [
+      vnode,
+      prevVNode
+    ]);
+  }
 
-    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();
+  const emptyAppContext = createAppContext();
+  let uid = 0;
+  function createComponentInstance(vnode, parent, suspense) {
+    const type = vnode.type;
+    const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
+    const instance = {
+      uid: uid++,
+      vnode,
+      type,
+      parent,
+      appContext,
+      root: null,
+      // to be immediately set
+      next: null,
+      subTree: null,
+      // will be set synchronously right after creation
+      effect: null,
+      update: null,
+      // will be set synchronously right after creation
+      job: null,
+      scope: new EffectScope(
+        true
+        /* detached */
+      ),
+      render: null,
+      proxy: null,
+      exposed: null,
+      exposeProxy: null,
+      withProxy: null,
+      provides: parent ? parent.provides : Object.create(appContext.provides),
+      ids: parent ? parent.ids : ["", 0, 0],
+      accessCache: null,
+      renderCache: [],
+      // local resolved assets
+      components: null,
+      directives: null,
+      // resolved props and emits options
+      propsOptions: normalizePropsOptions(type, appContext),
+      emitsOptions: normalizeEmitsOptions(type, appContext),
+      // emit
+      emit: null,
+      // to be set immediately
+      emitted: null,
+      // props default value
+      propsDefaults: EMPTY_OBJ,
+      // inheritAttrs
+      inheritAttrs: type.inheritAttrs,
+      // state
+      ctx: EMPTY_OBJ,
+      data: EMPTY_OBJ,
+      props: EMPTY_OBJ,
+      attrs: EMPTY_OBJ,
+      slots: EMPTY_OBJ,
+      refs: EMPTY_OBJ,
+      setupState: EMPTY_OBJ,
+      setupContext: null,
+      // suspense related
+      suspense,
+      suspenseId: suspense ? suspense.pendingId : 0,
+      asyncDep: null,
+      asyncResolved: false,
+      // lifecycle hooks
+      // not using enums here because it results in computed properties
+      isMounted: false,
+      isUnmounted: false,
+      isDeactivated: false,
+      bc: null,
+      c: null,
+      bm: null,
+      m: null,
+      bu: null,
+      u: null,
+      um: null,
+      bum: null,
+      da: null,
+      a: null,
+      rtg: null,
+      rtc: null,
+      ec: null,
+      sp: null
+    };
+    {
+      instance.ctx = createDevRenderContext(instance);
+    }
+    instance.root = parent ? parent.root : instance;
+    instance.emit = emit.bind(null, instance);
+    if (vnode.ce) {
+      vnode.ce(instance);
+    }
+    return instance;
+  }
+  let currentInstance = null;
+  const getCurrentInstance = () => currentInstance || currentRenderingInstance;
+  let internalSetCurrentInstance;
+  let setInSSRSetupState;
+  {
+    internalSetCurrentInstance = (i) => {
+      currentInstance = i;
+    };
+    setInSSRSetupState = (v) => {
+      isInSSRComponentSetup = v;
+    };
+  }
+  const setCurrentInstance = (instance) => {
+    const prev = currentInstance;
+    internalSetCurrentInstance(instance);
+    instance.scope.on();
+    return () => {
+      instance.scope.off();
+      internalSetCurrentInstance(prev);
+    };
+  };
+  const unsetCurrentInstance = () => {
+    currentInstance && currentInstance.scope.off();
+    internalSetCurrentInstance(null);
+  };
+  const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
+  function validateComponentName(name, { isNativeTag }) {
+    if (isBuiltInTag(name) || isNativeTag(name)) {
+      warn$1(
+        "Do not use built-in or reserved HTML elements as component id: " + name
+      );
+    }
+  }
+  function isStatefulComponent(instance) {
+    return instance.vnode.shapeFlag & 4;
+  }
+  let isInSSRComponentSetup = false;
+  function setupComponent(instance, isSSR = false, optimized = false) {
+    isSSR && setInSSRSetupState(isSSR);
+    const { props, children } = instance.vnode;
+    const isStateful = isStatefulComponent(instance);
+    initProps(instance, props, isStateful, isSSR);
+    initSlots(instance, children, optimized || isSSR);
+    const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
+    isSSR && setInSSRSetupState(false);
+    return setupResult;
+  }
+  function setupStatefulComponent(instance, isSSR) {
+    var _a;
+    const Component = instance.type;
+    {
+      if (Component.name) {
+        validateComponentName(Component.name, instance.appContext.config);
+      }
+      if (Component.components) {
+        const names = Object.keys(Component.components);
+        for (let i = 0; i < names.length; i++) {
+          validateComponentName(names[i], instance.appContext.config);
         }
-      } 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 (Component.directives) {
+        const names = Object.keys(Component.directives);
+        for (let i = 0; i < names.length; i++) {
+          validateDirectiveName(names[i]);
         }
       }
-      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(parentElm, oldCh, oldStartIdx, oldEndIdx);
+      if (Component.compilerOptions && isRuntimeOnly()) {
+        warn$1(
+          `"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
+        );
       }
     }
-
-    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
+    instance.accessCache = /* @__PURE__ */ Object.create(null);
+    instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers);
+    {
+      exposePropsOnRenderContext(instance);
+    }
+    const { setup } = Component;
+    if (setup) {
+      pauseTracking();
+      const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
+      const reset = setCurrentInstance(instance);
+      const setupResult = callWithErrorHandling(
+        setup,
+        instance,
+        0,
+        [
+          shallowReadonly(instance.props) ,
+          setupContext
+        ]
+      );
+      const isAsyncSetup = isPromise(setupResult);
+      resetTracking();
+      reset();
+      if ((isAsyncSetup || instance.sp) && !isAsyncWrapper(instance)) {
+        markAsyncBoundary(instance);
+      }
+      if (isAsyncSetup) {
+        setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
+        if (isSSR) {
+          return setupResult.then((resolvedResult) => {
+            handleSetupResult(instance, resolvedResult, isSSR);
+          }).catch((e) => {
+            handleError(e, instance, 0);
+          });
+        } else {
+          instance.asyncDep = setupResult;
+          if (!instance.suspense) {
+            const name = (_a = Component.name) != null ? _a : "Anonymous";
+            warn$1(
+              `Component <${name}>: setup function returned a promise, but no <Suspense> boundary was found in the parent component tree. A component with async setup() must be nested in a <Suspense> in order to be rendered.`
             );
-          } else {
-            seenKeys[key] = true;
           }
         }
+      } else {
+        handleSetupResult(instance, setupResult, isSSR);
       }
+    } else {
+      finishComponentSetup(instance, isSSR);
     }
-
-    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);
+  }
+  function handleSetupResult(instance, setupResult, isSSR) {
+    if (isFunction(setupResult)) {
+      {
+        instance.render = setupResult;
       }
-
-      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
+    } else if (isObject(setupResult)) {
+      if (isVNode(setupResult)) {
+        warn$1(
+          `setup() should not return VNodes directly - return a render function instead.`
+        );
       }
-
-      // 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
+      {
+        instance.devtoolsRawSetupState = setupResult;
       }
-
-      var i;
-      var data = vnode.data;
-      if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
-        i(oldVnode, vnode);
+      instance.setupState = proxyRefs(setupResult);
+      {
+        exposeSetupStateOnRenderContext(instance);
       }
-
-      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); }
+    } else if (setupResult !== void 0) {
+      warn$1(
+        `setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
+      );
+    }
+    finishComponentSetup(instance, isSSR);
+  }
+  let compile$1;
+  let installWithProxy;
+  function registerRuntimeCompiler(_compile) {
+    compile$1 = _compile;
+    installWithProxy = (i) => {
+      if (i.render._rc) {
+        i.withProxy = new Proxy(i.ctx, RuntimeCompiledPublicInstanceProxyHandlers);
       }
-      if (isUndef(vnode.text)) {
-        if (isDef(oldCh) && isDef(ch)) {
-          if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
-        } else if (isDef(ch)) {
+    };
+  }
+  const isRuntimeOnly = () => !compile$1;
+  function finishComponentSetup(instance, isSSR, skipOptions) {
+    const Component = instance.type;
+    if (!instance.render) {
+      if (!isSSR && compile$1 && !Component.render) {
+        const template = Component.template || resolveMergedOptions(instance).template;
+        if (template) {
+          {
+            startMeasure(instance, `compile`);
+          }
+          const { isCustomElement, compilerOptions } = instance.appContext.config;
+          const { delimiters, compilerOptions: componentCompilerOptions } = Component;
+          const finalCompilerOptions = extend(
+            extend(
+              {
+                isCustomElement,
+                delimiters
+              },
+              compilerOptions
+            ),
+            componentCompilerOptions
+          );
+          Component.render = compile$1(template, finalCompilerOptions);
           {
-            checkDuplicateKeys(ch);
+            endMeasure(instance, `compile`);
           }
-          if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
-          addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
-        } else if (isDef(oldCh)) {
-          removeVnodes(elm, 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); }
+      instance.render = Component.render || NOOP;
+      if (installWithProxy) {
+        installWithProxy(instance);
       }
     }
-
-    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;
+    {
+      const reset = setCurrentInstance(instance);
+      pauseTracking();
+      try {
+        applyOptions(instance);
+      } finally {
+        resetTracking();
+        reset();
+      }
+    }
+    if (!Component.render && instance.render === NOOP && !isSSR) {
+      if (!compile$1 && Component.template) {
+        warn$1(
+          `Component provided template option but runtime compilation is not supported in this build of Vue.` + (` Use "vue.global.js" instead.` )
+        );
       } else {
-        for (var i = 0; i < queue.length; ++i) {
-          queue[i].data.hook.insert(queue[i]);
-        }
+        warn$1(`Component is missing template or render function: `, Component);
       }
     }
-
-    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
+  }
+  const attrsProxyHandlers = {
+    get(target, key) {
+      markAttrsAccessed();
+      track(target, "get", "");
+      return target[key];
+    },
+    set() {
+      warn$1(`setupContext.attrs is readonly.`);
+      return false;
+    },
+    deleteProperty() {
+      warn$1(`setupContext.attrs is readonly.`);
+      return false;
+    }
+  } ;
+  function getSlotsProxy(instance) {
+    return new Proxy(instance.slots, {
+      get(target, key) {
+        track(instance, "get", "$slots");
+        return target[key];
       }
-      // assert node match
+    });
+  }
+  function createSetupContext(instance) {
+    const expose = (exposed) => {
       {
-        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 (instance.exposed) {
+          warn$1(`expose() should be called only once per setup().`);
         }
-        if (isDef(data)) {
-          var fullInvoke = false;
-          for (var key in data) {
-            if (!isRenderedModule(key)) {
-              fullInvoke = true;
-              invokeCreateHooks(vnode, insertedVnodeQueue);
-              break
+        if (exposed != null) {
+          let exposedType = typeof exposed;
+          if (exposedType === "object") {
+            if (isArray(exposed)) {
+              exposedType = "array";
+            } else if (isRef(exposed)) {
+              exposedType = "ref";
             }
           }
-          if (!fullInvoke && data['class']) {
-            // ensure collecting deps for deep class bindings for future updates
-            traverse(data['class']);
+          if (exposedType !== "object") {
+            warn$1(
+              `expose() should be passed a plain object, received ${exposedType}.`
+            );
           }
         }
-      } 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)
       }
+      instance.exposed = exposed || {};
+    };
+    {
+      let attrsProxy;
+      let slotsProxy;
+      return Object.freeze({
+        get attrs() {
+          return attrsProxy || (attrsProxy = new Proxy(instance.attrs, attrsProxyHandlers));
+        },
+        get slots() {
+          return slotsProxy || (slotsProxy = getSlotsProxy(instance));
+        },
+        get emit() {
+          return (event, ...args) => instance.emit(event, ...args);
+        },
+        expose
+      });
     }
-
-    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(parentElm, [oldVnode], 0, 0);
-          } else if (isDef(oldVnode.tag)) {
-            invokeDestroyHook(oldVnode);
+  }
+  function getComponentPublicInstance(instance) {
+    if (instance.exposed) {
+      return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
+        get(target, key) {
+          if (key in target) {
+            return target[key];
+          } else if (key in publicPropertiesMap) {
+            return publicPropertiesMap[key](instance);
           }
+        },
+        has(target, key) {
+          return key in target || key in publicPropertiesMap;
         }
-      }
-
-      invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
-      return vnode.elm
+      }));
+    } else {
+      return instance.proxy;
     }
   }
-
-  /*  */
-
-  var directives = {
-    create: updateDirectives,
-    update: updateDirectives,
-    destroy: function unbindDirectives (vnode) {
-      updateDirectives(vnode, emptyNode);
+  const classifyRE = /(?:^|[-_])(\w)/g;
+  const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
+  function getComponentName(Component, includeInferred = true) {
+    return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
+  }
+  function formatComponentName(instance, Component, isRoot = false) {
+    let name = getComponentName(Component);
+    if (!name && Component.__file) {
+      const match = Component.__file.match(/([^/\\]+)\.\w+$/);
+      if (match) {
+        name = match[1];
+      }
     }
-  };
-
-  function updateDirectives (oldVnode, vnode) {
-    if (oldVnode.data.directives || vnode.data.directives) {
-      _update(oldVnode, vnode);
+    if (!name && instance && instance.parent) {
+      const inferFromRegistry = (registry) => {
+        for (const key in registry) {
+          if (registry[key] === Component) {
+            return key;
+          }
+        }
+      };
+      name = inferFromRegistry(
+        instance.components || instance.parent.type.components
+      ) || inferFromRegistry(instance.appContext.components);
     }
+    return name ? classify(name) : isRoot ? `App` : `Anonymous`;
+  }
+  function isClassComponent(value) {
+    return isFunction(value) && "__vccOpts" in value;
   }
 
-  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);
-        }
+  const computed = (getterOrOptions, debugOptions) => {
+    const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
+    {
+      const i = getCurrentInstance();
+      if (i && i.appContext.config.warnRecursiveComputed) {
+        c._warnRecursive = true;
       }
     }
+    return c;
+  };
 
-    if (dirsWithInsert.length) {
-      var callInsert = function () {
-        for (var i = 0; i < dirsWithInsert.length; i++) {
-          callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
+  function h(type, propsOrChildren, children) {
+    const l = arguments.length;
+    if (l === 2) {
+      if (isObject(propsOrChildren) && !isArray(propsOrChildren)) {
+        if (isVNode(propsOrChildren)) {
+          return createVNode(type, null, [propsOrChildren]);
         }
-      };
-      if (isCreate) {
-        mergeVNodeHook(vnode, 'insert', callInsert);
+        return createVNode(type, propsOrChildren);
       } else {
-        callInsert();
+        return createVNode(type, null, propsOrChildren);
+      }
+    } else {
+      if (l > 3) {
+        children = Array.prototype.slice.call(arguments, 2);
+      } else if (l === 3 && isVNode(children)) {
+        children = [children];
       }
+      return createVNode(type, propsOrChildren, children);
     }
+  }
 
-    if (dirsWithPostpatch.length) {
-      mergeVNodeHook(vnode, 'postpatch', function () {
-        for (var i = 0; i < dirsWithPostpatch.length; i++) {
-          callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
+  function initCustomFormatter() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const vueStyle = { style: "color:#3ba776" };
+    const numberStyle = { style: "color:#1677ff" };
+    const stringStyle = { style: "color:#f5222d" };
+    const keywordStyle = { style: "color:#eb2f96" };
+    const formatter = {
+      __vue_custom_formatter: true,
+      header(obj) {
+        if (!isObject(obj)) {
+          return null;
         }
-      });
+        if (obj.__isVue) {
+          return ["div", vueStyle, `VueInstance`];
+        } else if (isRef(obj)) {
+          pauseTracking();
+          const value = obj.value;
+          resetTracking();
+          return [
+            "div",
+            {},
+            ["span", vueStyle, genRefFlag(obj)],
+            "<",
+            formatValue(value),
+            `>`
+          ];
+        } else if (isReactive(obj)) {
+          return [
+            "div",
+            {},
+            ["span", vueStyle, isShallow(obj) ? "ShallowReactive" : "Reactive"],
+            "<",
+            formatValue(obj),
+            `>${isReadonly(obj) ? ` (readonly)` : ``}`
+          ];
+        } else if (isReadonly(obj)) {
+          return [
+            "div",
+            {},
+            ["span", vueStyle, isShallow(obj) ? "ShallowReadonly" : "Readonly"],
+            "<",
+            formatValue(obj),
+            ">"
+          ];
+        }
+        return null;
+      },
+      hasBody(obj) {
+        return obj && obj.__isVue;
+      },
+      body(obj) {
+        if (obj && obj.__isVue) {
+          return [
+            "div",
+            {},
+            ...formatInstance(obj.$)
+          ];
+        }
+      }
+    };
+    function formatInstance(instance) {
+      const blocks = [];
+      if (instance.type.props && instance.props) {
+        blocks.push(createInstanceBlock("props", toRaw(instance.props)));
+      }
+      if (instance.setupState !== EMPTY_OBJ) {
+        blocks.push(createInstanceBlock("setup", instance.setupState));
+      }
+      if (instance.data !== EMPTY_OBJ) {
+        blocks.push(createInstanceBlock("data", toRaw(instance.data)));
+      }
+      const computed = extractKeys(instance, "computed");
+      if (computed) {
+        blocks.push(createInstanceBlock("computed", computed));
+      }
+      const injected = extractKeys(instance, "inject");
+      if (injected) {
+        blocks.push(createInstanceBlock("injected", injected));
+      }
+      blocks.push([
+        "div",
+        {},
+        [
+          "span",
+          {
+            style: keywordStyle.style + ";opacity:0.66"
+          },
+          "$ (internal): "
+        ],
+        ["object", { object: instance }]
+      ]);
+      return blocks;
+    }
+    function createInstanceBlock(type, target) {
+      target = extend({}, target);
+      if (!Object.keys(target).length) {
+        return ["span", {}];
+      }
+      return [
+        "div",
+        { style: "line-height:1.25em;margin-bottom:0.6em" },
+        [
+          "div",
+          {
+            style: "color:#476582"
+          },
+          type
+        ],
+        [
+          "div",
+          {
+            style: "padding-left:1.25em"
+          },
+          ...Object.keys(target).map((key) => {
+            return [
+              "div",
+              {},
+              ["span", keywordStyle, key + ": "],
+              formatValue(target[key], false)
+            ];
+          })
+        ]
+      ];
+    }
+    function formatValue(v, asRaw = true) {
+      if (typeof v === "number") {
+        return ["span", numberStyle, v];
+      } else if (typeof v === "string") {
+        return ["span", stringStyle, JSON.stringify(v)];
+      } else if (typeof v === "boolean") {
+        return ["span", keywordStyle, v];
+      } else if (isObject(v)) {
+        return ["object", { object: asRaw ? toRaw(v) : v }];
+      } else {
+        return ["span", stringStyle, String(v)];
+      }
     }
-
-    if (!isCreate) {
-      for (key in oldDirs) {
-        if (!newDirs[key]) {
-          // no longer present, unbind
-          callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
+    function extractKeys(instance, type) {
+      const Comp = instance.type;
+      if (isFunction(Comp)) {
+        return;
+      }
+      const extracted = {};
+      for (const key in instance.ctx) {
+        if (isKeyOfType(Comp, key, type)) {
+          extracted[key] = instance.ctx[key];
         }
       }
+      return extracted;
     }
-  }
-
-  var emptyModifiers = Object.create(null);
-
-  function normalizeDirectives$1 (
-    dirs,
-    vm
-  ) {
-    var res = Object.create(null);
-    if (!dirs) {
-      // $flow-disable-line
-      return res
+    function isKeyOfType(Comp, key, type) {
+      const opts = Comp[type];
+      if (isArray(opts) && opts.includes(key) || isObject(opts) && key in opts) {
+        return true;
+      }
+      if (Comp.extends && isKeyOfType(Comp.extends, key, type)) {
+        return true;
+      }
+      if (Comp.mixins && Comp.mixins.some((m) => isKeyOfType(m, key, type))) {
+        return true;
+      }
     }
-    var i, dir;
-    for (i = 0; i < dirs.length; i++) {
-      dir = dirs[i];
-      if (!dir.modifiers) {
-        // $flow-disable-line
-        dir.modifiers = emptyModifiers;
+    function genRefFlag(v) {
+      if (isShallow(v)) {
+        return `ShallowRef`;
+      }
+      if (v.effect) {
+        return `ComputedRef`;
       }
-      res[getRawDirName(dir)] = dir;
-      dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
+      return `Ref`;
+    }
+    if (window.devtoolsFormatters) {
+      window.devtoolsFormatters.push(formatter);
+    } else {
+      window.devtoolsFormatters = [formatter];
     }
-    // $flow-disable-line
-    return res
   }
 
-  function getRawDirName (dir) {
-    return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
+  function withMemo(memo, render, cache, index) {
+    const cached = cache[index];
+    if (cached && isMemoSame(cached, memo)) {
+      return cached;
+    }
+    const ret = render();
+    ret.memo = memo.slice();
+    ret.cacheIndex = index;
+    return cache[index] = ret;
   }
-
-  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 isMemoSame(cached, memo) {
+    const prev = cached.memo;
+    if (prev.length != memo.length) {
+      return false;
+    }
+    for (let i = 0; i < prev.length; i++) {
+      if (hasChanged(prev[i], memo[i])) {
+        return false;
       }
     }
+    if (isBlockTreeEnabled > 0 && currentBlock) {
+      currentBlock.push(cached);
+    }
+    return true;
   }
 
-  var baseModules = [
-    ref,
-    directives
-  ];
+  const version = "3.5.17";
+  const warn = warn$1 ;
+  const ErrorTypeStrings = ErrorTypeStrings$1 ;
+  const devtools = devtools$1 ;
+  const setDevtoolsHook = setDevtoolsHook$1 ;
+  const ssrUtils = null;
+  const resolveFilter = null;
+  const compatUtils = null;
+  const DeprecationTypes = null;
 
-  /*  */
-
-  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
+  let policy = void 0;
+  const tt = typeof window !== "undefined" && window.trustedTypes;
+  if (tt) {
+    try {
+      policy = /* @__PURE__ */ tt.createPolicy("vue", {
+        createHTML: (val) => val
+      });
+    } catch (e) {
+      warn(`Error creating trusted types policy: ${e}`);
     }
-    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);
+  }
+  const unsafeToTrustedHTML = policy ? (val) => policy.createHTML(val) : (val) => val;
+  const svgNS = "http://www.w3.org/2000/svg";
+  const mathmlNS = "http://www.w3.org/1998/Math/MathML";
+  const doc = typeof document !== "undefined" ? document : null;
+  const templateContainer = doc && /* @__PURE__ */ doc.createElement("template");
+  const nodeOps = {
+    insert: (child, parent, anchor) => {
+      parent.insertBefore(child, anchor || null);
+    },
+    remove: (child) => {
+      const parent = child.parentNode;
+      if (parent) {
+        parent.removeChild(child);
+      }
+    },
+    createElement: (tag, namespace, is, props) => {
+      const el = namespace === "svg" ? doc.createElementNS(svgNS, tag) : namespace === "mathml" ? doc.createElementNS(mathmlNS, tag) : is ? doc.createElement(tag, { is }) : doc.createElement(tag);
+      if (tag === "select" && props && props.multiple != null) {
+        el.setAttribute("multiple", props.multiple);
+      }
+      return el;
+    },
+    createText: (text) => doc.createTextNode(text),
+    createComment: (text) => doc.createComment(text),
+    setText: (node, text) => {
+      node.nodeValue = text;
+    },
+    setElementText: (el, text) => {
+      el.textContent = text;
+    },
+    parentNode: (node) => node.parentNode,
+    nextSibling: (node) => node.nextSibling,
+    querySelector: (selector) => doc.querySelector(selector),
+    setScopeId(el, id) {
+      el.setAttribute(id, "");
+    },
+    // __UNSAFE__
+    // Reason: innerHTML.
+    // Static content here can only come from compiled templates.
+    // As long as the user only uses trusted templates, this is safe.
+    insertStaticContent(content, parent, anchor, namespace, start, end) {
+      const before = anchor ? anchor.previousSibling : parent.lastChild;
+      if (start && (start === end || start.nextSibling)) {
+        while (true) {
+          parent.insertBefore(start.cloneNode(true), anchor);
+          if (start === end || !(start = start.nextSibling)) break;
+        }
+      } else {
+        templateContainer.innerHTML = unsafeToTrustedHTML(
+          namespace === "svg" ? `<svg>${content}</svg>` : namespace === "mathml" ? `<math>${content}</math>` : content
+        );
+        const template = templateContainer.content;
+        if (namespace === "svg" || namespace === "mathml") {
+          const wrapper = template.firstChild;
+          while (wrapper.firstChild) {
+            template.appendChild(wrapper.firstChild);
+          }
+          template.removeChild(wrapper);
+        }
+        parent.insertBefore(template, anchor);
+      }
+      return [
+        // first
+        before ? before.nextSibling : parent.firstChild,
+        // last
+        anchor ? anchor.previousSibling : parent.lastChild
+      ];
     }
+  };
 
-    for (key in attrs) {
-      cur = attrs[key];
-      old = oldAttrs[key];
-      if (old !== cur) {
-        setAttr(elm, key, cur);
+  const TRANSITION$1 = "transition";
+  const ANIMATION = "animation";
+  const vtcKey = Symbol("_vtc");
+  const DOMTransitionPropsValidators = {
+    name: String,
+    type: String,
+    css: {
+      type: Boolean,
+      default: true
+    },
+    duration: [String, Number, Object],
+    enterFromClass: String,
+    enterActiveClass: String,
+    enterToClass: String,
+    appearFromClass: String,
+    appearActiveClass: String,
+    appearToClass: String,
+    leaveFromClass: String,
+    leaveActiveClass: String,
+    leaveToClass: String
+  };
+  const TransitionPropsValidators = /* @__PURE__ */ extend(
+    {},
+    BaseTransitionPropsValidators,
+    DOMTransitionPropsValidators
+  );
+  const decorate$1 = (t) => {
+    t.displayName = "Transition";
+    t.props = TransitionPropsValidators;
+    return t;
+  };
+  const Transition = /* @__PURE__ */ decorate$1(
+    (props, { slots }) => h(BaseTransition, resolveTransitionProps(props), slots)
+  );
+  const callHook = (hook, args = []) => {
+    if (isArray(hook)) {
+      hook.forEach((h2) => h2(...args));
+    } else if (hook) {
+      hook(...args);
+    }
+  };
+  const hasExplicitCallback = (hook) => {
+    return hook ? isArray(hook) ? hook.some((h2) => h2.length > 1) : hook.length > 1 : false;
+  };
+  function resolveTransitionProps(rawProps) {
+    const baseProps = {};
+    for (const key in rawProps) {
+      if (!(key in DOMTransitionPropsValidators)) {
+        baseProps[key] = rawProps[key];
+      }
+    }
+    if (rawProps.css === false) {
+      return baseProps;
+    }
+    const {
+      name = "v",
+      type,
+      duration,
+      enterFromClass = `${name}-enter-from`,
+      enterActiveClass = `${name}-enter-active`,
+      enterToClass = `${name}-enter-to`,
+      appearFromClass = enterFromClass,
+      appearActiveClass = enterActiveClass,
+      appearToClass = enterToClass,
+      leaveFromClass = `${name}-leave-from`,
+      leaveActiveClass = `${name}-leave-active`,
+      leaveToClass = `${name}-leave-to`
+    } = rawProps;
+    const durations = normalizeDuration(duration);
+    const enterDuration = durations && durations[0];
+    const leaveDuration = durations && durations[1];
+    const {
+      onBeforeEnter,
+      onEnter,
+      onEnterCancelled,
+      onLeave,
+      onLeaveCancelled,
+      onBeforeAppear = onBeforeEnter,
+      onAppear = onEnter,
+      onAppearCancelled = onEnterCancelled
+    } = baseProps;
+    const finishEnter = (el, isAppear, done, isCancelled) => {
+      el._enterCancelled = isCancelled;
+      removeTransitionClass(el, isAppear ? appearToClass : enterToClass);
+      removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
+      done && done();
+    };
+    const finishLeave = (el, done) => {
+      el._isLeaving = false;
+      removeTransitionClass(el, leaveFromClass);
+      removeTransitionClass(el, leaveToClass);
+      removeTransitionClass(el, leaveActiveClass);
+      done && done();
+    };
+    const makeEnterHook = (isAppear) => {
+      return (el, done) => {
+        const hook = isAppear ? onAppear : onEnter;
+        const resolve = () => finishEnter(el, isAppear, done);
+        callHook(hook, [el, resolve]);
+        nextFrame(() => {
+          removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass);
+          addTransitionClass(el, isAppear ? appearToClass : enterToClass);
+          if (!hasExplicitCallback(hook)) {
+            whenTransitionEnds(el, type, enterDuration, resolve);
+          }
+        });
+      };
+    };
+    return extend(baseProps, {
+      onBeforeEnter(el) {
+        callHook(onBeforeEnter, [el]);
+        addTransitionClass(el, enterFromClass);
+        addTransitionClass(el, enterActiveClass);
+      },
+      onBeforeAppear(el) {
+        callHook(onBeforeAppear, [el]);
+        addTransitionClass(el, appearFromClass);
+        addTransitionClass(el, appearActiveClass);
+      },
+      onEnter: makeEnterHook(false),
+      onAppear: makeEnterHook(true),
+      onLeave(el, done) {
+        el._isLeaving = true;
+        const resolve = () => finishLeave(el, done);
+        addTransitionClass(el, leaveFromClass);
+        if (!el._enterCancelled) {
+          forceReflow();
+          addTransitionClass(el, leaveActiveClass);
+        } else {
+          addTransitionClass(el, leaveActiveClass);
+          forceReflow();
+        }
+        nextFrame(() => {
+          if (!el._isLeaving) {
+            return;
+          }
+          removeTransitionClass(el, leaveFromClass);
+          addTransitionClass(el, leaveToClass);
+          if (!hasExplicitCallback(onLeave)) {
+            whenTransitionEnds(el, type, leaveDuration, resolve);
+          }
+        });
+        callHook(onLeave, [el, resolve]);
+      },
+      onEnterCancelled(el) {
+        finishEnter(el, false, void 0, true);
+        callHook(onEnterCancelled, [el]);
+      },
+      onAppearCancelled(el) {
+        finishEnter(el, true, void 0, true);
+        callHook(onAppearCancelled, [el]);
+      },
+      onLeaveCancelled(el) {
+        finishLeave(el);
+        callHook(onLeaveCancelled, [el]);
       }
+    });
+  }
+  function normalizeDuration(duration) {
+    if (duration == null) {
+      return null;
+    } else if (isObject(duration)) {
+      return [NumberOf(duration.enter), NumberOf(duration.leave)];
+    } else {
+      const n = NumberOf(duration);
+      return [n, n];
     }
-    // #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);
+  }
+  function NumberOf(val) {
+    const res = toNumber(val);
+    {
+      assertNumber(res, "<transition> explicit duration");
     }
-    for (key in oldAttrs) {
-      if (isUndef(attrs[key])) {
-        if (isXlink(key)) {
-          elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
-        } else if (!isEnumeratedAttr(key)) {
-          elm.removeAttribute(key);
-        }
+    return res;
+  }
+  function addTransitionClass(el, cls) {
+    cls.split(/\s+/).forEach((c) => c && el.classList.add(c));
+    (el[vtcKey] || (el[vtcKey] = /* @__PURE__ */ new Set())).add(cls);
+  }
+  function removeTransitionClass(el, cls) {
+    cls.split(/\s+/).forEach((c) => c && el.classList.remove(c));
+    const _vtc = el[vtcKey];
+    if (_vtc) {
+      _vtc.delete(cls);
+      if (!_vtc.size) {
+        el[vtcKey] = void 0;
       }
     }
   }
-
-  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 nextFrame(cb) {
+    requestAnimationFrame(() => {
+      requestAnimationFrame(cb);
+    });
+  }
+  let endId = 0;
+  function whenTransitionEnds(el, expectedType, explicitTimeout, resolve) {
+    const id = el._endId = ++endId;
+    const resolveIfNotStale = () => {
+      if (id === el._endId) {
+        resolve();
+      }
+    };
+    if (explicitTimeout != null) {
+      return setTimeout(resolveIfNotStale, explicitTimeout);
+    }
+    const { type, timeout, propCount } = getTransitionInfo(el, expectedType);
+    if (!type) {
+      return resolve();
+    }
+    const endEvent = type + "end";
+    let ended = 0;
+    const end = () => {
+      el.removeEventListener(endEvent, onEnd);
+      resolveIfNotStale();
+    };
+    const onEnd = (e) => {
+      if (e.target === el && ++ended >= propCount) {
+        end();
+      }
+    };
+    setTimeout(() => {
+      if (ended < propCount) {
+        end();
+      }
+    }, timeout + 1);
+    el.addEventListener(endEvent, onEnd);
+  }
+  function getTransitionInfo(el, expectedType) {
+    const styles = window.getComputedStyle(el);
+    const getStyleProperties = (key) => (styles[key] || "").split(", ");
+    const transitionDelays = getStyleProperties(`${TRANSITION$1}Delay`);
+    const transitionDurations = getStyleProperties(`${TRANSITION$1}Duration`);
+    const transitionTimeout = getTimeout(transitionDelays, transitionDurations);
+    const animationDelays = getStyleProperties(`${ANIMATION}Delay`);
+    const animationDurations = getStyleProperties(`${ANIMATION}Duration`);
+    const animationTimeout = getTimeout(animationDelays, animationDurations);
+    let type = null;
+    let timeout = 0;
+    let propCount = 0;
+    if (expectedType === TRANSITION$1) {
+      if (transitionTimeout > 0) {
+        type = TRANSITION$1;
+        timeout = transitionTimeout;
+        propCount = transitionDurations.length;
+      }
+    } else if (expectedType === ANIMATION) {
+      if (animationTimeout > 0) {
+        type = ANIMATION;
+        timeout = animationTimeout;
+        propCount = animationDurations.length;
       }
     } else {
-      baseSetAttr(el, key, value);
+      timeout = Math.max(transitionTimeout, animationTimeout);
+      type = timeout > 0 ? transitionTimeout > animationTimeout ? TRANSITION$1 : ANIMATION : null;
+      propCount = type ? type === TRANSITION$1 ? transitionDurations.length : animationDurations.length : 0;
+    }
+    const hasTransform = type === TRANSITION$1 && /\b(transform|all)(,|$)/.test(
+      getStyleProperties(`${TRANSITION$1}Property`).toString()
+    );
+    return {
+      type,
+      timeout,
+      propCount,
+      hasTransform
+    };
+  }
+  function getTimeout(delays, durations) {
+    while (delays.length < durations.length) {
+      delays = delays.concat(delays);
     }
+    return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i])));
+  }
+  function toMs(s) {
+    if (s === "auto") return 0;
+    return Number(s.slice(0, -1).replace(",", ".")) * 1e3;
+  }
+  function forceReflow() {
+    return document.body.offsetHeight;
   }
 
-  function baseSetAttr (el, key, value) {
-    if (isFalsyAttrValue(value)) {
-      el.removeAttribute(key);
+  function patchClass(el, value, isSVG) {
+    const transitionClasses = el[vtcKey];
+    if (transitionClasses) {
+      value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
+    }
+    if (value == null) {
+      el.removeAttribute("class");
+    } else if (isSVG) {
+      el.setAttribute("class", value);
     } 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);
+      el.className = value;
     }
   }
 
-  var attrs = {
-    create: updateAttrs,
-    update: updateAttrs
+  const vShowOriginalDisplay = Symbol("_vod");
+  const vShowHidden = Symbol("_vsh");
+  const vShow = {
+    beforeMount(el, { value }, { transition }) {
+      el[vShowOriginalDisplay] = el.style.display === "none" ? "" : el.style.display;
+      if (transition && value) {
+        transition.beforeEnter(el);
+      } else {
+        setDisplay(el, value);
+      }
+    },
+    mounted(el, { value }, { transition }) {
+      if (transition && value) {
+        transition.enter(el);
+      }
+    },
+    updated(el, { value, oldValue }, { transition }) {
+      if (!value === !oldValue) return;
+      if (transition) {
+        if (value) {
+          transition.beforeEnter(el);
+          setDisplay(el, true);
+          transition.enter(el);
+        } else {
+          transition.leave(el, () => {
+            setDisplay(el, false);
+          });
+        }
+      } else {
+        setDisplay(el, value);
+      }
+    },
+    beforeUnmount(el, { value }) {
+      setDisplay(el, value);
+    }
   };
+  {
+    vShow.name = "show";
+  }
+  function setDisplay(el, value) {
+    el.style.display = value ? el[vShowOriginalDisplay] : "none";
+    el[vShowHidden] = !value;
+  }
 
-  /*  */
-
-  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
+  const CSS_VAR_TEXT = Symbol("CSS_VAR_TEXT" );
+  function useCssVars(getter) {
+    const instance = getCurrentInstance();
+    if (!instance) {
+      warn(`useCssVars is called without current active component instance.`);
+      return;
     }
-
-    var cls = genClassForVnode(vnode);
-
-    // handle transition classes
-    var transitionClass = el._transitionClasses;
-    if (isDef(transitionClass)) {
-      cls = concat(cls, stringifyClass(transitionClass));
+    const updateTeleports = instance.ut = (vars = getter(instance.proxy)) => {
+      Array.from(
+        document.querySelectorAll(`[data-v-owner="${instance.uid}"]`)
+      ).forEach((node) => setVarsOnNode(node, vars));
+    };
+    {
+      instance.getCssVars = () => getter(instance.proxy);
     }
-
-    // set the class
-    if (cls !== el._prevClass) {
-      el.setAttribute('class', cls);
-      el._prevClass = cls;
+    const setVars = () => {
+      const vars = getter(instance.proxy);
+      if (instance.ce) {
+        setVarsOnNode(instance.ce, vars);
+      } else {
+        setVarsOnVNode(instance.subTree, vars);
+      }
+      updateTeleports(vars);
+    };
+    onBeforeUpdate(() => {
+      queuePostFlushCb(setVars);
+    });
+    onMounted(() => {
+      watch(setVars, NOOP, { flush: "post" });
+      const ob = new MutationObserver(setVars);
+      ob.observe(instance.subTree.el.parentNode, { childList: true });
+      onUnmounted(() => ob.disconnect());
+    });
+  }
+  function setVarsOnVNode(vnode, vars) {
+    if (vnode.shapeFlag & 128) {
+      const suspense = vnode.suspense;
+      vnode = suspense.activeBranch;
+      if (suspense.pendingBranch && !suspense.isHydrating) {
+        suspense.effects.push(() => {
+          setVarsOnVNode(suspense.activeBranch, vars);
+        });
+      }
+    }
+    while (vnode.component) {
+      vnode = vnode.component.subTree;
+    }
+    if (vnode.shapeFlag & 1 && vnode.el) {
+      setVarsOnNode(vnode.el, vars);
+    } else if (vnode.type === Fragment) {
+      vnode.children.forEach((c) => setVarsOnVNode(c, vars));
+    } else if (vnode.type === Static) {
+      let { el, anchor } = vnode;
+      while (el) {
+        setVarsOnNode(el, vars);
+        if (el === anchor) break;
+        el = el.nextSibling;
+      }
+    }
+  }
+  function setVarsOnNode(el, vars) {
+    if (el.nodeType === 1) {
+      const style = el.style;
+      let cssText = "";
+      for (const key in vars) {
+        style.setProperty(`--${key}`, vars[key]);
+        cssText += `--${key}: ${vars[key]};`;
+      }
+      style[CSS_VAR_TEXT] = cssText;
     }
   }
 
-  var klass = {
-    create: updateClass,
-    update: updateClass
-  };
-
-  /*  */
-
-  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();
+  const displayRE = /(^|;)\s*display\s*:/;
+  function patchStyle(el, prev, next) {
+    const style = el.style;
+    const isCssString = isString(next);
+    let hasControlledDisplay = false;
+    if (next && !isCssString) {
+      if (prev) {
+        if (!isString(prev)) {
+          for (const key in prev) {
+            if (next[key] == null) {
+              setStyle(style, key, "");
+            }
+          }
         } else {
-          pushFilter();
+          for (const prevStyle of prev.split(";")) {
+            const key = prevStyle.slice(0, prevStyle.indexOf(":")).trim();
+            if (next[key] == null) {
+              setStyle(style, key, "");
+            }
+          }
         }
-      } 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                 // }
+      }
+      for (const key in next) {
+        if (key === "display") {
+          hasControlledDisplay = true;
         }
-        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;
+        setStyle(style, key, next[key]);
+      }
+    } else {
+      if (isCssString) {
+        if (prev !== next) {
+          const cssVarText = style[CSS_VAR_TEXT];
+          if (cssVarText) {
+            next += ";" + cssVarText;
           }
+          style.cssText = next;
+          hasControlledDisplay = displayRE.test(next);
         }
+      } else if (prev) {
+        el.removeAttribute("style");
       }
     }
-
-    if (expression === undefined) {
-      expression = exp.slice(0, i).trim();
-    } else if (lastFilterIndex !== 0) {
-      pushFilter();
+    if (vShowOriginalDisplay in el) {
+      el[vShowOriginalDisplay] = hasControlledDisplay ? style.display : "";
+      if (el[vShowHidden]) {
+        style.display = "none";
+      }
+    }
+  }
+  const semicolonRE = /[^\\];\s*$/;
+  const importantRE = /\s*!important$/;
+  function setStyle(style, name, val) {
+    if (isArray(val)) {
+      val.forEach((v) => setStyle(style, name, v));
+    } else {
+      if (val == null) val = "";
+      {
+        if (semicolonRE.test(val)) {
+          warn(
+            `Unexpected semicolon at the end of '${name}' style value: '${val}'`
+          );
+        }
+      }
+      if (name.startsWith("--")) {
+        style.setProperty(name, val);
+      } else {
+        const prefixed = autoPrefix(style, name);
+        if (importantRE.test(val)) {
+          style.setProperty(
+            hyphenate(prefixed),
+            val.replace(importantRE, ""),
+            "important"
+          );
+        } else {
+          style[prefixed] = val;
+        }
+      }
+    }
+  }
+  const prefixes = ["Webkit", "Moz", "ms"];
+  const prefixCache = {};
+  function autoPrefix(style, rawName) {
+    const cached = prefixCache[rawName];
+    if (cached) {
+      return cached;
+    }
+    let name = camelize(rawName);
+    if (name !== "filter" && name in style) {
+      return prefixCache[rawName] = name;
+    }
+    name = capitalize(name);
+    for (let i = 0; i < prefixes.length; i++) {
+      const prefixed = prefixes[i] + name;
+      if (prefixed in style) {
+        return prefixCache[rawName] = prefixed;
+      }
     }
+    return rawName;
+  }
 
-    function pushFilter () {
-      (filters || (filters = [])).push(exp.slice(lastFilterIndex, i).trim());
-      lastFilterIndex = i + 1;
+  const xlinkNS = "http://www.w3.org/1999/xlink";
+  function patchAttr(el, key, value, isSVG, instance, isBoolean = isSpecialBooleanAttr(key)) {
+    if (isSVG && key.startsWith("xlink:")) {
+      if (value == null) {
+        el.removeAttributeNS(xlinkNS, key.slice(6, key.length));
+      } else {
+        el.setAttributeNS(xlinkNS, key, value);
+      }
+    } else {
+      if (value == null || isBoolean && !includeBooleanAttr(value)) {
+        el.removeAttribute(key);
+      } else {
+        el.setAttribute(
+          key,
+          isBoolean ? "" : isSymbol(value) ? String(value) : value
+        );
+      }
     }
+  }
 
-    if (filters) {
-      for (i = 0; i < filters.length; i++) {
-        expression = wrapFilter(expression, filters[i]);
+  function patchDOMProp(el, key, value, parentComponent, attrName) {
+    if (key === "innerHTML" || key === "textContent") {
+      if (value != null) {
+        el[key] = key === "innerHTML" ? unsafeToTrustedHTML(value) : value;
+      }
+      return;
+    }
+    const tag = el.tagName;
+    if (key === "value" && tag !== "PROGRESS" && // custom elements may use _value internally
+    !tag.includes("-")) {
+      const oldValue = tag === "OPTION" ? el.getAttribute("value") || "" : el.value;
+      const newValue = value == null ? (
+        // #11647: value should be set as empty string for null and undefined,
+        // but <input type="checkbox"> should be set as 'on'.
+        el.type === "checkbox" ? "on" : ""
+      ) : String(value);
+      if (oldValue !== newValue || !("_value" in el)) {
+        el.value = newValue;
+      }
+      if (value == null) {
+        el.removeAttribute(key);
+      }
+      el._value = value;
+      return;
+    }
+    let needRemove = false;
+    if (value === "" || value == null) {
+      const type = typeof el[key];
+      if (type === "boolean") {
+        value = includeBooleanAttr(value);
+      } else if (value == null && type === "string") {
+        value = "";
+        needRemove = true;
+      } else if (type === "number") {
+        value = 0;
+        needRemove = true;
+      }
+    }
+    try {
+      el[key] = value;
+    } catch (e) {
+      if (!needRemove) {
+        warn(
+          `Failed setting prop "${key}" on <${tag.toLowerCase()}>: value ${value} is invalid.`,
+          e
+        );
       }
     }
+    needRemove && el.removeAttribute(attrName || key);
+  }
 
-    return expression
+  function addEventListener(el, event, handler, options) {
+    el.addEventListener(event, handler, options);
+  }
+  function removeEventListener(el, event, handler, options) {
+    el.removeEventListener(event, handler, options);
+  }
+  const veiKey = Symbol("_vei");
+  function patchEvent(el, rawName, prevValue, nextValue, instance = null) {
+    const invokers = el[veiKey] || (el[veiKey] = {});
+    const existingInvoker = invokers[rawName];
+    if (nextValue && existingInvoker) {
+      existingInvoker.value = sanitizeEventValue(nextValue, rawName) ;
+    } else {
+      const [name, options] = parseName(rawName);
+      if (nextValue) {
+        const invoker = invokers[rawName] = createInvoker(
+          sanitizeEventValue(nextValue, rawName) ,
+          instance
+        );
+        addEventListener(el, name, invoker, options);
+      } else if (existingInvoker) {
+        removeEventListener(el, name, existingInvoker, options);
+        invokers[rawName] = void 0;
+      }
+    }
+  }
+  const optionsModifierRE = /(?:Once|Passive|Capture)$/;
+  function parseName(name) {
+    let options;
+    if (optionsModifierRE.test(name)) {
+      options = {};
+      let m;
+      while (m = name.match(optionsModifierRE)) {
+        name = name.slice(0, name.length - m[0].length);
+        options[m[0].toLowerCase()] = true;
+      }
+    }
+    const event = name[2] === ":" ? name.slice(3) : hyphenate(name.slice(2));
+    return [event, options];
+  }
+  let cachedNow = 0;
+  const p = /* @__PURE__ */ Promise.resolve();
+  const getNow = () => cachedNow || (p.then(() => cachedNow = 0), cachedNow = Date.now());
+  function createInvoker(initialValue, instance) {
+    const invoker = (e) => {
+      if (!e._vts) {
+        e._vts = Date.now();
+      } else if (e._vts <= invoker.attached) {
+        return;
+      }
+      callWithAsyncErrorHandling(
+        patchStopImmediatePropagation(e, invoker.value),
+        instance,
+        5,
+        [e]
+      );
+    };
+    invoker.value = initialValue;
+    invoker.attached = getNow();
+    return invoker;
+  }
+  function sanitizeEventValue(value, propName) {
+    if (isFunction(value) || isArray(value)) {
+      return value;
+    }
+    warn(
+      `Wrong type passed as event handler to ${propName} - did you forget @ or : in front of your prop?
+Expected function or array of functions, received type ${typeof value}.`
+    );
+    return NOOP;
+  }
+  function patchStopImmediatePropagation(e, value) {
+    if (isArray(value)) {
+      const originalStop = e.stopImmediatePropagation;
+      e.stopImmediatePropagation = () => {
+        originalStop.call(e);
+        e._stopped = true;
+      };
+      return value.map(
+        (fn) => (e2) => !e2._stopped && fn && fn(e2)
+      );
+    } else {
+      return value;
+    }
   }
 
-  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))
-    }
-  }
-
-  /*  */
-
-
-
-  /* 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
+  const isNativeOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // lowercase letter
+  key.charCodeAt(2) > 96 && key.charCodeAt(2) < 123;
+  const patchProp = (el, key, prevValue, nextValue, namespace, parentComponent) => {
+    const isSVG = namespace === "svg";
+    if (key === "class") {
+      patchClass(el, nextValue, isSVG);
+    } else if (key === "style") {
+      patchStyle(el, prevValue, nextValue);
+    } else if (isOn(key)) {
+      if (!isModelListener(key)) {
+        patchEvent(el, key, prevValue, nextValue, parentComponent);
+      }
+    } else if (key[0] === "." ? (key = key.slice(1), true) : key[0] === "^" ? (key = key.slice(1), false) : shouldSetAsProp(el, key, nextValue, isSVG)) {
+      patchDOMProp(el, key, nextValue);
+      if (!el.tagName.includes("-") && (key === "value" || key === "checked" || key === "selected")) {
+        patchAttr(el, key, nextValue, isSVG, parentComponent, key !== "value");
+      }
+    } else if (
+      // #11081 force set props for possible async custom element
+      el._isVueCE && (/[A-Z]/.test(key) || !isString(nextValue))
     ) {
-      warn(
-        'passive and prevent can\'t be used together. ' +
-        'Passive handler can\'t prevent default event.',
-        range
-      );
+      patchDOMProp(el, camelize(key), nextValue, parentComponent, key);
+    } else {
+      if (key === "true-value") {
+        el._trueValue = nextValue;
+      } else if (key === "false-value") {
+        el._falseValue = nextValue;
+      }
+      patchAttr(el, key, nextValue, isSVG);
     }
-
-    // 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;
+  };
+  function shouldSetAsProp(el, key, value, isSVG) {
+    if (isSVG) {
+      if (key === "innerHTML" || key === "textContent") {
+        return true;
       }
-    } else if (modifiers.middle) {
-      if (dynamic) {
-        name = "(" + name + ")==='click'?'mouseup':(" + name + ")";
-      } else if (name === 'click') {
-        name = 'mouseup';
+      if (key in el && isNativeOn(key) && isFunction(value)) {
+        return true;
       }
+      return false;
     }
-
-    // check capture modifier
-    if (modifiers.capture) {
-      delete modifiers.capture;
-      name = prependModifierMarker('!', name, dynamic);
+    if (key === "spellcheck" || key === "draggable" || key === "translate" || key === "autocorrect") {
+      return false;
     }
-    if (modifiers.once) {
-      delete modifiers.once;
-      name = prependModifierMarker('~', name, dynamic);
+    if (key === "form") {
+      return false;
     }
-    /* istanbul ignore if */
-    if (modifiers.passive) {
-      delete modifiers.passive;
-      name = prependModifierMarker('&', name, dynamic);
+    if (key === "list" && el.tagName === "INPUT") {
+      return false;
     }
-
-    var events;
-    if (modifiers.native) {
-      delete modifiers.native;
-      events = el.nativeEvents || (el.nativeEvents = {});
-    } else {
-      events = el.events || (el.events = {});
+    if (key === "type" && el.tagName === "TEXTAREA") {
+      return false;
     }
-
-    var newHandler = rangeSetItem({ value: value.trim(), dynamic: dynamic }, range);
-    if (modifiers !== emptyObject) {
-      newHandler.modifiers = modifiers;
+    if (key === "width" || key === "height") {
+      const tag = el.tagName;
+      if (tag === "IMG" || tag === "VIDEO" || tag === "CANVAS" || tag === "SOURCE") {
+        return false;
+      }
     }
-
-    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;
+    if (isNativeOn(key) && isString(value)) {
+      return false;
     }
-
-    el.plain = false;
-  }
-
-  function getRawBindingAttr (
-    el,
-    name
-  ) {
-    return el.rawAttrsMap[':' + name] ||
-      el.rawAttrsMap['v-bind:' + name] ||
-      el.rawAttrsMap[name]
+    return key in el;
   }
 
-  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)
+  const REMOVAL = {};
+  /*! #__NO_SIDE_EFFECTS__ */
+  // @__NO_SIDE_EFFECTS__
+  function defineCustomElement(options, extraOptions, _createApp) {
+    const Comp = defineComponent(options, extraOptions);
+    if (isPlainObject(Comp)) extend(Comp, extraOptions);
+    class VueCustomElement extends VueElement {
+      constructor(initialProps) {
+        super(Comp, initialProps, _createApp);
       }
     }
+    VueCustomElement.def = Comp;
+    return VueCustomElement;
   }
-
-  // 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
+  /*! #__NO_SIDE_EFFECTS__ */
+  const defineSSRCustomElement = /* @__NO_SIDE_EFFECTS__ */ (options, extraOptions) => {
+    return /* @__PURE__ */ defineCustomElement(options, extraOptions, createSSRApp);
+  };
+  const BaseClass = typeof HTMLElement !== "undefined" ? HTMLElement : class {
+  };
+  class VueElement extends BaseClass {
+    constructor(_def, _props = {}, _createApp = createApp) {
+      super();
+      this._def = _def;
+      this._props = _props;
+      this._createApp = _createApp;
+      this._isVueCE = true;
+      /**
+       * @internal
+       */
+      this._instance = null;
+      /**
+       * @internal
+       */
+      this._app = null;
+      /**
+       * @internal
+       */
+      this._nonce = this._def.nonce;
+      this._connected = false;
+      this._resolved = false;
+      this._numberProps = null;
+      this._styleChildren = /* @__PURE__ */ new WeakSet();
+      this._ob = null;
+      if (this.shadowRoot && _createApp !== createApp) {
+        this._root = this.shadowRoot;
+      } else {
+        if (this.shadowRoot) {
+          warn(
+            `Custom element has pre-rendered declarative shadow root but is not defined as hydratable. Use \`defineSSRCustomElement\`.`
+          );
+        }
+        if (_def.shadowRoot !== false) {
+          this.attachShadow({ mode: "open" });
+          this._root = this.shadowRoot;
+        } else {
+          this._root = this;
         }
       }
     }
-    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
+    connectedCallback() {
+      if (!this.isConnected) return;
+      if (!this.shadowRoot && !this._resolved) {
+        this._parseSlots();
+      }
+      this._connected = true;
+      let parent = this;
+      while (parent = parent && (parent.parentNode || parent.host)) {
+        if (parent instanceof VueElement) {
+          this._parent = parent;
+          break;
+        }
+      }
+      if (!this._instance) {
+        if (this._resolved) {
+          this._mount(this._def);
+        } else {
+          if (parent && parent._pendingResolve) {
+            this._pendingResolve = parent._pendingResolve.then(() => {
+              this._pendingResolve = void 0;
+              this._resolveDef();
+            });
+          } else {
+            this._resolveDef();
+          }
+        }
       }
     }
-  }
-
-  function rangeSetItem (
-    item,
-    range
-  ) {
-    if (range) {
-      if (range.start != null) {
-        item.start = range.start;
+    _setParent(parent = this._parent) {
+      if (parent) {
+        this._instance.parent = parent._instance;
+        this._inheritParentContext(parent);
       }
-      if (range.end != null) {
-        item.end = range.end;
+    }
+    _inheritParentContext(parent = this._parent) {
+      if (parent && this._app) {
+        Object.setPrototypeOf(
+          this._app._context.provides,
+          parent._instance.provides
+        );
       }
     }
-    return item
-  }
-
-  /*  */
-
-  /**
-   * 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 + ")")
+    disconnectedCallback() {
+      this._connected = false;
+      nextTick(() => {
+        if (!this._connected) {
+          if (this._ob) {
+            this._ob.disconnect();
+            this._ob = null;
+          }
+          this._app && this._app.unmount();
+          if (this._instance) this._instance.ce = void 0;
+          this._app = this._instance = null;
+        }
+      });
     }
-  }
-
-  /**
-   * 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$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) + '"'
+    /**
+     * resolve inner component definition (handle possible async component)
+     */
+    _resolveDef() {
+      if (this._pendingResolve) {
+        return;
+      }
+      for (let i = 0; i < this.attributes.length; i++) {
+        this._setAttr(this.attributes[i].name);
+      }
+      this._ob = new MutationObserver((mutations) => {
+        for (const m of mutations) {
+          this._setAttr(m.attributeName);
+        }
+      });
+      this._ob.observe(this, { attributes: true });
+      const resolve = (def, isAsync = false) => {
+        this._resolved = true;
+        this._pendingResolve = void 0;
+        const { props, styles } = def;
+        let numberProps;
+        if (props && !isArray(props)) {
+          for (const key in props) {
+            const opt = props[key];
+            if (opt === Number || opt && opt.type === Number) {
+              if (key in this._props) {
+                this._props[key] = toNumber(this._props[key]);
+              }
+              (numberProps || (numberProps = /* @__PURE__ */ Object.create(null)))[camelize(key)] = true;
+            }
+          }
+        }
+        this._numberProps = numberProps;
+        this._resolveProps(def);
+        if (this.shadowRoot) {
+          this._applyStyles(styles);
+        } else if (styles) {
+          warn(
+            "Custom element style injection is not supported when using shadowRoot: false"
+          );
         }
+        this._mount(def);
+      };
+      const asyncDef = this._def.__asyncLoader;
+      if (asyncDef) {
+        this._pendingResolve = asyncDef().then((def) => {
+          def.configureApp = this._def.configureApp;
+          resolve(this._def = def, true);
+        });
       } else {
-        return {
-          exp: val,
-          key: null
+        resolve(this._def);
+      }
+    }
+    _mount(def) {
+      if (!def.name) {
+        def.name = "VueElement";
+      }
+      this._app = this._createApp(def);
+      this._inheritParentContext();
+      if (def.configureApp) {
+        def.configureApp(this._app);
+      }
+      this._app._ceVNode = this._createVNode();
+      this._app.mount(this._root);
+      const exposed = this._instance && this._instance.exposed;
+      if (!exposed) return;
+      for (const key in exposed) {
+        if (!hasOwn(this, key)) {
+          Object.defineProperty(this, key, {
+            // unwrap ref to be consistent with public instance behavior
+            get: () => unref(exposed[key])
+          });
+        } else {
+          warn(`Exposed property "${key}" already exists on custom element.`);
         }
       }
     }
-
-    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)
-    }
-  }
-
-  function next () {
-    return str.charCodeAt(++index$1)
-  }
-
-  function eof () {
-    return index$1 >= len
-  }
-
-  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
+    _resolveProps(def) {
+      const { props } = def;
+      const declaredPropKeys = isArray(props) ? props : Object.keys(props || {});
+      for (const key of Object.keys(this)) {
+        if (key[0] !== "_" && declaredPropKeys.includes(key)) {
+          this._setProp(key, this[key]);
+        }
       }
-      if (chr === 0x5B) { inBracket++; }
-      if (chr === 0x5D) { inBracket--; }
-      if (inBracket === 0) {
-        expressionEndPos = index$1;
-        break
+      for (const key of declaredPropKeys.map(camelize)) {
+        Object.defineProperty(this, key, {
+          get() {
+            return this._getProp(key);
+          },
+          set(val) {
+            this._setProp(key, val, true, true);
+          }
+        });
       }
     }
-  }
-
-  function parseString (chr) {
-    var stringQuote = chr;
-    while (!eof()) {
-      chr = next();
-      if (chr === stringQuote) {
-        break
+    _setAttr(key) {
+      if (key.startsWith("data-v-")) return;
+      const has = this.hasAttribute(key);
+      let value = has ? this.getAttribute(key) : REMOVAL;
+      const camelKey = camelize(key);
+      if (has && this._numberProps && this._numberProps[camelKey]) {
+        value = toNumber(value);
       }
+      this._setProp(camelKey, value, false, true);
     }
-  }
-
-  /*  */
-
-  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']
-        );
+    /**
+     * @internal
+     */
+    _getProp(key) {
+      return this._props[key];
+    }
+    /**
+     * @internal
+     */
+    _setProp(key, val, shouldReflect = true, shouldUpdate = false) {
+      if (val !== this._props[key]) {
+        if (val === REMOVAL) {
+          delete this._props[key];
+        } else {
+          this._props[key] = val;
+          if (key === "key" && this._app) {
+            this._app._ceVNode.key = val;
+          }
+        }
+        if (shouldUpdate && this._instance) {
+          this._update();
+        }
+        if (shouldReflect) {
+          const ob = this._ob;
+          ob && ob.disconnect();
+          if (val === true) {
+            this.setAttribute(hyphenate(key), "");
+          } else if (typeof val === "string" || typeof val === "number") {
+            this.setAttribute(hyphenate(key), val + "");
+          } else if (!val) {
+            this.removeAttribute(hyphenate(key));
+          }
+          ob && ob.observe(this, { attributes: true });
+        }
       }
     }
-
-    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']
-      );
+    _update() {
+      const vnode = this._createVNode();
+      if (this._app) vnode.appContext = this._app._context;
+      render(vnode, this._root);
     }
-
-    // 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]
-        );
+    _createVNode() {
+      const baseProps = {};
+      if (!this.shadowRoot) {
+        baseProps.onVnodeMounted = baseProps.onVnodeUpdated = this._renderSlots.bind(this);
+      }
+      const vnode = createVNode(this._def, extend(baseProps, this._props));
+      if (!this._instance) {
+        vnode.ce = (instance) => {
+          this._instance = instance;
+          instance.ce = this;
+          instance.isCE = true;
+          {
+            instance.ceReload = (newStyles) => {
+              if (this._styles) {
+                this._styles.forEach((s) => this._root.removeChild(s));
+                this._styles.length = 0;
+              }
+              this._applyStyles(newStyles);
+              this._instance = null;
+              this._update();
+            };
+          }
+          const dispatch = (event, args) => {
+            this.dispatchEvent(
+              new CustomEvent(
+                event,
+                isPlainObject(args[0]) ? extend({ detail: args }, args[0]) : { detail: args }
+              )
+            );
+          };
+          instance.emit = (event, ...args) => {
+            dispatch(event, args);
+            if (hyphenate(event) !== event) {
+              dispatch(hyphenate(event), args);
+            }
+          };
+          this._setParent();
+        };
       }
+      return vnode;
     }
-
-    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()";
+    _applyStyles(styles, owner) {
+      if (!styles) return;
+      if (owner) {
+        if (owner === this._def || this._styleChildren.has(owner)) {
+          return;
+        }
+        this._styleChildren.add(owner);
+      }
+      const nonce = this._nonce;
+      for (let i = styles.length - 1; i >= 0; i--) {
+        const s = document.createElement("style");
+        if (nonce) s.setAttribute("nonce", nonce);
+        s.textContent = styles[i];
+        this.shadowRoot.prepend(s);
+        {
+          if (owner) {
+            if (owner.__hmrId) {
+              if (!this._childStyles) this._childStyles = /* @__PURE__ */ new Map();
+              let entry = this._childStyles.get(owner.__hmrId);
+              if (!entry) {
+                this._childStyles.set(owner.__hmrId, entry = []);
+              }
+              entry.push(s);
+            }
+          } else {
+            (this._styles || (this._styles = [])).push(s);
+          }
+        }
+      }
     }
-    if (number) {
-      valueExpression = "_n(" + valueExpression + ")";
+    /**
+     * Only called when shadowRoot is false
+     */
+    _parseSlots() {
+      const slots = this._slots = {};
+      let n;
+      while (n = this.firstChild) {
+        const slotName = n.nodeType === 1 && n.getAttribute("slot") || "default";
+        (slots[slotName] || (slots[slotName] = [])).push(n);
+        this.removeChild(n);
+      }
     }
-
-    var code = genAssignmentCode(value, valueExpression);
-    if (needCompositionGuard) {
-      code = "if($event.target.composing)return;" + code;
+    /**
+     * Only called when shadowRoot is false
+     */
+    _renderSlots() {
+      const outlets = (this._teleportTarget || this).querySelectorAll("slot");
+      const scopeId = this._instance.type.__scopeId;
+      for (let i = 0; i < outlets.length; i++) {
+        const o = outlets[i];
+        const slotName = o.getAttribute("name") || "default";
+        const content = this._slots[slotName];
+        const parent = o.parentNode;
+        if (content) {
+          for (const n of content) {
+            if (scopeId && n.nodeType === 1) {
+              const id = scopeId + "-s";
+              const walker = document.createTreeWalker(n, 1);
+              n.setAttribute(id, "");
+              let child;
+              while (child = walker.nextNode()) {
+                child.setAttribute(id, "");
+              }
+            }
+            parent.insertBefore(n, o);
+          }
+        } else {
+          while (o.firstChild) parent.insertBefore(o.firstChild, o);
+        }
+        parent.removeChild(o);
+      }
     }
-
-    addProp(el, 'value', ("(" + value + ")"));
-    addHandler(el, event, code, null, true);
-    if (trim || number) {
-      addHandler(el, 'blur', '$forceUpdate()');
+    /**
+     * @internal
+     */
+    _injectChildStyle(comp) {
+      this._applyStyles(comp.styles, comp);
     }
-  }
-
-  /*  */
-
-  // 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];
+    /**
+     * @internal
+     */
+    _removeChildStyle(comp) {
+      {
+        this._styleChildren.delete(comp);
+        if (this._childStyles && comp.__hmrId) {
+          const oldStyles = this._childStyles.get(comp.__hmrId);
+          if (oldStyles) {
+            oldStyles.forEach((s) => this._root.removeChild(s));
+            oldStyles.length = 0;
+          }
+        }
+      }
     }
-    // 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 useHost(caller) {
+    const instance = getCurrentInstance();
+    const el = instance && instance.ce;
+    if (el) {
+      return el;
+    } else {
+      if (!instance) {
+        warn(
+          `${caller || "useHost"} called without an active component instance.`
+        );
+      } else {
+        warn(
+          `${caller || "useHost"} can only be used in components defined via defineCustomElement.`
+        );
+      }
     }
+    return null;
+  }
+  function useShadowRoot() {
+    const el = useHost("useShadowRoot") ;
+    return el && el.shadowRoot;
   }
 
-  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 useCssModule(name = "$style") {
+    {
+      {
+        warn(`useCssModule() is not supported in the global build.`);
       }
+      return EMPTY_OBJ;
     }
   }
 
-  // #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)
+  const positionMap = /* @__PURE__ */ new WeakMap();
+  const newPositionMap = /* @__PURE__ */ new WeakMap();
+  const moveCbKey = Symbol("_moveCb");
+  const enterCbKey = Symbol("_enterCb");
+  const decorate = (t) => {
+    delete t.props.mode;
+    return t;
+  };
+  const TransitionGroupImpl = /* @__PURE__ */ decorate({
+    name: "TransitionGroup",
+    props: /* @__PURE__ */ extend({}, TransitionPropsValidators, {
+      tag: String,
+      moveClass: String
+    }),
+    setup(props, { slots }) {
+      const instance = getCurrentInstance();
+      const state = useTransitionState();
+      let prevChildren;
+      let children;
+      onUpdated(() => {
+        if (!prevChildren.length) {
+          return;
         }
+        const moveClass = props.moveClass || `${props.name || "v"}-move`;
+        if (!hasCSSTransform(
+          prevChildren[0].el,
+          instance.vnode.el,
+          moveClass
+        )) {
+          prevChildren = [];
+          return;
+        }
+        prevChildren.forEach(callPendingCbs);
+        prevChildren.forEach(recordPosition);
+        const movedChildren = prevChildren.filter(applyTranslation);
+        forceReflow();
+        movedChildren.forEach((c) => {
+          const el = c.el;
+          const style = el.style;
+          addTransitionClass(el, moveClass);
+          style.transform = style.webkitTransform = style.transitionDuration = "";
+          const cb = el[moveCbKey] = (e) => {
+            if (e && e.target !== el) {
+              return;
+            }
+            if (!e || /transform$/.test(e.propertyName)) {
+              el.removeEventListener("transitionend", cb);
+              el[moveCbKey] = null;
+              removeTransitionClass(el, moveClass);
+            }
+          };
+          el.addEventListener("transitionend", cb);
+        });
+        prevChildren = [];
+      });
+      return () => {
+        const rawProps = toRaw(props);
+        const cssTransitionProps = resolveTransitionProps(rawProps);
+        let tag = rawProps.tag || Fragment;
+        prevChildren = [];
+        if (children) {
+          for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (child.el && child.el instanceof Element) {
+              prevChildren.push(child);
+              setTransitionHooks(
+                child,
+                resolveTransitionHooks(
+                  child,
+                  cssTransitionProps,
+                  state,
+                  instance
+                )
+              );
+              positionMap.set(
+                child,
+                child.el.getBoundingClientRect()
+              );
+            }
+          }
+        }
+        children = slots.default ? getTransitionRawChildren(slots.default()) : [];
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+          if (child.key != null) {
+            setTransitionHooks(
+              child,
+              resolveTransitionHooks(child, cssTransitionProps, state, instance)
+            );
+          } else if (child.type !== Text) {
+            warn(`<TransitionGroup> children must be keyed.`);
+          }
+        }
+        return createVNode(tag, null, children);
       };
     }
-    target$1.addEventListener(
-      name,
-      handler,
-      supportsPassive
-        ? { capture: capture, passive: passive }
-        : capture
-    );
+  });
+  const TransitionGroup = TransitionGroupImpl;
+  function callPendingCbs(c) {
+    const el = c.el;
+    if (el[moveCbKey]) {
+      el[moveCbKey]();
+    }
+    if (el[enterCbKey]) {
+      el[enterCbKey]();
+    }
   }
-
-  function remove$2 (
-    name,
-    handler,
-    capture,
-    _target
-  ) {
-    (_target || target$1).removeEventListener(
-      name,
-      handler._wrapper || handler,
-      capture
-    );
+  function recordPosition(c) {
+    newPositionMap.set(c, c.el.getBoundingClientRect());
   }
-
-  function updateDOMListeners (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.on) && isUndef(vnode.data.on)) {
-      return
+  function applyTranslation(c) {
+    const oldPos = positionMap.get(c);
+    const newPos = newPositionMap.get(c);
+    const dx = oldPos.left - newPos.left;
+    const dy = oldPos.top - newPos.top;
+    if (dx || dy) {
+      const s = c.el.style;
+      s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)`;
+      s.transitionDuration = "0s";
+      return c;
+    }
+  }
+  function hasCSSTransform(el, root, moveClass) {
+    const clone = el.cloneNode();
+    const _vtc = el[vtcKey];
+    if (_vtc) {
+      _vtc.forEach((cls) => {
+        cls.split(/\s+/).forEach((c) => c && clone.classList.remove(c));
+      });
     }
-    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;
+    moveClass.split(/\s+/).forEach((c) => c && clone.classList.add(c));
+    clone.style.display = "none";
+    const container = root.nodeType === 1 ? root : root.parentNode;
+    container.appendChild(clone);
+    const { hasTransform } = getTransitionInfo(clone);
+    container.removeChild(clone);
+    return hasTransform;
   }
 
-  var events = {
-    create: updateDOMListeners,
-    update: updateDOMListeners
+  const getModelAssigner = (vnode) => {
+    const fn = vnode.props["onUpdate:modelValue"] || false;
+    return isArray(fn) ? (value) => invokeArrayFns(fn, value) : fn;
   };
-
-  /*  */
-
-  var svgContainer;
-
-  function updateDOMProps (oldVnode, vnode) {
-    if (isUndef(oldVnode.data.domProps) && isUndef(vnode.data.domProps)) {
-      return
+  function onCompositionStart(e) {
+    e.target.composing = true;
+  }
+  function onCompositionEnd(e) {
+    const target = e.target;
+    if (target.composing) {
+      target.composing = false;
+      target.dispatchEvent(new Event("input"));
+    }
+  }
+  const assignKey = Symbol("_assign");
+  const vModelText = {
+    created(el, { modifiers: { lazy, trim, number } }, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+      const castToNumber = number || vnode.props && vnode.props.type === "number";
+      addEventListener(el, lazy ? "change" : "input", (e) => {
+        if (e.target.composing) return;
+        let domValue = el.value;
+        if (trim) {
+          domValue = domValue.trim();
+        }
+        if (castToNumber) {
+          domValue = looseToNumber(domValue);
+        }
+        el[assignKey](domValue);
+      });
+      if (trim) {
+        addEventListener(el, "change", () => {
+          el.value = el.value.trim();
+        });
+      }
+      if (!lazy) {
+        addEventListener(el, "compositionstart", onCompositionStart);
+        addEventListener(el, "compositionend", onCompositionEnd);
+        addEventListener(el, "change", onCompositionEnd);
+      }
+    },
+    // set value on mounted so it's after min/max for type="range"
+    mounted(el, { value }) {
+      el.value = value == null ? "" : value;
+    },
+    beforeUpdate(el, { value, oldValue, modifiers: { lazy, trim, number } }, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+      if (el.composing) return;
+      const elValue = (number || el.type === "number") && !/^0\d/.test(el.value) ? looseToNumber(el.value) : el.value;
+      const newValue = value == null ? "" : value;
+      if (elValue === newValue) {
+        return;
+      }
+      if (document.activeElement === el && el.type !== "range") {
+        if (lazy && value === oldValue) {
+          return;
+        }
+        if (trim && el.value.trim() === newValue) {
+          return;
+        }
+      }
+      el.value = newValue;
+    }
+  };
+  const vModelCheckbox = {
+    // #4096 array checkboxes need to be deep traversed
+    deep: true,
+    created(el, _, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+      addEventListener(el, "change", () => {
+        const modelValue = el._modelValue;
+        const elementValue = getValue(el);
+        const checked = el.checked;
+        const assign = el[assignKey];
+        if (isArray(modelValue)) {
+          const index = looseIndexOf(modelValue, elementValue);
+          const found = index !== -1;
+          if (checked && !found) {
+            assign(modelValue.concat(elementValue));
+          } else if (!checked && found) {
+            const filtered = [...modelValue];
+            filtered.splice(index, 1);
+            assign(filtered);
+          }
+        } else if (isSet(modelValue)) {
+          const cloned = new Set(modelValue);
+          if (checked) {
+            cloned.add(elementValue);
+          } else {
+            cloned.delete(elementValue);
+          }
+          assign(cloned);
+        } else {
+          assign(getCheckboxValue(el, checked));
+        }
+      });
+    },
+    // set initial checked on mount to wait for true-value/false-value
+    mounted: setChecked,
+    beforeUpdate(el, binding, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+      setChecked(el, binding, vnode);
     }
-    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);
+  };
+  function setChecked(el, { value, oldValue }, vnode) {
+    el._modelValue = value;
+    let checked;
+    if (isArray(value)) {
+      checked = looseIndexOf(value, vnode.props.value) > -1;
+    } else if (isSet(value)) {
+      checked = value.has(vnode.props.value);
+    } else {
+      if (value === oldValue) return;
+      checked = looseEqual(value, getCheckboxValue(el, true));
     }
-
-    for (key in oldProps) {
-      if (!(key in props)) {
-        elm[key] = '';
+    if (el.checked !== checked) {
+      el.checked = checked;
+    }
+  }
+  const vModelRadio = {
+    created(el, { value }, vnode) {
+      el.checked = looseEqual(value, vnode.props.value);
+      el[assignKey] = getModelAssigner(vnode);
+      addEventListener(el, "change", () => {
+        el[assignKey](getValue(el));
+      });
+    },
+    beforeUpdate(el, { value, oldValue }, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+      if (value !== oldValue) {
+        el.checked = looseEqual(value, vnode.props.value);
+      }
+    }
+  };
+  const vModelSelect = {
+    // <select multiple> value need to be deep traversed
+    deep: true,
+    created(el, { value, modifiers: { number } }, vnode) {
+      const isSetModel = isSet(value);
+      addEventListener(el, "change", () => {
+        const selectedVal = Array.prototype.filter.call(el.options, (o) => o.selected).map(
+          (o) => number ? looseToNumber(getValue(o)) : getValue(o)
+        );
+        el[assignKey](
+          el.multiple ? isSetModel ? new Set(selectedVal) : selectedVal : selectedVal[0]
+        );
+        el._assigning = true;
+        nextTick(() => {
+          el._assigning = false;
+        });
+      });
+      el[assignKey] = getModelAssigner(vnode);
+    },
+    // set value in mounted & updated because <select> relies on its children
+    // <option>s.
+    mounted(el, { value }) {
+      setSelected(el, value);
+    },
+    beforeUpdate(el, _binding, vnode) {
+      el[assignKey] = getModelAssigner(vnode);
+    },
+    updated(el, { value }) {
+      if (!el._assigning) {
+        setSelected(el, value);
       }
     }
-
-    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);
+  };
+  function setSelected(el, value) {
+    const isMultiple = el.multiple;
+    const isArrayValue = isArray(value);
+    if (isMultiple && !isArrayValue && !isSet(value)) {
+      warn(
+        `<select multiple v-model> expects an Array or Set value for its binding, but got ${Object.prototype.toString.call(value).slice(8, -1)}.`
+      );
+      return;
+    }
+    for (let i = 0, l = el.options.length; i < l; i++) {
+      const option = el.options[i];
+      const optionValue = getValue(option);
+      if (isMultiple) {
+        if (isArrayValue) {
+          const optionType = typeof optionValue;
+          if (optionType === "string" || optionType === "number") {
+            option.selected = value.some((v) => String(v) === String(optionValue));
+          } else {
+            option.selected = looseIndexOf(value, optionValue) > -1;
+          }
+        } else {
+          option.selected = value.has(optionValue);
         }
-      } 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 unnecesarry `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) {}
+      } else if (looseEqual(getValue(option), value)) {
+        if (el.selectedIndex !== i) el.selectedIndex = i;
+        return;
       }
     }
+    if (!isMultiple && el.selectedIndex !== -1) {
+      el.selectedIndex = -1;
+    }
   }
-
-  // check platforms/web/util/attrs.js acceptValue
-
-
-  function shouldUpdateValue (elm, checkVal) {
-    return (!elm.composing && (
-      elm.tagName === 'OPTION' ||
-      isNotInFocusAndDirty(elm, checkVal) ||
-      isDirtyWithModifiers(elm, checkVal)
-    ))
+  function getValue(el) {
+    return "_value" in el ? el._value : el.value;
   }
-
-  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 getCheckboxValue(el, checked) {
+    const key = checked ? "_trueValue" : "_falseValue";
+    return key in el ? el[key] : checked;
   }
-
-  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()
-      }
+  const vModelDynamic = {
+    created(el, binding, vnode) {
+      callModelHook(el, binding, vnode, null, "created");
+    },
+    mounted(el, binding, vnode) {
+      callModelHook(el, binding, vnode, null, "mounted");
+    },
+    beforeUpdate(el, binding, vnode, prevVNode) {
+      callModelHook(el, binding, vnode, prevVNode, "beforeUpdate");
+    },
+    updated(el, binding, vnode, prevVNode) {
+      callModelHook(el, binding, vnode, prevVNode, "updated");
+    }
+  };
+  function resolveDynamicModel(tagName, type) {
+    switch (tagName) {
+      case "SELECT":
+        return vModelSelect;
+      case "TEXTAREA":
+        return vModelText;
+      default:
+        switch (type) {
+          case "checkbox":
+            return vModelCheckbox;
+          case "radio":
+            return vModelRadio;
+          default:
+            return vModelText;
+        }
     }
-    return value !== newVal
   }
-
-  var domProps = {
-    create: updateDOMProps,
-    update: updateDOMProps
+  function callModelHook(el, binding, vnode, prevVNode, hook) {
+    const modelToUse = resolveDynamicModel(
+      el.tagName,
+      vnode.props && vnode.props.type
+    );
+    const fn = modelToUse[hook];
+    fn && fn(el, binding, vnode, prevVNode);
+  }
+
+  const systemModifiers = ["ctrl", "shift", "alt", "meta"];
+  const modifierGuards = {
+    stop: (e) => e.stopPropagation(),
+    prevent: (e) => e.preventDefault(),
+    self: (e) => e.target !== e.currentTarget,
+    ctrl: (e) => !e.ctrlKey,
+    shift: (e) => !e.shiftKey,
+    alt: (e) => !e.altKey,
+    meta: (e) => !e.metaKey,
+    left: (e) => "button" in e && e.button !== 0,
+    middle: (e) => "button" in e && e.button !== 1,
+    right: (e) => "button" in e && e.button !== 2,
+    exact: (e, modifiers) => systemModifiers.some((m) => e[`${m}Key`] && !modifiers.includes(m))
   };
-
-  /*  */
-
-  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());
+  const withModifiers = (fn, modifiers) => {
+    const cache = fn._withMods || (fn._withMods = {});
+    const cacheKey = modifiers.join(".");
+    return cache[cacheKey] || (cache[cacheKey] = (event, ...args) => {
+      for (let i = 0; i < modifiers.length; i++) {
+        const guard = modifierGuards[modifiers[i]];
+        if (guard && guard(event, modifiers)) return;
+      }
+      return fn(event, ...args);
+    });
+  };
+  const keyNames = {
+    esc: "escape",
+    space: " ",
+    up: "arrow-up",
+    left: "arrow-left",
+    right: "arrow-right",
+    down: "arrow-down",
+    delete: "backspace"
+  };
+  const withKeys = (fn, modifiers) => {
+    const cache = fn._withKeys || (fn._withKeys = {});
+    const cacheKey = modifiers.join(".");
+    return cache[cacheKey] || (cache[cacheKey] = (event) => {
+      if (!("key" in event)) {
+        return;
+      }
+      const eventKey = hyphenate(event.key);
+      if (modifiers.some(
+        (k) => k === eventKey || keyNames[k] === eventKey
+      )) {
+        return fn(event);
       }
     });
-    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
+  const rendererOptions = /* @__PURE__ */ extend({ patchProp }, nodeOps);
+  let renderer;
+  let enabledHydration = false;
+  function ensureRenderer() {
+    return renderer || (renderer = createRenderer(rendererOptions));
   }
-
-  // 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 ensureHydrationRenderer() {
+    renderer = enabledHydration ? renderer : createHydrationRenderer(rendererOptions);
+    enabledHydration = true;
+    return renderer;
   }
-
-  /**
-   * 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))) {
-      extend(res, styleData);
+  const render = (...args) => {
+    ensureRenderer().render(...args);
+  };
+  const hydrate = (...args) => {
+    ensureHydrationRenderer().hydrate(...args);
+  };
+  const createApp = (...args) => {
+    const app = ensureRenderer().createApp(...args);
+    {
+      injectNativeTagCheck(app);
+      injectCompilerOptionsCheck(app);
+    }
+    const { mount } = app;
+    app.mount = (containerOrSelector) => {
+      const container = normalizeContainer(containerOrSelector);
+      if (!container) return;
+      const component = app._component;
+      if (!isFunction(component) && !component.render && !component.template) {
+        component.template = container.innerHTML;
+      }
+      if (container.nodeType === 1) {
+        container.textContent = "";
+      }
+      const proxy = mount(container, false, resolveRootNamespace(container));
+      if (container instanceof Element) {
+        container.removeAttribute("v-cloak");
+        container.setAttribute("data-v-app", "");
+      }
+      return proxy;
+    };
+    return app;
+  };
+  const createSSRApp = (...args) => {
+    const app = ensureHydrationRenderer().createApp(...args);
+    {
+      injectNativeTagCheck(app);
+      injectCompilerOptionsCheck(app);
     }
-
-    var parentNode = vnode;
-    while ((parentNode = parentNode.parent)) {
-      if (parentNode.data && (styleData = normalizeStyleData(parentNode.data))) {
-        extend(res, styleData);
+    const { mount } = app;
+    app.mount = (containerOrSelector) => {
+      const container = normalizeContainer(containerOrSelector);
+      if (container) {
+        return mount(container, true, resolveRootNamespace(container));
       }
+    };
+    return app;
+  };
+  function resolveRootNamespace(container) {
+    if (container instanceof SVGElement) {
+      return "svg";
+    }
+    if (typeof MathMLElement === "function" && container instanceof MathMLElement) {
+      return "mathml";
     }
-    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];
+  function injectNativeTagCheck(app) {
+    Object.defineProperty(app.config, "isNativeTag", {
+      value: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
+      writable: false
+    });
+  }
+  function injectCompilerOptionsCheck(app) {
+    if (isRuntimeOnly()) {
+      const isCustomElement = app.config.isCustomElement;
+      Object.defineProperty(app.config, "isCustomElement", {
+        get() {
+          return isCustomElement;
+        },
+        set() {
+          warn(
+            `The \`isCustomElement\` config option is deprecated. Use \`compilerOptions.isCustomElement\` instead.`
+          );
         }
-      } 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
+      });
+      const compilerOptions = app.config.compilerOptions;
+      const msg = `The \`compilerOptions\` config option is only respected when using a build of Vue.js that includes the runtime compiler (aka "full build"). Since you are using the runtime-only build, \`compilerOptions\` must be passed to \`@vue/compiler-dom\` in the build setup instead.
+- For vue-loader: pass it via vue-loader's \`compilerOptions\` loader option.
+- For vue-cli: see https://cli.vuejs.org/guide/webpack.html#modifying-options-of-a-loader
+- For vite: pass it via @vitejs/plugin-vue options. See https://github.com/vitejs/vite-plugin-vue/tree/main/packages/plugin-vue#example-for-passing-options-to-vuecompiler-sfc`;
+      Object.defineProperty(app.config, "compilerOptions", {
+        get() {
+          warn(msg);
+          return compilerOptions;
+        },
+        set() {
+          warn(msg);
+        }
+      });
     }
-    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 normalizeContainer(container) {
+    if (isString(container)) {
+      const res = document.querySelector(container);
+      if (!res) {
+        warn(
+          `Failed to mount app: mount target selector "${container}" returned null.`
+        );
       }
+      return res;
     }
-  });
-
-  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
+    if (window.ShadowRoot && container instanceof window.ShadowRoot && container.mode === "closed") {
+      warn(
+        `mounting on a ShadowRoot with \`{mode: "closed"}\` may lead to unpredictable bugs`
+      );
     }
+    return container;
+  }
+  const initDirectivesForSSR = NOOP;
 
-    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);
+  function initDev() {
+    {
+      {
+        console.info(
+          `You are running a development build of Vue.
+Make sure to use the production build (*.prod.js) when deploying for production.`
+        );
       }
+      initCustomFormatter();
     }
   }
 
-  var style = {
-    create: updateStyle,
-    update: updateStyle
+  const FRAGMENT = Symbol(`Fragment` );
+  const TELEPORT = Symbol(`Teleport` );
+  const SUSPENSE = Symbol(`Suspense` );
+  const KEEP_ALIVE = Symbol(`KeepAlive` );
+  const BASE_TRANSITION = Symbol(
+    `BaseTransition` 
+  );
+  const OPEN_BLOCK = Symbol(`openBlock` );
+  const CREATE_BLOCK = Symbol(`createBlock` );
+  const CREATE_ELEMENT_BLOCK = Symbol(
+    `createElementBlock` 
+  );
+  const CREATE_VNODE = Symbol(`createVNode` );
+  const CREATE_ELEMENT_VNODE = Symbol(
+    `createElementVNode` 
+  );
+  const CREATE_COMMENT = Symbol(
+    `createCommentVNode` 
+  );
+  const CREATE_TEXT = Symbol(
+    `createTextVNode` 
+  );
+  const CREATE_STATIC = Symbol(
+    `createStaticVNode` 
+  );
+  const RESOLVE_COMPONENT = Symbol(
+    `resolveComponent` 
+  );
+  const RESOLVE_DYNAMIC_COMPONENT = Symbol(
+    `resolveDynamicComponent` 
+  );
+  const RESOLVE_DIRECTIVE = Symbol(
+    `resolveDirective` 
+  );
+  const RESOLVE_FILTER = Symbol(
+    `resolveFilter` 
+  );
+  const WITH_DIRECTIVES = Symbol(
+    `withDirectives` 
+  );
+  const RENDER_LIST = Symbol(`renderList` );
+  const RENDER_SLOT = Symbol(`renderSlot` );
+  const CREATE_SLOTS = Symbol(`createSlots` );
+  const TO_DISPLAY_STRING = Symbol(
+    `toDisplayString` 
+  );
+  const MERGE_PROPS = Symbol(`mergeProps` );
+  const NORMALIZE_CLASS = Symbol(
+    `normalizeClass` 
+  );
+  const NORMALIZE_STYLE = Symbol(
+    `normalizeStyle` 
+  );
+  const NORMALIZE_PROPS = Symbol(
+    `normalizeProps` 
+  );
+  const GUARD_REACTIVE_PROPS = Symbol(
+    `guardReactiveProps` 
+  );
+  const TO_HANDLERS = Symbol(`toHandlers` );
+  const CAMELIZE = Symbol(`camelize` );
+  const CAPITALIZE = Symbol(`capitalize` );
+  const TO_HANDLER_KEY = Symbol(
+    `toHandlerKey` 
+  );
+  const SET_BLOCK_TRACKING = Symbol(
+    `setBlockTracking` 
+  );
+  const PUSH_SCOPE_ID = Symbol(`pushScopeId` );
+  const POP_SCOPE_ID = Symbol(`popScopeId` );
+  const WITH_CTX = Symbol(`withCtx` );
+  const UNREF = Symbol(`unref` );
+  const IS_REF = Symbol(`isRef` );
+  const WITH_MEMO = Symbol(`withMemo` );
+  const IS_MEMO_SAME = Symbol(`isMemoSame` );
+  const helperNameMap = {
+    [FRAGMENT]: `Fragment`,
+    [TELEPORT]: `Teleport`,
+    [SUSPENSE]: `Suspense`,
+    [KEEP_ALIVE]: `KeepAlive`,
+    [BASE_TRANSITION]: `BaseTransition`,
+    [OPEN_BLOCK]: `openBlock`,
+    [CREATE_BLOCK]: `createBlock`,
+    [CREATE_ELEMENT_BLOCK]: `createElementBlock`,
+    [CREATE_VNODE]: `createVNode`,
+    [CREATE_ELEMENT_VNODE]: `createElementVNode`,
+    [CREATE_COMMENT]: `createCommentVNode`,
+    [CREATE_TEXT]: `createTextVNode`,
+    [CREATE_STATIC]: `createStaticVNode`,
+    [RESOLVE_COMPONENT]: `resolveComponent`,
+    [RESOLVE_DYNAMIC_COMPONENT]: `resolveDynamicComponent`,
+    [RESOLVE_DIRECTIVE]: `resolveDirective`,
+    [RESOLVE_FILTER]: `resolveFilter`,
+    [WITH_DIRECTIVES]: `withDirectives`,
+    [RENDER_LIST]: `renderList`,
+    [RENDER_SLOT]: `renderSlot`,
+    [CREATE_SLOTS]: `createSlots`,
+    [TO_DISPLAY_STRING]: `toDisplayString`,
+    [MERGE_PROPS]: `mergeProps`,
+    [NORMALIZE_CLASS]: `normalizeClass`,
+    [NORMALIZE_STYLE]: `normalizeStyle`,
+    [NORMALIZE_PROPS]: `normalizeProps`,
+    [GUARD_REACTIVE_PROPS]: `guardReactiveProps`,
+    [TO_HANDLERS]: `toHandlers`,
+    [CAMELIZE]: `camelize`,
+    [CAPITALIZE]: `capitalize`,
+    [TO_HANDLER_KEY]: `toHandlerKey`,
+    [SET_BLOCK_TRACKING]: `setBlockTracking`,
+    [PUSH_SCOPE_ID]: `pushScopeId`,
+    [POP_SCOPE_ID]: `popScopeId`,
+    [WITH_CTX]: `withCtx`,
+    [UNREF]: `unref`,
+    [IS_REF]: `isRef`,
+    [WITH_MEMO]: `withMemo`,
+    [IS_MEMO_SAME]: `isMemoSame`
   };
-
-  /*  */
-
-  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());
-      }
-    }
+  function registerRuntimeHelpers(helpers) {
+    Object.getOwnPropertySymbols(helpers).forEach((s) => {
+      helperNameMap[s] = helpers[s];
+    });
   }
 
-  /**
-   * 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); });
+  const locStub = {
+    start: { line: 1, column: 1, offset: 0 },
+    end: { line: 1, column: 1, offset: 0 },
+    source: ""
+  };
+  function createRoot(children, source = "") {
+    return {
+      type: 0,
+      source,
+      children,
+      helpers: /* @__PURE__ */ new Set(),
+      components: [],
+      directives: [],
+      hoists: [],
+      imports: [],
+      cached: [],
+      temps: 0,
+      codegenNode: void 0,
+      loc: locStub
+    };
+  }
+  function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
+    if (context) {
+      if (isBlock) {
+        context.helper(OPEN_BLOCK);
+        context.helper(getVNodeBlockHelper(context.inSSR, isComponent));
       } else {
-        el.classList.remove(cls);
+        context.helper(getVNodeHelper(context.inSSR, isComponent));
       }
-      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');
+      if (directives) {
+        context.helper(WITH_DIRECTIVES);
       }
     }
+    return {
+      type: 13,
+      tag,
+      props,
+      children,
+      patchFlag,
+      dynamicProps,
+      directives,
+      isBlock,
+      disableTracking,
+      isComponent,
+      loc
+    };
   }
-
-  /*  */
-
-  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)
-    }
+  function createArrayExpression(elements, loc = locStub) {
+    return {
+      type: 17,
+      loc,
+      elements
+    };
   }
-
-  var autoCssTransition = cached(function (name) {
+  function createObjectExpression(properties, loc = locStub) {
     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';
-    }
+      type: 15,
+      loc,
+      properties
+    };
   }
-
-  // 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 createObjectProperty(key, value) {
+    return {
+      type: 16,
+      loc: locStub,
+      key: isString(key) ? createSimpleExpression(key, true) : key,
+      value
+    };
   }
-
-  function addTransitionClass (el, cls) {
-    var transitionClasses = el._transitionClasses || (el._transitionClasses = []);
-    if (transitionClasses.indexOf(cls) < 0) {
-      transitionClasses.push(cls);
-      addClass(el, cls);
-    }
+  function createSimpleExpression(content, isStatic = false, loc = locStub, constType = 0) {
+    return {
+      type: 4,
+      loc,
+      content,
+      isStatic,
+      constType: isStatic ? 3 : constType
+    };
   }
-
-  function removeTransitionClass (el, cls) {
-    if (el._transitionClasses) {
-      remove(el._transitionClasses, cls);
-    }
-    removeClass(el, cls);
+  function createCompoundExpression(children, loc = locStub) {
+    return {
+      type: 8,
+      loc,
+      children
+    };
   }
-
-  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();
+  function createCallExpression(callee, args = [], loc = locStub) {
+    return {
+      type: 14,
+      loc,
+      callee,
+      arguments: args
     };
-    var onEnd = function (e) {
-      if (e.target === el) {
-        if (++ended >= propCount) {
-          end();
-        }
-      }
+  }
+  function createFunctionExpression(params, returns = void 0, newline = false, isSlot = false, loc = locStub) {
+    return {
+      type: 18,
+      params,
+      returns,
+      newline,
+      isSlot,
+      loc
     };
-    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']);
+  }
+  function createConditionalExpression(test, consequent, alternate, newline = true) {
     return {
-      type: type,
-      timeout: timeout,
-      propCount: propCount,
-      hasTransform: hasTransform
-    }
+      type: 19,
+      test,
+      consequent,
+      alternate,
+      newline,
+      loc: locStub
+    };
   }
-
-  function getTimeout (delays, durations) {
-    /* istanbul ignore next */
-    while (delays.length < durations.length) {
-      delays = delays.concat(delays);
+  function createCacheExpression(index, value, needPauseTracking = false, inVOnce = false) {
+    return {
+      type: 20,
+      index,
+      value,
+      needPauseTracking,
+      inVOnce,
+      needArraySpread: false,
+      loc: locStub
+    };
+  }
+  function createBlockStatement(body) {
+    return {
+      type: 21,
+      body,
+      loc: locStub
+    };
+  }
+  function getVNodeHelper(ssr, isComponent) {
+    return ssr || isComponent ? CREATE_VNODE : CREATE_ELEMENT_VNODE;
+  }
+  function getVNodeBlockHelper(ssr, isComponent) {
+    return ssr || isComponent ? CREATE_BLOCK : CREATE_ELEMENT_BLOCK;
+  }
+  function convertToBlock(node, { helper, removeHelper, inSSR }) {
+    if (!node.isBlock) {
+      node.isBlock = true;
+      removeHelper(getVNodeHelper(inSSR, node.isComponent));
+      helper(OPEN_BLOCK);
+      helper(getVNodeBlockHelper(inSSR, node.isComponent));
+    }
+  }
+
+  const defaultDelimitersOpen = new Uint8Array([123, 123]);
+  const defaultDelimitersClose = new Uint8Array([125, 125]);
+  function isTagStartChar(c) {
+    return c >= 97 && c <= 122 || c >= 65 && c <= 90;
+  }
+  function isWhitespace(c) {
+    return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
+  }
+  function isEndOfTagSection(c) {
+    return c === 47 || c === 62 || isWhitespace(c);
+  }
+  function toCharCodes(str) {
+    const ret = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+      ret[i] = str.charCodeAt(i);
+    }
+    return ret;
+  }
+  const Sequences = {
+    Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
+    // CDATA[
+    CdataEnd: new Uint8Array([93, 93, 62]),
+    // ]]>
+    CommentEnd: new Uint8Array([45, 45, 62]),
+    // `-->`
+    ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
+    // `<\/script`
+    StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
+    // `</style`
+    TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
+    // `</title`
+    TextareaEnd: new Uint8Array([
+      60,
+      47,
+      116,
+      101,
+      120,
+      116,
+      97,
+      114,
+      101,
+      97
+    ])
+    // `</textarea
+  };
+  class Tokenizer {
+    constructor(stack, cbs) {
+      this.stack = stack;
+      this.cbs = cbs;
+      /** The current state the tokenizer is in. */
+      this.state = 1;
+      /** The read buffer. */
+      this.buffer = "";
+      /** The beginning of the section that is currently being read. */
+      this.sectionStart = 0;
+      /** The index within the buffer that we are currently looking at. */
+      this.index = 0;
+      /** The start of the last entity. */
+      this.entityStart = 0;
+      /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
+      this.baseState = 1;
+      /** For special parsing behavior inside of script and style tags. */
+      this.inRCDATA = false;
+      /** For disabling RCDATA tags handling */
+      this.inXML = false;
+      /** For disabling interpolation parsing in v-pre */
+      this.inVPre = false;
+      /** Record newline positions for fast line / column calculation */
+      this.newlines = [];
+      this.mode = 0;
+      this.delimiterOpen = defaultDelimitersOpen;
+      this.delimiterClose = defaultDelimitersClose;
+      this.delimiterIndex = -1;
+      this.currentSequence = void 0;
+      this.sequenceIndex = 0;
+    }
+    get inSFCRoot() {
+      return this.mode === 2 && this.stack.length === 0;
+    }
+    reset() {
+      this.state = 1;
+      this.mode = 0;
+      this.buffer = "";
+      this.sectionStart = 0;
+      this.index = 0;
+      this.baseState = 1;
+      this.inRCDATA = false;
+      this.currentSequence = void 0;
+      this.newlines.length = 0;
+      this.delimiterOpen = defaultDelimitersOpen;
+      this.delimiterClose = defaultDelimitersClose;
     }
-
-    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);
+    /**
+     * Generate Position object with line / column information using recorded
+     * newline positions. We know the index is always going to be an already
+     * processed index, so all the newlines up to this index should have been
+     * recorded.
+     */
+    getPos(index) {
+      let line = 1;
+      let column = index + 1;
+      for (let i = this.newlines.length - 1; i >= 0; i--) {
+        const newlineIndex = this.newlines[i];
+        if (index > newlineIndex) {
+          line = i + 2;
+          column = index - newlineIndex;
+          break;
+        }
+      }
+      return {
+        column,
+        line,
+        offset: index
+      };
     }
-
-    var expectsCSS = css !== false && !isIE9;
-    var userWantsControl = getHookArgumentsLength(enterHook);
-
-    var cb = el._enterCb = once(function () {
-      if (expectsCSS) {
-        removeTransitionClass(el, toClass);
-        removeTransitionClass(el, activeClass);
+    peek() {
+      return this.buffer.charCodeAt(this.index + 1);
+    }
+    stateText(c) {
+      if (c === 60) {
+        if (this.index > this.sectionStart) {
+          this.cbs.ontext(this.sectionStart, this.index);
+        }
+        this.state = 5;
+        this.sectionStart = this.index;
+      } else if (!this.inVPre && c === this.delimiterOpen[0]) {
+        this.state = 2;
+        this.delimiterIndex = 0;
+        this.stateInterpolationOpen(c);
+      }
+    }
+    stateInterpolationOpen(c) {
+      if (c === this.delimiterOpen[this.delimiterIndex]) {
+        if (this.delimiterIndex === this.delimiterOpen.length - 1) {
+          const start = this.index + 1 - this.delimiterOpen.length;
+          if (start > this.sectionStart) {
+            this.cbs.ontext(this.sectionStart, start);
+          }
+          this.state = 3;
+          this.sectionStart = start;
+        } else {
+          this.delimiterIndex++;
+        }
+      } else if (this.inRCDATA) {
+        this.state = 32;
+        this.stateInRCDATA(c);
+      } else {
+        this.state = 1;
+        this.stateText(c);
+      }
+    }
+    stateInterpolation(c) {
+      if (c === this.delimiterClose[0]) {
+        this.state = 4;
+        this.delimiterIndex = 0;
+        this.stateInterpolationClose(c);
+      }
+    }
+    stateInterpolationClose(c) {
+      if (c === this.delimiterClose[this.delimiterIndex]) {
+        if (this.delimiterIndex === this.delimiterClose.length - 1) {
+          this.cbs.oninterpolation(this.sectionStart, this.index + 1);
+          if (this.inRCDATA) {
+            this.state = 32;
+          } else {
+            this.state = 1;
+          }
+          this.sectionStart = this.index + 1;
+        } else {
+          this.delimiterIndex++;
+        }
+      } else {
+        this.state = 3;
+        this.stateInterpolation(c);
+      }
+    }
+    stateSpecialStartSequence(c) {
+      const isEnd = this.sequenceIndex === this.currentSequence.length;
+      const isMatch = isEnd ? (
+        // If we are at the end of the sequence, make sure the tag name has ended
+        isEndOfTagSection(c)
+      ) : (
+        // Otherwise, do a case-insensitive comparison
+        (c | 32) === this.currentSequence[this.sequenceIndex]
+      );
+      if (!isMatch) {
+        this.inRCDATA = false;
+      } else if (!isEnd) {
+        this.sequenceIndex++;
+        return;
+      }
+      this.sequenceIndex = 0;
+      this.state = 6;
+      this.stateInTagName(c);
+    }
+    /** Look for an end tag. For <title> and <textarea>, also decode entities. */
+    stateInRCDATA(c) {
+      if (this.sequenceIndex === this.currentSequence.length) {
+        if (c === 62 || isWhitespace(c)) {
+          const endOfText = this.index - this.currentSequence.length;
+          if (this.sectionStart < endOfText) {
+            const actualIndex = this.index;
+            this.index = endOfText;
+            this.cbs.ontext(this.sectionStart, endOfText);
+            this.index = actualIndex;
+          }
+          this.sectionStart = endOfText + 2;
+          this.stateInClosingTagName(c);
+          this.inRCDATA = false;
+          return;
+        }
+        this.sequenceIndex = 0;
+      }
+      if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
+        this.sequenceIndex += 1;
+      } else if (this.sequenceIndex === 0) {
+        if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
+          if (!this.inVPre && c === this.delimiterOpen[0]) {
+            this.state = 2;
+            this.delimiterIndex = 0;
+            this.stateInterpolationOpen(c);
+          }
+        } else if (this.fastForwardTo(60)) {
+          this.sequenceIndex = 1;
+        }
+      } else {
+        this.sequenceIndex = Number(c === 60);
       }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, startClass);
+    }
+    stateCDATASequence(c) {
+      if (c === Sequences.Cdata[this.sequenceIndex]) {
+        if (++this.sequenceIndex === Sequences.Cdata.length) {
+          this.state = 28;
+          this.currentSequence = Sequences.CdataEnd;
+          this.sequenceIndex = 0;
+          this.sectionStart = this.index + 1;
         }
-        enterCancelledHook && enterCancelledHook(el);
       } else {
-        afterEnterHook && afterEnterHook(el);
+        this.sequenceIndex = 0;
+        this.state = 23;
+        this.stateInDeclaration(c);
       }
-      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();
+    }
+    /**
+     * When we wait for one specific character, we can speed things up
+     * by skipping through the buffer until we find it.
+     *
+     * @returns Whether the character was found.
+     */
+    fastForwardTo(c) {
+      while (++this.index < this.buffer.length) {
+        const cc = this.buffer.charCodeAt(this.index);
+        if (cc === 10) {
+          this.newlines.push(this.index);
+        }
+        if (cc === c) {
+          return true;
         }
-        enterHook && enterHook(el, cb);
-      });
+      }
+      this.index = this.buffer.length - 1;
+      return false;
     }
-
-    // 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);
-            }
+    /**
+     * Comments and CDATA end with `-->` and `]]>`.
+     *
+     * Their common qualities are:
+     * - Their end sequences have a distinct character they start with.
+     * - That character is then repeated, so we have to check multiple repeats.
+     * - All characters but the start character of the sequence can be skipped.
+     */
+    stateInCommentLike(c) {
+      if (c === this.currentSequence[this.sequenceIndex]) {
+        if (++this.sequenceIndex === this.currentSequence.length) {
+          if (this.currentSequence === Sequences.CdataEnd) {
+            this.cbs.oncdata(this.sectionStart, this.index - 2);
+          } else {
+            this.cbs.oncomment(this.sectionStart, this.index - 2);
           }
+          this.sequenceIndex = 0;
+          this.sectionStart = this.index + 1;
+          this.state = 1;
         }
-      });
-    }
-
-    if (vnode.data.show) {
-      toggleDisplay && toggleDisplay();
-      enterHook && enterHook(el, cb);
-    }
-
-    if (!expectsCSS && !userWantsControl) {
-      cb();
+      } else if (this.sequenceIndex === 0) {
+        if (this.fastForwardTo(this.currentSequence[0])) {
+          this.sequenceIndex = 1;
+        }
+      } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
+        this.sequenceIndex = 0;
+      }
+    }
+    startSpecial(sequence, offset) {
+      this.enterRCDATA(sequence, offset);
+      this.state = 31;
+    }
+    enterRCDATA(sequence, offset) {
+      this.inRCDATA = true;
+      this.currentSequence = sequence;
+      this.sequenceIndex = offset;
+    }
+    stateBeforeTagName(c) {
+      if (c === 33) {
+        this.state = 22;
+        this.sectionStart = this.index + 1;
+      } else if (c === 63) {
+        this.state = 24;
+        this.sectionStart = this.index + 1;
+      } else if (isTagStartChar(c)) {
+        this.sectionStart = this.index;
+        if (this.mode === 0) {
+          this.state = 6;
+        } else if (this.inSFCRoot) {
+          this.state = 34;
+        } else if (!this.inXML) {
+          if (c === 116) {
+            this.state = 30;
+          } else {
+            this.state = c === 115 ? 29 : 6;
+          }
+        } else {
+          this.state = 6;
+        }
+      } else if (c === 47) {
+        this.state = 8;
+      } else {
+        this.state = 1;
+        this.stateText(c);
+      }
     }
-  }
-
-  function leave (vnode, rm) {
-    var el = vnode.elm;
-
-    // call enter callback now
-    if (isDef(el._enterCb)) {
-      el._enterCb.cancelled = true;
-      el._enterCb();
+    stateInTagName(c) {
+      if (isEndOfTagSection(c)) {
+        this.handleTagName(c);
+      }
     }
-
-    var data = resolveTransition(vnode.data.transition);
-    if (isUndef(data) || el.nodeType !== 1) {
-      return rm()
+    stateInSFCRootTagName(c) {
+      if (isEndOfTagSection(c)) {
+        const tag = this.buffer.slice(this.sectionStart, this.index);
+        if (tag !== "template") {
+          this.enterRCDATA(toCharCodes(`</` + tag), 0);
+        }
+        this.handleTagName(c);
+      }
     }
-
-    /* istanbul ignore if */
-    if (isDef(el._leaveCb)) {
-      return
+    handleTagName(c) {
+      this.cbs.onopentagname(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.state = 11;
+      this.stateBeforeAttrName(c);
     }
-
-    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);
+    stateBeforeClosingTagName(c) {
+      if (isWhitespace(c)) ; else if (c === 62) {
+        {
+          this.cbs.onerr(14, this.index);
+        }
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      } else {
+        this.state = isTagStartChar(c) ? 9 : 27;
+        this.sectionStart = this.index;
+      }
     }
-
-    var cb = el._leaveCb = once(function () {
-      if (el.parentNode && el.parentNode._pending) {
-        el.parentNode._pending[vnode.key] = null;
+    stateInClosingTagName(c) {
+      if (c === 62 || isWhitespace(c)) {
+        this.cbs.onclosetag(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.state = 10;
+        this.stateAfterClosingTagName(c);
       }
-      if (expectsCSS) {
-        removeTransitionClass(el, leaveToClass);
-        removeTransitionClass(el, leaveActiveClass);
+    }
+    stateAfterClosingTagName(c) {
+      if (c === 62) {
+        this.state = 1;
+        this.sectionStart = this.index + 1;
       }
-      if (cb.cancelled) {
-        if (expectsCSS) {
-          removeTransitionClass(el, leaveClass);
+    }
+    stateBeforeAttrName(c) {
+      if (c === 62) {
+        this.cbs.onopentagend(this.index);
+        if (this.inRCDATA) {
+          this.state = 32;
+        } else {
+          this.state = 1;
+        }
+        this.sectionStart = this.index + 1;
+      } else if (c === 47) {
+        this.state = 7;
+        if (this.peek() !== 62) {
+          this.cbs.onerr(22, this.index);
+        }
+      } else if (c === 60 && this.peek() === 47) {
+        this.cbs.onopentagend(this.index);
+        this.state = 5;
+        this.sectionStart = this.index;
+      } else if (!isWhitespace(c)) {
+        if (c === 61) {
+          this.cbs.onerr(
+            19,
+            this.index
+          );
         }
-        leaveCancelled && leaveCancelled(el);
+        this.handleAttrStart(c);
+      }
+    }
+    handleAttrStart(c) {
+      if (c === 118 && this.peek() === 45) {
+        this.state = 13;
+        this.sectionStart = this.index;
+      } else if (c === 46 || c === 58 || c === 64 || c === 35) {
+        this.cbs.ondirname(this.index, this.index + 1);
+        this.state = 14;
+        this.sectionStart = this.index + 1;
       } else {
-        rm();
-        afterLeave && afterLeave(el);
+        this.state = 12;
+        this.sectionStart = this.index;
+      }
+    }
+    stateInSelfClosingTag(c) {
+      if (c === 62) {
+        this.cbs.onselfclosingtag(this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+        this.inRCDATA = false;
+      } else if (!isWhitespace(c)) {
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      }
+    }
+    stateInAttrName(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.onattribname(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 34 || c === 39 || c === 60) {
+        this.cbs.onerr(
+          17,
+          this.index
+        );
       }
-      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);
-              }
-            }
-          }
-        });
+    }
+    stateInDirName(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 58) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.state = 14;
+        this.sectionStart = this.index + 1;
+      } else if (c === 46) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.state = 16;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateInDirArg(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirarg(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 91) {
+        this.state = 15;
+      } else if (c === 46) {
+        this.cbs.ondirarg(this.sectionStart, this.index);
+        this.state = 16;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateInDynamicDirArg(c) {
+      if (c === 93) {
+        this.state = 14;
+      } else if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirarg(this.sectionStart, this.index + 1);
+        this.handleAttrNameEnd(c);
+        {
+          this.cbs.onerr(
+            27,
+            this.index
+          );
+        }
       }
-      leave && leave(el, cb);
-      if (!expectsCSS && !userWantsControl) {
-        cb();
+    }
+    stateInDirModifier(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirmodifier(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 46) {
+        this.cbs.ondirmodifier(this.sectionStart, this.index);
+        this.sectionStart = this.index + 1;
+      }
+    }
+    handleAttrNameEnd(c) {
+      this.sectionStart = this.index;
+      this.state = 17;
+      this.cbs.onattribnameend(this.index);
+      this.stateAfterAttrName(c);
+    }
+    stateAfterAttrName(c) {
+      if (c === 61) {
+        this.state = 18;
+      } else if (c === 47 || c === 62) {
+        this.cbs.onattribend(0, this.sectionStart);
+        this.sectionStart = -1;
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      } else if (!isWhitespace(c)) {
+        this.cbs.onattribend(0, this.sectionStart);
+        this.handleAttrStart(c);
+      }
+    }
+    stateBeforeAttrValue(c) {
+      if (c === 34) {
+        this.state = 19;
+        this.sectionStart = this.index + 1;
+      } else if (c === 39) {
+        this.state = 20;
+        this.sectionStart = this.index + 1;
+      } else if (!isWhitespace(c)) {
+        this.sectionStart = this.index;
+        this.state = 21;
+        this.stateInAttrValueNoQuotes(c);
+      }
+    }
+    handleInAttrValue(c, quote) {
+      if (c === quote || this.fastForwardTo(quote)) {
+        this.cbs.onattribdata(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.cbs.onattribend(
+          quote === 34 ? 3 : 2,
+          this.index + 1
+        );
+        this.state = 11;
+      }
+    }
+    stateInAttrValueDoubleQuotes(c) {
+      this.handleInAttrValue(c, 34);
+    }
+    stateInAttrValueSingleQuotes(c) {
+      this.handleInAttrValue(c, 39);
+    }
+    stateInAttrValueNoQuotes(c) {
+      if (isWhitespace(c) || c === 62) {
+        this.cbs.onattribdata(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.cbs.onattribend(1, this.index);
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {
+        this.cbs.onerr(
+          18,
+          this.index
+        );
+      } else ;
+    }
+    stateBeforeDeclaration(c) {
+      if (c === 91) {
+        this.state = 26;
+        this.sequenceIndex = 0;
+      } else {
+        this.state = c === 45 ? 25 : 23;
       }
     }
-  }
-
-  // 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
-      );
+    stateInDeclaration(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
     }
-  }
-
-  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
+    stateInProcessingInstruction(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.cbs.onprocessinginstruction(this.sectionStart, this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
     }
-    var invokerFns = fn.fns;
-    if (isDef(invokerFns)) {
-      // invoker
-      return getHookArgumentsLength(
-        Array.isArray(invokerFns)
-          ? invokerFns[0]
-          : invokerFns
-      )
-    } else {
-      return (fn._length || fn.length) > 1
+    stateBeforeComment(c) {
+      if (c === 45) {
+        this.state = 28;
+        this.currentSequence = Sequences.CommentEnd;
+        this.sequenceIndex = 2;
+        this.sectionStart = this.index + 1;
+      } else {
+        this.state = 23;
+      }
     }
-  }
-
-  function _enter (_, vnode) {
-    if (vnode.data.show !== true) {
-      enter(vnode);
+    stateInSpecialComment(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.cbs.oncomment(this.sectionStart, this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
     }
-  }
-
-  var transition = inBrowser ? {
-    create: _enter,
-    activate: _enter,
-    remove: function remove$$1 (vnode, rm) {
-      /* istanbul ignore else */
-      if (vnode.data.show !== true) {
-        leave(vnode, rm);
+    stateBeforeSpecialS(c) {
+      if (c === Sequences.ScriptEnd[3]) {
+        this.startSpecial(Sequences.ScriptEnd, 4);
+      } else if (c === Sequences.StyleEnd[3]) {
+        this.startSpecial(Sequences.StyleEnd, 4);
       } else {
-        rm();
+        this.state = 6;
+        this.stateInTagName(c);
       }
     }
-  } : {};
-
-  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;
-      if (el && el.vmodel) {
-        trigger(el, 'input');
+    stateBeforeSpecialT(c) {
+      if (c === Sequences.TitleEnd[3]) {
+        this.startSpecial(Sequences.TitleEnd, 4);
+      } else if (c === Sequences.TextareaEnd[3]) {
+        this.startSpecial(Sequences.TextareaEnd, 4);
+      } else {
+        this.state = 6;
+        this.stateInTagName(c);
       }
-    });
-  }
-
-  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);
+    }
+    startEntity() {
+    }
+    stateInEntity() {
+    }
+    /**
+     * Iterates through the buffer, calling the function corresponding to the current state.
+     *
+     * States that are more likely to be hit are higher up, as a performance improvement.
+     */
+    parse(input) {
+      this.buffer = input;
+      while (this.index < this.buffer.length) {
+        const c = this.buffer.charCodeAt(this.index);
+        if (c === 10 && this.state !== 33) {
+          this.newlines.push(this.index);
         }
-        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;
+        switch (this.state) {
+          case 1: {
+            this.stateText(c);
+            break;
           }
-        }
-      }
-    },
-
-    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');
+          case 2: {
+            this.stateInterpolationOpen(c);
+            break;
+          }
+          case 3: {
+            this.stateInterpolation(c);
+            break;
+          }
+          case 4: {
+            this.stateInterpolationClose(c);
+            break;
+          }
+          case 31: {
+            this.stateSpecialStartSequence(c);
+            break;
+          }
+          case 32: {
+            this.stateInRCDATA(c);
+            break;
+          }
+          case 26: {
+            this.stateCDATASequence(c);
+            break;
+          }
+          case 19: {
+            this.stateInAttrValueDoubleQuotes(c);
+            break;
+          }
+          case 12: {
+            this.stateInAttrName(c);
+            break;
+          }
+          case 13: {
+            this.stateInDirName(c);
+            break;
+          }
+          case 14: {
+            this.stateInDirArg(c);
+            break;
+          }
+          case 15: {
+            this.stateInDynamicDirArg(c);
+            break;
+          }
+          case 16: {
+            this.stateInDirModifier(c);
+            break;
+          }
+          case 28: {
+            this.stateInCommentLike(c);
+            break;
+          }
+          case 27: {
+            this.stateInSpecialComment(c);
+            break;
+          }
+          case 11: {
+            this.stateBeforeAttrName(c);
+            break;
+          }
+          case 6: {
+            this.stateInTagName(c);
+            break;
+          }
+          case 34: {
+            this.stateInSFCRootTagName(c);
+            break;
+          }
+          case 9: {
+            this.stateInClosingTagName(c);
+            break;
+          }
+          case 5: {
+            this.stateBeforeTagName(c);
+            break;
+          }
+          case 17: {
+            this.stateAfterAttrName(c);
+            break;
+          }
+          case 20: {
+            this.stateInAttrValueSingleQuotes(c);
+            break;
+          }
+          case 18: {
+            this.stateBeforeAttrValue(c);
+            break;
+          }
+          case 8: {
+            this.stateBeforeClosingTagName(c);
+            break;
+          }
+          case 10: {
+            this.stateAfterClosingTagName(c);
+            break;
+          }
+          case 29: {
+            this.stateBeforeSpecialS(c);
+            break;
+          }
+          case 30: {
+            this.stateBeforeSpecialT(c);
+            break;
+          }
+          case 21: {
+            this.stateInAttrValueNoQuotes(c);
+            break;
+          }
+          case 7: {
+            this.stateInSelfClosingTag(c);
+            break;
+          }
+          case 23: {
+            this.stateInDeclaration(c);
+            break;
+          }
+          case 22: {
+            this.stateBeforeDeclaration(c);
+            break;
+          }
+          case 25: {
+            this.stateBeforeComment(c);
+            break;
+          }
+          case 24: {
+            this.stateInProcessingInstruction(c);
+            break;
+          }
+          case 33: {
+            this.stateInEntity();
+            break;
           }
         }
+        this.index++;
       }
+      this.cleanup();
+      this.finish();
     }
-  };
-
-  function setSelected (el, binding, vm) {
-    actuallySetSelected(el, binding, vm);
-    /* istanbul ignore if */
-    if (isIE || isEdge) {
-      setTimeout(function () {
-        actuallySetSelected(el, binding, vm);
-      }, 0);
+    /**
+     * Remove data that has already been consumed from the buffer.
+     */
+    cleanup() {
+      if (this.sectionStart !== this.index) {
+        if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
+          this.cbs.ontext(this.sectionStart, this.index);
+          this.sectionStart = this.index;
+        } else if (this.state === 19 || this.state === 20 || this.state === 21) {
+          this.cbs.onattribdata(this.sectionStart, this.index);
+          this.sectionStart = this.index;
+        }
+      }
     }
-  }
-
-  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
+    finish() {
+      this.handleTrailingData();
+      this.cbs.onend();
     }
-    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;
+    /** Handle any trailing data. */
+    handleTrailingData() {
+      const endIndex = this.buffer.length;
+      if (this.sectionStart >= endIndex) {
+        return;
+      }
+      if (this.state === 28) {
+        if (this.currentSequence === Sequences.CdataEnd) {
+          this.cbs.oncdata(this.sectionStart, endIndex);
+        } else {
+          this.cbs.oncomment(this.sectionStart, endIndex);
         }
-      } else {
-        if (looseEqual(getValue(option), value)) {
-          if (el.selectedIndex !== i) {
-            el.selectedIndex = i;
+      } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {
+        this.cbs.ontext(this.sectionStart, endIndex);
+      }
+    }
+    emitCodePoint(cp, consumed) {
+    }
+  }
+
+  function defaultOnError(error) {
+    throw error;
+  }
+  function defaultOnWarn(msg) {
+    console.warn(`[Vue warn] ${msg.message}`);
+  }
+  function createCompilerError(code, loc, messages, additionalMessage) {
+    const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    error.loc = loc;
+    return error;
+  }
+  const errorMessages = {
+    // parse errors
+    [0]: "Illegal comment.",
+    [1]: "CDATA section is allowed only in XML context.",
+    [2]: "Duplicate attribute.",
+    [3]: "End tag cannot have attributes.",
+    [4]: "Illegal '/' in tags.",
+    [5]: "Unexpected EOF in tag.",
+    [6]: "Unexpected EOF in CDATA section.",
+    [7]: "Unexpected EOF in comment.",
+    [8]: "Unexpected EOF in script.",
+    [9]: "Unexpected EOF in tag.",
+    [10]: "Incorrectly closed comment.",
+    [11]: "Incorrectly opened comment.",
+    [12]: "Illegal tag name. Use '&lt;' to print '<'.",
+    [13]: "Attribute value was expected.",
+    [14]: "End tag name was expected.",
+    [15]: "Whitespace was expected.",
+    [16]: "Unexpected '<!--' in comment.",
+    [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
+    [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
+    [19]: "Attribute name cannot start with '='.",
+    [21]: "'<?' is allowed only in XML context.",
+    [20]: `Unexpected null character.`,
+    [22]: "Illegal '/' in tags.",
+    // Vue-specific parse errors
+    [23]: "Invalid end tag.",
+    [24]: "Element is missing end tag.",
+    [25]: "Interpolation end sign was not found.",
+    [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
+    [26]: "Legal directive name was expected.",
+    // transform errors
+    [28]: `v-if/v-else-if is missing expression.`,
+    [29]: `v-if/else branches must use unique keys.`,
+    [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+    [31]: `v-for is missing expression.`,
+    [32]: `v-for has invalid expression.`,
+    [33]: `<template v-for> key should be placed on the <template> tag.`,
+    [34]: `v-bind is missing expression.`,
+    [52]: `v-bind with same-name shorthand only allows static argument.`,
+    [35]: `v-on is missing expression.`,
+    [36]: `Unexpected custom directive on <slot> outlet.`,
+    [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
+    [38]: `Duplicate slot names found. `,
+    [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
+    [40]: `v-slot can only be used on components or <template> tags.`,
+    [41]: `v-model is missing expression.`,
+    [42]: `v-model value must be a valid JavaScript member expression.`,
+    [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+    [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+    [45]: `Error parsing JavaScript expression: `,
+    [46]: `<KeepAlive> expects exactly one child component.`,
+    [51]: `@vnode-* hooks in templates are no longer supported. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support has been removed in 3.4.`,
+    // generic errors
+    [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+    [48]: `ES module mode is not supported in this build of compiler.`,
+    [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+    [50]: `"scopeId" option is only supported in module mode.`,
+    // just to fulfill types
+    [53]: ``
+  };
+
+  const isStaticExp = (p) => p.type === 4 && p.isStatic;
+  function isCoreComponent(tag) {
+    switch (tag) {
+      case "Teleport":
+      case "teleport":
+        return TELEPORT;
+      case "Suspense":
+      case "suspense":
+        return SUSPENSE;
+      case "KeepAlive":
+      case "keep-alive":
+        return KEEP_ALIVE;
+      case "BaseTransition":
+      case "base-transition":
+        return BASE_TRANSITION;
+    }
+  }
+  const nonIdentifierRE = /^\d|[^\$\w\xA0-\uFFFF]/;
+  const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+  const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
+  const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
+  const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
+  const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
+  const isMemberExpressionBrowser = (exp) => {
+    const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
+    let state = 0 /* inMemberExp */;
+    let stateStack = [];
+    let currentOpenBracketCount = 0;
+    let currentOpenParensCount = 0;
+    let currentStringType = null;
+    for (let i = 0; i < path.length; i++) {
+      const char = path.charAt(i);
+      switch (state) {
+        case 0 /* inMemberExp */:
+          if (char === "[") {
+            stateStack.push(state);
+            state = 1 /* inBrackets */;
+            currentOpenBracketCount++;
+          } else if (char === "(") {
+            stateStack.push(state);
+            state = 2 /* inParens */;
+            currentOpenParensCount++;
+          } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
+            return false;
           }
-          return
-        }
+          break;
+        case 1 /* inBrackets */:
+          if (char === `'` || char === `"` || char === "`") {
+            stateStack.push(state);
+            state = 3 /* inString */;
+            currentStringType = char;
+          } else if (char === `[`) {
+            currentOpenBracketCount++;
+          } else if (char === `]`) {
+            if (!--currentOpenBracketCount) {
+              state = stateStack.pop();
+            }
+          }
+          break;
+        case 2 /* inParens */:
+          if (char === `'` || char === `"` || char === "`") {
+            stateStack.push(state);
+            state = 3 /* inString */;
+            currentStringType = char;
+          } else if (char === `(`) {
+            currentOpenParensCount++;
+          } else if (char === `)`) {
+            if (i === path.length - 1) {
+              return false;
+            }
+            if (!--currentOpenParensCount) {
+              state = stateStack.pop();
+            }
+          }
+          break;
+        case 3 /* inString */:
+          if (char === currentStringType) {
+            state = stateStack.pop();
+            currentStringType = null;
+          }
+          break;
       }
     }
-    if (!isMultiple) {
-      el.selectedIndex = -1;
+    return !currentOpenBracketCount && !currentOpenParensCount;
+  };
+  const isMemberExpression = isMemberExpressionBrowser ;
+  const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+  const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
+  const isFnExpression = isFnExpressionBrowser ;
+  function assert(condition, msg) {
+    if (!condition) {
+      throw new Error(msg || `unexpected compiler condition`);
+    }
+  }
+  function findDir(node, name, allowEmpty = false) {
+    for (let i = 0; i < node.props.length; i++) {
+      const p = node.props[i];
+      if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
+        return p;
+      }
+    }
+  }
+  function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
+    for (let i = 0; i < node.props.length; i++) {
+      const p = node.props[i];
+      if (p.type === 6) {
+        if (dynamicOnly) continue;
+        if (p.name === name && (p.value || allowEmpty)) {
+          return p;
+        }
+      } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
+        return p;
+      }
     }
   }
-
-  function hasNoMatchingOption (value, options) {
-    return options.every(function (o) { return !looseEqual(o, value); })
+  function isStaticArgOf(arg, name) {
+    return !!(arg && isStaticExp(arg) && arg.content === name);
   }
-
-  function getValue (option) {
-    return '_value' in option
-      ? option._value
-      : option.value
+  function hasDynamicKeyVBind(node) {
+    return node.props.some(
+      (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
+      p.arg.type !== 4 || // v-bind:[_ctx.foo]
+      !p.arg.isStatic)
+      // v-bind:[foo]
+    );
   }
-
-  function onCompositionStart (e) {
-    e.target.composing = true;
+  function isText$1(node) {
+    return node.type === 5 || node.type === 2;
   }
-
-  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 isVSlot(p) {
+    return p.type === 7 && p.name === "slot";
   }
-
-  function trigger (el, type) {
-    var e = document.createEvent('HTMLEvents');
-    e.initEvent(type, true, true);
-    el.dispatchEvent(e);
+  function isTemplateNode(node) {
+    return node.type === 1 && node.tagType === 3;
   }
-
-  /*  */
-
-  // 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 isSlotOutlet(node) {
+    return node.type === 1 && node.tagType === 2;
   }
-
-  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';
+  const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+  function getUnnormalizedProps(props, callPath = []) {
+    if (props && !isString(props) && props.type === 14) {
+      const callee = props.callee;
+      if (!isString(callee) && propsHelperSet.has(callee)) {
+        return getUnnormalizedProps(
+          props.arguments[0],
+          callPath.concat(props)
+        );
       }
-    },
-
-    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';
-          });
+    }
+    return [props, callPath];
+  }
+  function injectProp(node, prop, context) {
+    let propsWithInjection;
+    let props = node.type === 13 ? node.props : node.arguments[2];
+    let callPath = [];
+    let parentCall;
+    if (props && !isString(props) && props.type === 14) {
+      const ret = getUnnormalizedProps(props);
+      props = ret[0];
+      callPath = ret[1];
+      parentCall = callPath[callPath.length - 1];
+    }
+    if (props == null || isString(props)) {
+      propsWithInjection = createObjectExpression([prop]);
+    } else if (props.type === 14) {
+      const first = props.arguments[0];
+      if (!isString(first) && first.type === 15) {
+        if (!hasProp(prop, first)) {
+          first.properties.unshift(prop);
         }
       } else {
-        el.style.display = value ? el.__vOriginalDisplay : 'none';
+        if (props.callee === TO_HANDLERS) {
+          propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+            createObjectExpression([prop]),
+            props
+          ]);
+        } else {
+          props.arguments.unshift(createObjectExpression([prop]));
+        }
       }
-    },
-
-    unbind: function unbind (
-      el,
-      binding,
-      vnode,
-      oldVnode,
-      isDestroy
-    ) {
-      if (!isDestroy) {
-        el.style.display = el.__vOriginalDisplay;
+      !propsWithInjection && (propsWithInjection = props);
+    } else if (props.type === 15) {
+      if (!hasProp(prop, props)) {
+        props.properties.unshift(prop);
       }
-    }
-  };
-
-  var platformDirectives = {
-    model: directive,
-    show: show
-  };
-
-  /*  */
-
-  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))
+      propsWithInjection = props;
     } 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];
+      propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+        createObjectExpression([prop]),
+        props
+      ]);
+      if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
+        parentCall = callPath[callPath.length - 2];
+      }
     }
-    return data
-  }
-
-  function placeholder (h, rawChild) {
-    if (/\d-keep-alive$/.test(rawChild.tag)) {
-      return h('keep-alive', {
-        props: rawChild.componentOptions.propsData
-      })
+    if (node.type === 13) {
+      if (parentCall) {
+        parentCall.arguments[0] = propsWithInjection;
+      } else {
+        node.props = propsWithInjection;
+      }
+    } else {
+      if (parentCall) {
+        parentCall.arguments[0] = propsWithInjection;
+      } else {
+        node.arguments[2] = propsWithInjection;
+      }
     }
   }
-
-  function hasParentTransition (vnode) {
-    while ((vnode = vnode.parent)) {
-      if (vnode.data.transition) {
-        return true
-      }
+  function hasProp(prop, props) {
+    let result = false;
+    if (prop.key.type === 4) {
+      const propKeyName = prop.key.content;
+      result = props.properties.some(
+        (p) => p.key.type === 4 && p.key.content === propKeyName
+      );
     }
+    return result;
   }
-
-  function isSameChild (child, oldChild) {
-    return oldChild.key === child.key && oldChild.tag === child.tag
+  function toValidAssetId(name, type) {
+    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+  })}`;
   }
-
-  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
+  function getMemoedVNodeCall(node) {
+    if (node.type === 14 && node.callee === WITH_MEMO) {
+      return node.arguments[1].returns;
+    } else {
+      return node;
+    }
+  }
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
+
+  const defaultParserOptions = {
+    parseMode: "base",
+    ns: 0,
+    delimiters: [`{{`, `}}`],
+    getNamespace: () => 0,
+    isVoidTag: NO,
+    isPreTag: NO,
+    isIgnoreNewlineTag: NO,
+    isCustomElement: NO,
+    onError: defaultOnError,
+    onWarn: defaultOnWarn,
+    comments: true,
+    prefixIdentifiers: false
+  };
+  let currentOptions = defaultParserOptions;
+  let currentRoot = null;
+  let currentInput = "";
+  let currentOpenTag = null;
+  let currentProp = null;
+  let currentAttrValue = "";
+  let currentAttrStartIndex = -1;
+  let currentAttrEndIndex = -1;
+  let inPre = 0;
+  let inVPre = false;
+  let currentVPreBoundary = null;
+  const stack = [];
+  const tokenizer = new Tokenizer(stack, {
+    onerr: emitError,
+    ontext(start, end) {
+      onText(getSlice(start, end), start, end);
+    },
+    ontextentity(char, start, end) {
+      onText(char, start, end);
+    },
+    oninterpolation(start, end) {
+      if (inVPre) {
+        return onText(getSlice(start, end), start, end);
       }
-
-      // 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
+      let innerStart = start + tokenizer.delimiterOpen.length;
+      let innerEnd = end - tokenizer.delimiterClose.length;
+      while (isWhitespace(currentInput.charCodeAt(innerStart))) {
+        innerStart++;
       }
-
-      if (this._leaving) {
-        return placeholder(h, rawChild)
+      while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
+        innerEnd--;
       }
-
-      // 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;
+      let exp = getSlice(innerStart, innerEnd);
+      if (exp.includes("&")) {
+        {
+          exp = currentOptions.decodeEntities(exp, false);
+        }
       }
-
-      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
+      addNode({
+        type: 5,
+        content: createExp(exp, false, getLoc(innerStart, innerEnd)),
+        loc: getLoc(start, end)
+      });
+    },
+    onopentagname(start, end) {
+      const name = getSlice(start, end);
+      currentOpenTag = {
+        type: 1,
+        tag: name,
+        ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
+        tagType: 0,
+        // will be refined on tag close
+        props: [],
+        children: [],
+        loc: getLoc(start - 1, end),
+        codegenNode: void 0
+      };
+    },
+    onopentagend(end) {
+      endOpenTag(end);
+    },
+    onclosetag(start, end) {
+      const name = getSlice(start, end);
+      if (!currentOptions.isVoidTag(name)) {
+        let found = false;
+        for (let i = 0; i < stack.length; i++) {
+          const e = stack[i];
+          if (e.tag.toLowerCase() === name.toLowerCase()) {
+            found = true;
+            if (i > 0) {
+              emitError(24, stack[0].loc.start.offset);
+            }
+            for (let j = 0; j <= i; j++) {
+              const el = stack.shift();
+              onCloseTag(el, end, j < i);
+            }
+            break;
           }
-          var delayedLeave;
-          var performLeave = function () { delayedLeave(); };
-          mergeVNodeHook(data, 'afterEnter', performLeave);
-          mergeVNodeHook(data, 'enterCancelled', performLeave);
-          mergeVNodeHook(oldData, 'delayLeave', function (leave) { delayedLeave = leave; });
+        }
+        if (!found) {
+          emitError(23, backTrack(start, 60));
         }
       }
-
-      return rawChild
-    }
-  };
-
-  /*  */
-
-  var props = extend({
-    tag: String,
-    moveClass: String
-  }, transitionProps);
-
-  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);
+    },
+    onselfclosingtag(end) {
+      const name = currentOpenTag.tag;
+      currentOpenTag.isSelfClosing = true;
+      endOpenTag(end);
+      if (stack[0] && stack[0].tag === name) {
+        onCloseTag(stack.shift(), end);
+      }
+    },
+    onattribname(start, end) {
+      currentProp = {
+        type: 6,
+        name: getSlice(start, end),
+        nameLoc: getLoc(start, end),
+        value: void 0,
+        loc: getLoc(start)
       };
     },
-
-    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 + ">"));
+    ondirname(start, end) {
+      const raw = getSlice(start, end);
+      const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
+      if (!inVPre && name === "") {
+        emitError(26, start);
+      }
+      if (inVPre || name === "") {
+        currentProp = {
+          type: 6,
+          name: raw,
+          nameLoc: getLoc(start, end),
+          value: void 0,
+          loc: getLoc(start)
+        };
+      } else {
+        currentProp = {
+          type: 7,
+          name,
+          rawName: raw,
+          exp: void 0,
+          arg: void 0,
+          modifiers: raw === "." ? [createSimpleExpression("prop")] : [],
+          loc: getLoc(start)
+        };
+        if (name === "pre") {
+          inVPre = tokenizer.inVPre = true;
+          currentVPreBoundary = currentOpenTag;
+          const props = currentOpenTag.props;
+          for (let i = 0; i < props.length; i++) {
+            if (props[i].type === 7) {
+              props[i] = dirToAttr(props[i]);
+            }
           }
         }
       }
-
-      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);
+    },
+    ondirarg(start, end) {
+      if (start === end) return;
+      const arg = getSlice(start, end);
+      if (inVPre) {
+        currentProp.name += arg;
+        setLocEnd(currentProp.nameLoc, end);
+      } else {
+        const isStatic = arg[0] !== `[`;
+        currentProp.arg = createExp(
+          isStatic ? arg : arg.slice(1, -1),
+          isStatic,
+          getLoc(start, end),
+          isStatic ? 3 : 0
+        );
+      }
+    },
+    ondirmodifier(start, end) {
+      const mod = getSlice(start, end);
+      if (inVPre) {
+        currentProp.name += "." + mod;
+        setLocEnd(currentProp.nameLoc, end);
+      } else if (currentProp.name === "slot") {
+        const arg = currentProp.arg;
+        if (arg) {
+          arg.content += "." + mod;
+          setLocEnd(arg.loc, end);
+        }
+      } else {
+        const exp = createSimpleExpression(mod, true, getLoc(start, end));
+        currentProp.modifiers.push(exp);
+      }
+    },
+    onattribdata(start, end) {
+      currentAttrValue += getSlice(start, end);
+      if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
+      currentAttrEndIndex = end;
+    },
+    onattribentity(char, start, end) {
+      currentAttrValue += char;
+      if (currentAttrStartIndex < 0) currentAttrStartIndex = start;
+      currentAttrEndIndex = end;
+    },
+    onattribnameend(end) {
+      const start = currentProp.loc.start.offset;
+      const name = getSlice(start, end);
+      if (currentProp.type === 7) {
+        currentProp.rawName = name;
+      }
+      if (currentOpenTag.props.some(
+        (p) => (p.type === 7 ? p.rawName : p.name) === name
+      )) {
+        emitError(2, start);
+      }
+    },
+    onattribend(quote, end) {
+      if (currentOpenTag && currentProp) {
+        setLocEnd(currentProp.loc, end);
+        if (quote !== 0) {
+          if (currentAttrValue.includes("&")) {
+            currentAttrValue = currentOptions.decodeEntities(
+              currentAttrValue,
+              true
+            );
+          }
+          if (currentProp.type === 6) {
+            if (currentProp.name === "class") {
+              currentAttrValue = condense(currentAttrValue).trim();
+            }
+            if (quote === 1 && !currentAttrValue) {
+              emitError(13, end);
+            }
+            currentProp.value = {
+              type: 2,
+              content: currentAttrValue,
+              loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
+            };
+            if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") {
+              tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
+            }
           } else {
-            removed.push(c$1);
+            let expParseMode = 0 /* Normal */;
+            currentProp.exp = createExp(
+              currentAttrValue,
+              false,
+              getLoc(currentAttrStartIndex, currentAttrEndIndex),
+              0,
+              expParseMode
+            );
+            if (currentProp.name === "for") {
+              currentProp.forParseResult = parseForExpression(currentProp.exp);
+            }
           }
         }
-        this.kept = h(tag, null, kept);
-        this.removed = removed;
+        if (currentProp.type !== 7 || currentProp.name !== "pre") {
+          currentOpenTag.props.push(currentProp);
+        }
       }
-
-      return h(tag, null, children)
+      currentAttrValue = "";
+      currentAttrStartIndex = currentAttrEndIndex = -1;
     },
-
-    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
+    oncomment(start, end) {
+      if (currentOptions.comments) {
+        addNode({
+          type: 3,
+          content: getSlice(start, end),
+          loc: getLoc(start - 4, end + 3)
+        });
       }
-
-      // 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);
+    },
+    onend() {
+      const end = currentInput.length;
+      if (tokenizer.state !== 1) {
+        switch (tokenizer.state) {
+          case 5:
+          case 8:
+            emitError(5, end);
+            break;
+          case 3:
+          case 4:
+            emitError(
+              25,
+              tokenizer.sectionStart
+            );
+            break;
+          case 28:
+            if (tokenizer.currentSequence === Sequences.CdataEnd) {
+              emitError(6, end);
+            } else {
+              emitError(7, end);
             }
-          });
+            break;
+          case 6:
+          case 7:
+          case 9:
+          case 11:
+          case 12:
+          case 13:
+          case 14:
+          case 15:
+          case 16:
+          case 17:
+          case 18:
+          case 19:
+          // "
+          case 20:
+          // '
+          case 21:
+            emitError(9, end);
+            break;
         }
-      });
+      }
+      for (let index = 0; index < stack.length; index++) {
+        onCloseTag(stack[index], end - 1);
+        emitError(24, stack[index].loc.start.offset);
+      }
     },
-
-    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)
+    oncdata(start, end) {
+      if (stack[0].ns !== 0) {
+        onText(getSlice(start, end), start, end);
+      } else {
+        emitError(1, start - 9);
+      }
+    },
+    onprocessinginstruction(start) {
+      if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
+        emitError(
+          21,
+          start - 1
+        );
       }
     }
-  };
-
-  function callPendingCbs (c) {
-    /* istanbul ignore if */
-    if (c.elm._moveCb) {
-      c.elm._moveCb();
+  });
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  function parseForExpression(input) {
+    const loc = input.loc;
+    const exp = input.content;
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch) return;
+    const [, LHS, RHS] = inMatch;
+    const createAliasExpression = (content, offset, asParam = false) => {
+      const start = loc.start.offset + offset;
+      const end = start + content.length;
+      return createExp(
+        content,
+        false,
+        getLoc(start, end),
+        0,
+        asParam ? 1 /* Params */ : 0 /* Normal */
+      );
+    };
+    const result = {
+      source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
+      value: void 0,
+      key: void 0,
+      index: void 0,
+      finalized: false
+    };
+    let valueContent = LHS.trim().replace(stripParensRE, "").trim();
+    const trimmedOffset = LHS.indexOf(valueContent);
+    const iteratorMatch = valueContent.match(forIteratorRE);
+    if (iteratorMatch) {
+      valueContent = valueContent.replace(forIteratorRE, "").trim();
+      const keyContent = iteratorMatch[1].trim();
+      let keyOffset;
+      if (keyContent) {
+        keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
+        result.key = createAliasExpression(keyContent, keyOffset, true);
+      }
+      if (iteratorMatch[2]) {
+        const indexContent = iteratorMatch[2].trim();
+        if (indexContent) {
+          result.index = createAliasExpression(
+            indexContent,
+            exp.indexOf(
+              indexContent,
+              result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
+            ),
+            true
+          );
+        }
+      }
     }
-    /* istanbul ignore if */
-    if (c.elm._enterCb) {
-      c.elm._enterCb();
+    if (valueContent) {
+      result.value = createAliasExpression(valueContent, trimmedOffset, true);
     }
+    return result;
   }
-
-  function recordPosition (c) {
-    c.data.newPos = c.elm.getBoundingClientRect();
+  function getSlice(start, end) {
+    return currentInput.slice(start, end);
   }
-
-  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 endOpenTag(end) {
+    if (tokenizer.inSFCRoot) {
+      currentOpenTag.innerLoc = getLoc(end + 1, end + 1);
     }
-  }
-
-  var platformComponents = {
-    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)
-  };
-
-  // 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'
-          );
-        }
+    addNode(currentOpenTag);
+    const { tag, ns } = currentOpenTag;
+    if (ns === 0 && currentOptions.isPreTag(tag)) {
+      inPre++;
+    }
+    if (currentOptions.isVoidTag(tag)) {
+      onCloseTag(currentOpenTag, end);
+    } else {
+      stack.unshift(currentOpenTag);
+      if (ns === 1 || ns === 2) {
+        tokenizer.inXML = true;
       }
-      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"
-        );
+    }
+    currentOpenTag = null;
+  }
+  function onText(content, start, end) {
+    {
+      const tag = stack[0] && stack[0].tag;
+      if (tag !== "script" && tag !== "style" && content.includes("&")) {
+        content = currentOptions.decodeEntities(content, false);
       }
-    }, 0);
+    }
+    const parent = stack[0] || currentRoot;
+    const lastNode = parent.children[parent.children.length - 1];
+    if (lastNode && lastNode.type === 2) {
+      lastNode.content += content;
+      setLocEnd(lastNode.loc, end);
+    } else {
+      parent.children.push({
+        type: 2,
+        content,
+        loc: getLoc(start, end)
+      });
+    }
   }
-
-  /*  */
-
-  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));
+  function onCloseTag(el, end, isImplied = false) {
+    if (isImplied) {
+      setLocEnd(el.loc, backTrack(end, 60));
+    } else {
+      setLocEnd(el.loc, lookAhead(end, 62) + 1);
     }
-    return {
-      expression: tokens.join('+'),
-      tokens: rawTokens
+    if (tokenizer.inSFCRoot) {
+      if (el.children.length) {
+        el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);
+      } else {
+        el.innerLoc.end = extend({}, el.innerLoc.start);
+      }
+      el.innerLoc.source = getSlice(
+        el.innerLoc.start.offset,
+        el.innerLoc.end.offset
+      );
+    }
+    const { tag, ns, children } = el;
+    if (!inVPre) {
+      if (tag === "slot") {
+        el.tagType = 2;
+      } else if (isFragmentTemplate(el)) {
+        el.tagType = 3;
+      } else if (isComponent(el)) {
+        el.tagType = 1;
+      }
+    }
+    if (!tokenizer.inRCDATA) {
+      el.children = condenseWhitespace(children);
+    }
+    if (ns === 0 && currentOptions.isIgnoreNewlineTag(tag)) {
+      const first = children[0];
+      if (first && first.type === 2) {
+        first.content = first.content.replace(/^\r?\n/, "");
+      }
+    }
+    if (ns === 0 && currentOptions.isPreTag(tag)) {
+      inPre--;
+    }
+    if (currentVPreBoundary === el) {
+      inVPre = tokenizer.inVPre = false;
+      currentVPreBoundary = null;
+    }
+    if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
+      tokenizer.inXML = false;
     }
   }
-
-  /*  */
-
-  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']
-        );
+  function lookAhead(index, c) {
+    let i = index;
+    while (currentInput.charCodeAt(i) !== c && i < currentInput.length - 1) i++;
+    return i;
+  }
+  function backTrack(index, c) {
+    let i = index;
+    while (currentInput.charCodeAt(i) !== c && i >= 0) i--;
+    return i;
+  }
+  const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
+  function isFragmentTemplate({ tag, props }) {
+    if (tag === "template") {
+      for (let i = 0; i < props.length; i++) {
+        if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
+          return true;
+        }
       }
     }
-    if (staticClass) {
-      el.staticClass = JSON.stringify(staticClass);
+    return false;
+  }
+  function isComponent({ tag, props }) {
+    if (currentOptions.isCustomElement(tag)) {
+      return false;
+    }
+    if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || currentOptions.isBuiltInComponent && currentOptions.isBuiltInComponent(tag) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
+      return true;
+    }
+    for (let i = 0; i < props.length; i++) {
+      const p = props[i];
+      if (p.type === 6) {
+        if (p.name === "is" && p.value) {
+          if (p.value.content.startsWith("vue:")) {
+            return true;
+          }
+        }
+      }
     }
-    var classBinding = getBindingAttr(el, 'class', false /* getStatic */);
-    if (classBinding) {
-      el.classBinding = classBinding;
+    return false;
+  }
+  function isUpperCase(c) {
+    return c > 64 && c < 91;
+  }
+  const windowsNewlineRE = /\r\n/g;
+  function condenseWhitespace(nodes) {
+    const shouldCondense = currentOptions.whitespace !== "preserve";
+    let removedWhitespace = false;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.type === 2) {
+        if (!inPre) {
+          if (isAllWhitespace(node.content)) {
+            const prev = nodes[i - 1] && nodes[i - 1].type;
+            const next = nodes[i + 1] && nodes[i + 1].type;
+            if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
+              removedWhitespace = true;
+              nodes[i] = null;
+            } else {
+              node.content = " ";
+            }
+          } else if (shouldCondense) {
+            node.content = condense(node.content);
+          }
+        } else {
+          node.content = node.content.replace(windowsNewlineRE, "\n");
+        }
+      }
     }
+    return removedWhitespace ? nodes.filter(Boolean) : nodes;
   }
-
-  function genData (el) {
-    var data = '';
-    if (el.staticClass) {
-      data += "staticClass:" + (el.staticClass) + ",";
+  function isAllWhitespace(str) {
+    for (let i = 0; i < str.length; i++) {
+      if (!isWhitespace(str.charCodeAt(i))) {
+        return false;
+      }
     }
-    if (el.classBinding) {
-      data += "class:" + (el.classBinding) + ",";
+    return true;
+  }
+  function hasNewlineChar(str) {
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c === 10 || c === 13) {
+        return true;
+      }
     }
-    return data
+    return false;
   }
-
-  var klass$1 = {
-    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']
-          );
+  function condense(str) {
+    let ret = "";
+    let prevCharIsWhitespace = false;
+    for (let i = 0; i < str.length; i++) {
+      if (isWhitespace(str.charCodeAt(i))) {
+        if (!prevCharIsWhitespace) {
+          ret += " ";
+          prevCharIsWhitespace = true;
         }
+      } else {
+        ret += str[i];
+        prevCharIsWhitespace = false;
       }
-      el.staticStyle = JSON.stringify(parseStyleText(staticStyle));
     }
-
-    var styleBinding = getBindingAttr(el, 'style', false /* getStatic */);
-    if (styleBinding) {
-      el.styleBinding = styleBinding;
+    return ret;
+  }
+  function addNode(node) {
+    (stack[0] || currentRoot).children.push(node);
+  }
+  function getLoc(start, end) {
+    return {
+      start: tokenizer.getPos(start),
+      // @ts-expect-error allow late attachment
+      end: end == null ? end : tokenizer.getPos(end),
+      // @ts-expect-error allow late attachment
+      source: end == null ? end : getSlice(start, end)
+    };
+  }
+  function cloneLoc(loc) {
+    return getLoc(loc.start.offset, loc.end.offset);
+  }
+  function setLocEnd(loc, end) {
+    loc.end = tokenizer.getPos(end);
+    loc.source = getSlice(loc.start.offset, end);
+  }
+  function dirToAttr(dir) {
+    const attr = {
+      type: 6,
+      name: dir.rawName,
+      nameLoc: getLoc(
+        dir.loc.start.offset,
+        dir.loc.start.offset + dir.rawName.length
+      ),
+      value: void 0,
+      loc: dir.loc
+    };
+    if (dir.exp) {
+      const loc = dir.exp.loc;
+      if (loc.end.offset < dir.loc.end.offset) {
+        loc.start.offset--;
+        loc.start.column--;
+        loc.end.offset++;
+        loc.end.column++;
+      }
+      attr.value = {
+        type: 2,
+        content: dir.exp.content,
+        loc
+      };
     }
+    return attr;
   }
-
-  function genData$1 (el) {
-    var data = '';
-    if (el.staticStyle) {
-      data += "staticStyle:" + (el.staticStyle) + ",";
+  function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {
+    const exp = createSimpleExpression(content, isStatic, loc, constType);
+    return exp;
+  }
+  function emitError(code, index, message) {
+    currentOptions.onError(
+      createCompilerError(code, getLoc(index, index), void 0, message)
+    );
+  }
+  function reset() {
+    tokenizer.reset();
+    currentOpenTag = null;
+    currentProp = null;
+    currentAttrValue = "";
+    currentAttrStartIndex = -1;
+    currentAttrEndIndex = -1;
+    stack.length = 0;
+  }
+  function baseParse(input, options) {
+    reset();
+    currentInput = input;
+    currentOptions = extend({}, defaultParserOptions);
+    if (options) {
+      let key;
+      for (key in options) {
+        if (options[key] != null) {
+          currentOptions[key] = options[key];
+        }
+      }
     }
-    if (el.styleBinding) {
-      data += "style:(" + (el.styleBinding) + "),";
+    {
+      if (!currentOptions.decodeEntities) {
+        throw new Error(
+          `[@vue/compiler-core] decodeEntities option is required in browser builds.`
+        );
+      }
     }
-    return data
+    tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
+    tokenizer.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
+    const delimiters = options && options.delimiters;
+    if (delimiters) {
+      tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
+      tokenizer.delimiterClose = toCharCodes(delimiters[1]);
+    }
+    const root = currentRoot = createRoot([], input);
+    tokenizer.parse(currentInput);
+    root.loc = getLoc(0, input.length);
+    root.children = condenseWhitespace(root.children);
+    currentRoot = null;
+    return root;
+  }
+
+  function cacheStatic(root, context) {
+    walk(
+      root,
+      void 0,
+      context,
+      // Root node is unfortunately non-hoistable due to potential parent
+      // fallthrough attributes.
+      !!getSingleElementRoot(root)
+    );
   }
-
-  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
-    }
-  };
-
-  /*  */
-
-  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.
-   */
-
-  // 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 pased 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);
+  function getSingleElementRoot(root) {
+    const children = root.children.filter((x) => x.type !== 3);
+    return children.length === 1 && children[0].type === 1 && !isSlotOutlet(children[0]) ? children[0] : null;
+  }
+  function walk(node, parent, context, doNotHoistNode = false, inFor = false) {
+    const { children } = node;
+    const toCache = [];
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      if (child.type === 1 && child.tagType === 0) {
+        const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
+        if (constantType > 0) {
+          if (constantType >= 2) {
+            child.codegenNode.patchFlag = -1;
+            toCache.push(child);
+            continue;
+          }
+        } else {
+          const codegenNode = child.codegenNode;
+          if (codegenNode.type === 13) {
+            const flag = codegenNode.patchFlag;
+            if ((flag === void 0 || flag === 512 || flag === 1) && getGeneratedPropsConstantType(child, context) >= 2) {
+              const props = getNodeProps(child);
+              if (props) {
+                codegenNode.props = context.hoist(props);
               }
-              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
+            if (codegenNode.dynamicProps) {
+              codegenNode.dynamicProps = context.hoist(codegenNode.dynamicProps);
             }
           }
-
-          // Doctype:
-          var doctypeMatch = html.match(doctype);
-          if (doctypeMatch) {
-            advance(doctypeMatch[0].length);
-            continue
+        }
+      } else if (child.type === 12) {
+        const constantType = doNotHoistNode ? 0 : getConstantType(child, context);
+        if (constantType >= 2) {
+          toCache.push(child);
+          continue;
+        }
+      }
+      if (child.type === 1) {
+        const isComponent = child.tagType === 1;
+        if (isComponent) {
+          context.scopes.vSlot++;
+        }
+        walk(child, node, context, false, inFor);
+        if (isComponent) {
+          context.scopes.vSlot--;
+        }
+      } else if (child.type === 11) {
+        walk(child, node, context, child.children.length === 1, true);
+      } else if (child.type === 9) {
+        for (let i2 = 0; i2 < child.branches.length; i2++) {
+          walk(
+            child.branches[i2],
+            node,
+            context,
+            child.branches[i2].children.length === 1,
+            inFor
+          );
+        }
+      }
+    }
+    let cachedAsArray = false;
+    const slotCacheKeys = [];
+    if (toCache.length === children.length && node.type === 1) {
+      if (node.tagType === 0 && node.codegenNode && node.codegenNode.type === 13 && isArray(node.codegenNode.children)) {
+        node.codegenNode.children = getCacheExpression(
+          createArrayExpression(node.codegenNode.children)
+        );
+        cachedAsArray = true;
+      } else if (node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
+        const slot = getSlotNode(node.codegenNode, "default");
+        if (slot) {
+          slotCacheKeys.push(context.cached.length);
+          slot.returns = getCacheExpression(
+            createArrayExpression(slot.returns)
+          );
+          cachedAsArray = true;
+        }
+      } else if (node.tagType === 3 && parent && parent.type === 1 && parent.tagType === 1 && parent.codegenNode && parent.codegenNode.type === 13 && parent.codegenNode.children && !isArray(parent.codegenNode.children) && parent.codegenNode.children.type === 15) {
+        const slotName = findDir(node, "slot", true);
+        const slot = slotName && slotName.arg && getSlotNode(parent.codegenNode, slotName.arg);
+        if (slot) {
+          slotCacheKeys.push(context.cached.length);
+          slot.returns = getCacheExpression(
+            createArrayExpression(slot.returns)
+          );
+          cachedAsArray = true;
+        }
+      }
+    }
+    if (!cachedAsArray) {
+      for (const child of toCache) {
+        slotCacheKeys.push(context.cached.length);
+        child.codegenNode = context.cache(child.codegenNode);
+      }
+    }
+    if (slotCacheKeys.length && node.type === 1 && node.tagType === 1 && node.codegenNode && node.codegenNode.type === 13 && node.codegenNode.children && !isArray(node.codegenNode.children) && node.codegenNode.children.type === 15) {
+      node.codegenNode.children.properties.push(
+        createObjectProperty(
+          `__`,
+          createSimpleExpression(JSON.stringify(slotCacheKeys), false)
+        )
+      );
+    }
+    function getCacheExpression(value) {
+      const exp = context.cache(value);
+      if (inFor && context.hmr) {
+        exp.needArraySpread = true;
+      }
+      return exp;
+    }
+    function getSlotNode(node2, name) {
+      if (node2.children && !isArray(node2.children) && node2.children.type === 15) {
+        const slot = node2.children.properties.find(
+          (p) => p.key === name || p.key.content === name
+        );
+        return slot && slot.value;
+      }
+    }
+    if (toCache.length && context.transformHoist) {
+      context.transformHoist(children, context, node);
+    }
+  }
+  function getConstantType(node, context) {
+    const { constantCache } = context;
+    switch (node.type) {
+      case 1:
+        if (node.tagType !== 0) {
+          return 0;
+        }
+        const cached = constantCache.get(node);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const codegenNode = node.codegenNode;
+        if (codegenNode.type !== 13) {
+          return 0;
+        }
+        if (codegenNode.isBlock && node.tag !== "svg" && node.tag !== "foreignObject" && node.tag !== "math") {
+          return 0;
+        }
+        if (codegenNode.patchFlag === void 0) {
+          let returnType2 = 3;
+          const generatedPropsType = getGeneratedPropsConstantType(node, context);
+          if (generatedPropsType === 0) {
+            constantCache.set(node, 0);
+            return 0;
           }
-
-          // End tag:
-          var endTagMatch = html.match(endTag);
-          if (endTagMatch) {
-            var curIndex = index;
-            advance(endTagMatch[0].length);
-            parseEndTag(endTagMatch[1], curIndex, index);
-            continue
+          if (generatedPropsType < returnType2) {
+            returnType2 = generatedPropsType;
           }
-
-          // Start tag:
-          var startTagMatch = parseStartTag();
-          if (startTagMatch) {
-            handleStartTag(startTagMatch);
-            if (shouldIgnoreFirstNewline(startTagMatch.tagName, html)) {
-              advance(1);
+          for (let i = 0; i < node.children.length; i++) {
+            const childType = getConstantType(node.children[i], context);
+            if (childType === 0) {
+              constantCache.set(node, 0);
+              return 0;
+            }
+            if (childType < returnType2) {
+              returnType2 = childType;
+            }
+          }
+          if (returnType2 > 1) {
+            for (let i = 0; i < node.props.length; i++) {
+              const p = node.props[i];
+              if (p.type === 7 && p.name === "bind" && p.exp) {
+                const expType = getConstantType(p.exp, context);
+                if (expType === 0) {
+                  constantCache.set(node, 0);
+                  return 0;
+                }
+                if (expType < returnType2) {
+                  returnType2 = expType;
+                }
+              }
             }
-            continue
           }
+          if (codegenNode.isBlock) {
+            for (let i = 0; i < node.props.length; i++) {
+              const p = node.props[i];
+              if (p.type === 7) {
+                constantCache.set(node, 0);
+                return 0;
+              }
+            }
+            context.removeHelper(OPEN_BLOCK);
+            context.removeHelper(
+              getVNodeBlockHelper(context.inSSR, codegenNode.isComponent)
+            );
+            codegenNode.isBlock = false;
+            context.helper(getVNodeHelper(context.inSSR, codegenNode.isComponent));
+          }
+          constantCache.set(node, returnType2);
+          return returnType2;
+        } else {
+          constantCache.set(node, 0);
+          return 0;
         }
-
-        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);
+      case 2:
+      case 3:
+        return 3;
+      case 9:
+      case 11:
+      case 10:
+        return 0;
+      case 5:
+      case 12:
+        return getConstantType(node.content, context);
+      case 4:
+        return node.constType;
+      case 8:
+        let returnType = 3;
+        for (let i = 0; i < node.children.length; i++) {
+          const child = node.children[i];
+          if (isString(child) || isSymbol(child)) {
+            continue;
+          }
+          const childType = getConstantType(child, context);
+          if (childType === 0) {
+            return 0;
+          } else if (childType < returnType) {
+            returnType = childType;
           }
-          text = html.substring(0, textEnd);
         }
-
-        if (textEnd < 0) {
-          text = html;
+        return returnType;
+      case 20:
+        return 2;
+      default:
+        return 0;
+    }
+  }
+  const allowHoistedHelperSet = /* @__PURE__ */ new Set([
+    NORMALIZE_CLASS,
+    NORMALIZE_STYLE,
+    NORMALIZE_PROPS,
+    GUARD_REACTIVE_PROPS
+  ]);
+  function getConstantTypeOfHelperCall(value, context) {
+    if (value.type === 14 && !isString(value.callee) && allowHoistedHelperSet.has(value.callee)) {
+      const arg = value.arguments[0];
+      if (arg.type === 4) {
+        return getConstantType(arg, context);
+      } else if (arg.type === 14) {
+        return getConstantTypeOfHelperCall(arg, context);
+      }
+    }
+    return 0;
+  }
+  function getGeneratedPropsConstantType(node, context) {
+    let returnType = 3;
+    const props = getNodeProps(node);
+    if (props && props.type === 15) {
+      const { properties } = props;
+      for (let i = 0; i < properties.length; i++) {
+        const { key, value } = properties[i];
+        const keyType = getConstantType(key, context);
+        if (keyType === 0) {
+          return keyType;
         }
-
-        if (text) {
-          advance(text.length);
+        if (keyType < returnType) {
+          returnType = keyType;
         }
-
-        if (options.chars && text) {
-          options.chars(text, index - text.length, index);
+        let valueType;
+        if (value.type === 4) {
+          valueType = getConstantType(value, context);
+        } else if (value.type === 14) {
+          valueType = getConstantTypeOfHelperCall(value, context);
+        } else {
+          valueType = 0;
         }
-      } 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 });
+        if (valueType === 0) {
+          return valueType;
+        }
+        if (valueType < returnType) {
+          returnType = valueType;
         }
-        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);
+    return returnType;
+  }
+  function getNodeProps(node) {
+    const codegenNode = node.codegenNode;
+    if (codegenNode.type === 13) {
+      return codegenNode.props;
+    }
+  }
+
+  function createTransformContext(root, {
+    filename = "",
+    prefixIdentifiers = false,
+    hoistStatic = false,
+    hmr = false,
+    cacheHandlers = false,
+    nodeTransforms = [],
+    directiveTransforms = {},
+    transformHoist = null,
+    isBuiltInComponent = NOOP,
+    isCustomElement = NOOP,
+    expressionPlugins = [],
+    scopeId = null,
+    slotted = true,
+    ssr = false,
+    inSSR = false,
+    ssrCssVars = ``,
+    bindingMetadata = EMPTY_OBJ,
+    inline = false,
+    isTS = false,
+    onError = defaultOnError,
+    onWarn = defaultOnWarn,
+    compatConfig
+  }) {
+    const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
+    const context = {
+      // options
+      filename,
+      selfName: nameMatch && capitalize(camelize(nameMatch[1])),
+      prefixIdentifiers,
+      hoistStatic,
+      hmr,
+      cacheHandlers,
+      nodeTransforms,
+      directiveTransforms,
+      transformHoist,
+      isBuiltInComponent,
+      isCustomElement,
+      expressionPlugins,
+      scopeId,
+      slotted,
+      ssr,
+      inSSR,
+      ssrCssVars,
+      bindingMetadata,
+      inline,
+      isTS,
+      onError,
+      onWarn,
+      compatConfig,
+      // state
+      root,
+      helpers: /* @__PURE__ */ new Map(),
+      components: /* @__PURE__ */ new Set(),
+      directives: /* @__PURE__ */ new Set(),
+      hoists: [],
+      imports: [],
+      cached: [],
+      constantCache: /* @__PURE__ */ new WeakMap(),
+      temps: 0,
+      identifiers: /* @__PURE__ */ Object.create(null),
+      scopes: {
+        vFor: 0,
+        vSlot: 0,
+        vPre: 0,
+        vOnce: 0
+      },
+      parent: null,
+      grandParent: null,
+      currentNode: root,
+      childIndex: 0,
+      inVOnce: false,
+      // methods
+      helper(name) {
+        const count = context.helpers.get(name) || 0;
+        context.helpers.set(name, count + 1);
+        return name;
+      },
+      removeHelper(name) {
+        const count = context.helpers.get(name);
+        if (count) {
+          const currentCount = count - 1;
+          if (!currentCount) {
+            context.helpers.delete(name);
+          } else {
+            context.helpers.set(name, currentCount);
+          }
         }
-        if (end) {
-          match.unarySlash = end[1];
-          advance(end[0].length);
-          match.end = index;
-          return match
+      },
+      helperString(name) {
+        return `_${helperNameMap[context.helper(name)]}`;
+      },
+      replaceNode(node) {
+        {
+          if (!context.currentNode) {
+            throw new Error(`Node being replaced is already removed.`);
+          }
+          if (!context.parent) {
+            throw new Error(`Cannot replace root node.`);
+          }
         }
-      }
-    }
-
-    function handleStartTag (match) {
-      var tagName = match.tagName;
-      var unarySlash = match.unarySlash;
-
-      if (expectHTML) {
-        if (lastTag === 'p' && isNonPhrasingTag(tagName)) {
-          parseEndTag(lastTag);
+        context.parent.children[context.childIndex] = context.currentNode = node;
+      },
+      removeNode(node) {
+        if (!context.parent) {
+          throw new Error(`Cannot remove root node.`);
         }
-        if (canBeLeftOpenTag$$1(tagName) && lastTag === tagName) {
-          parseEndTag(tagName);
+        const list = context.parent.children;
+        const removalIndex = node ? list.indexOf(node) : context.currentNode ? context.childIndex : -1;
+        if (removalIndex < 0) {
+          throw new Error(`node being removed is not a child of current parent`);
         }
-      }
-
-      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 (!node || node === context.currentNode) {
+          context.currentNode = null;
+          context.onNodeRemoved();
+        } else {
+          if (context.childIndex > removalIndex) {
+            context.childIndex--;
+            context.onNodeRemoved();
+          }
         }
+        context.parent.children.splice(removalIndex, 1);
+      },
+      onNodeRemoved: NOOP,
+      addIdentifiers(exp) {
+      },
+      removeIdentifiers(exp) {
+      },
+      hoist(exp) {
+        if (isString(exp)) exp = createSimpleExpression(exp);
+        context.hoists.push(exp);
+        const identifier = createSimpleExpression(
+          `_hoisted_${context.hoists.length}`,
+          false,
+          exp.loc,
+          2
+        );
+        identifier.hoisted = exp;
+        return identifier;
+      },
+      cache(exp, isVNode = false, inVOnce = false) {
+        const cacheExp = createCacheExpression(
+          context.cached.length,
+          exp,
+          isVNode,
+          inVOnce
+        );
+        context.cached.push(cacheExp);
+        return cacheExp;
       }
-
-      if (!unary) {
-        stack.push({ tag: tagName, lowerCasedTag: tagName.toLowerCase(), attrs: attrs, start: match.start, end: match.end });
-        lastTag = tagName;
+    };
+    return context;
+  }
+  function transform(root, options) {
+    const context = createTransformContext(root, options);
+    traverseNode(root, context);
+    if (options.hoistStatic) {
+      cacheStatic(root, context);
+    }
+    if (!options.ssr) {
+      createRootCodegen(root, context);
+    }
+    root.helpers = /* @__PURE__ */ new Set([...context.helpers.keys()]);
+    root.components = [...context.components];
+    root.directives = [...context.directives];
+    root.imports = context.imports;
+    root.hoists = context.hoists;
+    root.temps = context.temps;
+    root.cached = context.cached;
+    root.transformed = true;
+  }
+  function createRootCodegen(root, context) {
+    const { helper } = context;
+    const { children } = root;
+    if (children.length === 1) {
+      const singleElementRootChild = getSingleElementRoot(root);
+      if (singleElementRootChild && singleElementRootChild.codegenNode) {
+        const codegenNode = singleElementRootChild.codegenNode;
+        if (codegenNode.type === 13) {
+          convertToBlock(codegenNode, context);
+        }
+        root.codegenNode = codegenNode;
+      } else {
+        root.codegenNode = children[0];
+      }
+    } else if (children.length > 1) {
+      let patchFlag = 64;
+      if (children.filter((c) => c.type !== 3).length === 1) {
+        patchFlag |= 2048;
+      }
+      root.codegenNode = createVNodeCall(
+        context,
+        helper(FRAGMENT),
+        void 0,
+        root.children,
+        patchFlag,
+        void 0,
+        void 0,
+        true,
+        void 0,
+        false
+      );
+    } else ;
+  }
+  function traverseChildren(parent, context) {
+    let i = 0;
+    const nodeRemoved = () => {
+      i--;
+    };
+    for (; i < parent.children.length; i++) {
+      const child = parent.children[i];
+      if (isString(child)) continue;
+      context.grandParent = context.parent;
+      context.parent = parent;
+      context.childIndex = i;
+      context.onNodeRemoved = nodeRemoved;
+      traverseNode(child, context);
+    }
+  }
+  function traverseNode(node, context) {
+    context.currentNode = node;
+    const { nodeTransforms } = context;
+    const exitFns = [];
+    for (let i2 = 0; i2 < nodeTransforms.length; i2++) {
+      const onExit = nodeTransforms[i2](node, context);
+      if (onExit) {
+        if (isArray(onExit)) {
+          exitFns.push(...onExit);
+        } else {
+          exitFns.push(onExit);
+        }
       }
-
-      if (options.start) {
-        options.start(tagName, attrs, unary, match.start, match.end);
+      if (!context.currentNode) {
+        return;
+      } else {
+        node = context.currentNode;
       }
     }
-
-    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
-          }
+    switch (node.type) {
+      case 3:
+        if (!context.ssr) {
+          context.helper(CREATE_COMMENT);
         }
-      } 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);
-          }
+        break;
+      case 5:
+        if (!context.ssr) {
+          context.helper(TO_DISPLAY_STRING);
         }
-
-        // 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);
+        break;
+      // for container types, further traverse downwards
+      case 9:
+        for (let i2 = 0; i2 < node.branches.length; i2++) {
+          traverseNode(node.branches[i2], context);
         }
-      } else if (lowerCasedTagName === 'p') {
-        if (options.start) {
-          options.start(tagName, [], false, start, end);
+        break;
+      case 10:
+      case 11:
+      case 1:
+      case 0:
+        traverseChildren(node, context);
+        break;
+    }
+    context.currentNode = node;
+    let i = exitFns.length;
+    while (i--) {
+      exitFns[i]();
+    }
+  }
+  function createStructuralDirectiveTransform(name, fn) {
+    const matches = isString(name) ? (n) => n === name : (n) => name.test(n);
+    return (node, context) => {
+      if (node.type === 1) {
+        const { props } = node;
+        if (node.tagType === 3 && props.some(isVSlot)) {
+          return;
         }
-        if (options.end) {
-          options.end(tagName, start, end);
+        const exitFns = [];
+        for (let i = 0; i < props.length; i++) {
+          const prop = props[i];
+          if (prop.type === 7 && matches(prop.name)) {
+            props.splice(i, 1);
+            i--;
+            const onExit = fn(node, prop, context);
+            if (onExit) exitFns.push(onExit);
+          }
         }
+        return exitFns;
       }
-    }
+    };
   }
 
-  /*  */
-
-  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 invalidAttributeRE = /[\s"'<>\/=]/;
-
-  var decodeHTMLCached = cached(he.decode);
-
-  var emptySlotScopeToken = "_empty_";
-
-  // configurable state
-  var warn$2;
-  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$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);
-          }
-          addIfCondition(root, {
-            exp: element.elseif,
-            block: element
-          });
+  const PURE_ANNOTATION = `/*@__PURE__*/`;
+  const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
+  function createCodegenContext(ast, {
+    mode = "function",
+    prefixIdentifiers = mode === "module",
+    sourceMap = false,
+    filename = `template.vue.html`,
+    scopeId = null,
+    optimizeImports = false,
+    runtimeGlobalName = `Vue`,
+    runtimeModuleName = `vue`,
+    ssrRuntimeModuleName = "vue/server-renderer",
+    ssr = false,
+    isTS = false,
+    inSSR = false
+  }) {
+    const context = {
+      mode,
+      prefixIdentifiers,
+      sourceMap,
+      filename,
+      scopeId,
+      optimizeImports,
+      runtimeGlobalName,
+      runtimeModuleName,
+      ssrRuntimeModuleName,
+      ssr,
+      isTS,
+      inSSR,
+      source: ast.source,
+      code: ``,
+      column: 1,
+      line: 1,
+      offset: 0,
+      indentLevel: 0,
+      pure: false,
+      map: void 0,
+      helper(key) {
+        return `_${helperNameMap[key]}`;
+      },
+      push(code, newlineIndex = -2 /* None */, node) {
+        context.code += code;
+      },
+      indent() {
+        newline(++context.indentLevel);
+      },
+      deindent(withoutNewLine = false) {
+        if (withoutNewLine) {
+          --context.indentLevel;
         } 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 }
-          );
+          newline(--context.indentLevel);
         }
+      },
+      newline() {
+        newline(context.indentLevel);
       }
-      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;
-        }
+    };
+    function newline(n) {
+      context.push("\n" + `  `.repeat(n), 0 /* Start */);
+    }
+    return context;
+  }
+  function generate(ast, options = {}) {
+    const context = createCodegenContext(ast, options);
+    if (options.onContextCreated) options.onContextCreated(context);
+    const {
+      mode,
+      push,
+      prefixIdentifiers,
+      indent,
+      deindent,
+      newline,
+      scopeId,
+      ssr
+    } = context;
+    const helpers = Array.from(ast.helpers);
+    const hasHelpers = helpers.length > 0;
+    const useWithBlock = !prefixIdentifiers && mode !== "module";
+    const preambleContext = context;
+    {
+      genFunctionPreamble(ast, preambleContext);
+    }
+    const functionName = ssr ? `ssrRender` : `render`;
+    const args = ssr ? ["_ctx", "_push", "_parent", "_attrs"] : ["_ctx", "_cache"];
+    const signature = args.join(", ");
+    {
+      push(`function ${functionName}(${signature}) {`);
+    }
+    indent();
+    if (useWithBlock) {
+      push(`with (_ctx) {`);
+      indent();
+      if (hasHelpers) {
+        push(
+          `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
+`,
+          -1 /* End */
+        );
+        newline();
       }
-
-      // 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 (ast.components.length) {
+      genAssets(ast.components, "component", context);
+      if (ast.directives.length || ast.temps > 0) {
+        newline();
       }
-      if (platformIsPreTag(element.tag)) {
-        inPre = false;
+    }
+    if (ast.directives.length) {
+      genAssets(ast.directives, "directive", context);
+      if (ast.temps > 0) {
+        newline();
       }
-      // apply post-transforms
-      for (var i = 0; i < postTransforms.length; i++) {
-        postTransforms[i](element, options);
+    }
+    if (ast.temps > 0) {
+      push(`let `);
+      for (let i = 0; i < ast.temps; i++) {
+        push(`${i > 0 ? `, ` : ``}_temp${i}`);
       }
     }
-
-    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();
+    if (ast.components.length || ast.directives.length || ast.temps) {
+      push(`
+`, 0 /* Start */);
+      newline();
+    }
+    if (!ssr) {
+      push(`return `);
+    }
+    if (ast.codegenNode) {
+      genNode(ast.codegenNode, context);
+    } else {
+      push(`null`);
+    }
+    if (useWithBlock) {
+      deindent();
+      push(`}`);
+    }
+    deindent();
+    push(`}`);
+    return {
+      ast,
+      code: context.code,
+      preamble: ``,
+      map: context.map ? context.map.toJSON() : void 0
+    };
+  }
+  function genFunctionPreamble(ast, context) {
+    const {
+      ssr,
+      prefixIdentifiers,
+      push,
+      newline,
+      runtimeModuleName,
+      runtimeGlobalName,
+      ssrRuntimeModuleName
+    } = context;
+    const VueBinding = runtimeGlobalName;
+    const helpers = Array.from(ast.helpers);
+    if (helpers.length > 0) {
+      {
+        push(`const _Vue = ${VueBinding}
+`, -1 /* End */);
+        if (ast.hoists.length) {
+          const staticHelpers = [
+            CREATE_VNODE,
+            CREATE_ELEMENT_VNODE,
+            CREATE_COMMENT,
+            CREATE_TEXT,
+            CREATE_STATIC
+          ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
+          push(`const { ${staticHelpers} } = _Vue
+`, -1 /* End */);
         }
       }
     }
-
-    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 }
-        );
+    genHoists(ast.hoists, context);
+    newline();
+    push(`return `);
+  }
+  function genAssets(assets, type, { helper, push, newline, isTS }) {
+    const resolver = helper(
+      type === "component" ? RESOLVE_COMPONENT : RESOLVE_DIRECTIVE
+    );
+    for (let i = 0; i < assets.length; i++) {
+      let id = assets[i];
+      const maybeSelfReference = id.endsWith("__self");
+      if (maybeSelfReference) {
+        id = id.slice(0, -6);
+      }
+      push(
+        `const ${toValidAssetId(id, type)} = ${resolver}(${JSON.stringify(id)}${maybeSelfReference ? `, true` : ``})${isTS ? `!` : ``}`
+      );
+      if (i < assets.length - 1) {
+        newline();
+      }
+    }
+  }
+  function genHoists(hoists, context) {
+    if (!hoists.length) {
+      return;
+    }
+    context.pure = true;
+    const { push, newline } = context;
+    newline();
+    for (let i = 0; i < hoists.length; i++) {
+      const exp = hoists[i];
+      if (exp) {
+        push(`const _hoisted_${i + 1} = `);
+        genNode(exp, context);
+        newline();
+      }
+    }
+    context.pure = false;
+  }
+  function isText(n) {
+    return isString(n) || n.type === 4 || n.type === 2 || n.type === 5 || n.type === 8;
+  }
+  function genNodeListAsArray(nodes, context) {
+    const multilines = nodes.length > 3 || nodes.some((n) => isArray(n) || !isText(n));
+    context.push(`[`);
+    multilines && context.indent();
+    genNodeList(nodes, context, multilines);
+    multilines && context.deindent();
+    context.push(`]`);
+  }
+  function genNodeList(nodes, context, multilines = false, comma = true) {
+    const { push, newline } = context;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (isString(node)) {
+        push(node, -3 /* Unknown */);
+      } else if (isArray(node)) {
+        genNodeListAsArray(node, context);
+      } else {
+        genNode(node, context);
       }
-      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']
-        );
+      if (i < nodes.length - 1) {
+        if (multilines) {
+          comma && push(",");
+          newline();
+        } else {
+          comma && push(", ");
+        }
       }
     }
-
-    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;
-        }
-
+  }
+  function genNode(node, context) {
+    if (isString(node)) {
+      context.push(node, -3 /* Unknown */);
+      return;
+    }
+    if (isSymbol(node)) {
+      context.push(context.helper(node));
+      return;
+    }
+    switch (node.type) {
+      case 1:
+      case 9:
+      case 11:
+        assert(
+          node.codegenNode != null,
+          `Codegen node is missing for element/if/for node. Apply appropriate transforms first.`
+        );
+        genNode(node.codegenNode, context);
+        break;
+      case 2:
+        genText(node, context);
+        break;
+      case 4:
+        genExpression(node, context);
+        break;
+      case 5:
+        genInterpolation(node, context);
+        break;
+      case 12:
+        genNode(node.codegenNode, context);
+        break;
+      case 8:
+        genCompoundExpression(node, context);
+        break;
+      case 3:
+        genComment(node, context);
+        break;
+      case 13:
+        genVNodeCall(node, context);
+        break;
+      case 14:
+        genCallExpression(node, context);
+        break;
+      case 15:
+        genObjectExpression(node, context);
+        break;
+      case 17:
+        genArrayExpression(node, context);
+        break;
+      case 18:
+        genFunctionExpression(node, context);
+        break;
+      case 19:
+        genConditionalExpression(node, context);
+        break;
+      case 20:
+        genCacheExpression(node, context);
+        break;
+      case 21:
+        genNodeList(node.body, context, true, false);
+        break;
+      // SSR only types
+      case 22:
+        break;
+      case 23:
+        break;
+      case 24:
+        break;
+      case 25:
+        break;
+      case 26:
+        break;
+      /* v8 ignore start */
+      case 10:
+        break;
+      default:
         {
-          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 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 (options.outputSourceRange) {
-            child.start = start;
-            child.end = end;
-          }
-          currentParent.children.push(child);
+          assert(false, `unhandled codegen node type: ${node.type}`);
+          const exhaustiveCheck = node;
+          return exhaustiveCheck;
         }
+    }
+  }
+  function genText(node, context) {
+    context.push(JSON.stringify(node.content), -3 /* Unknown */, node);
+  }
+  function genExpression(node, context) {
+    const { content, isStatic } = node;
+    context.push(
+      isStatic ? JSON.stringify(content) : content,
+      -3 /* Unknown */,
+      node
+    );
+  }
+  function genInterpolation(node, context) {
+    const { push, helper, pure } = context;
+    if (pure) push(PURE_ANNOTATION);
+    push(`${helper(TO_DISPLAY_STRING)}(`);
+    genNode(node.content, context);
+    push(`)`);
+  }
+  function genCompoundExpression(node, context) {
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      if (isString(child)) {
+        context.push(child, -3 /* Unknown */);
+      } else {
+        genNode(child, context);
       }
-    });
-    return root
+    }
   }
-
-  function processPre (el) {
-    if (getAndRemoveAttr(el, 'v-pre') != null) {
-      el.pre = true;
+  function genExpressionAsPropertyKey(node, context) {
+    const { push } = context;
+    if (node.type === 8) {
+      push(`[`);
+      genCompoundExpression(node, context);
+      push(`]`);
+    } else if (node.isStatic) {
+      const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
+      push(text, -2 /* None */, node);
+    } else {
+      push(`[${node.content}]`, -3 /* Unknown */, node);
     }
   }
-
-  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 genComment(node, context) {
+    const { push, helper, pure } = context;
+    if (pure) {
+      push(PURE_ANNOTATION);
+    }
+    push(
+      `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,
+      -3 /* Unknown */,
+      node
+    );
+  }
+  function genVNodeCall(node, context) {
+    const { push, helper, pure } = context;
+    const {
+      tag,
+      props,
+      children,
+      patchFlag,
+      dynamicProps,
+      directives,
+      isBlock,
+      disableTracking,
+      isComponent
+    } = node;
+    let patchFlagString;
+    if (patchFlag) {
+      {
+        if (patchFlag < 0) {
+          patchFlagString = patchFlag + ` /* ${PatchFlagNames[patchFlag]} */`;
+        } else {
+          const flagNames = Object.keys(PatchFlagNames).map(Number).filter((n) => n > 0 && patchFlag & n).map((n) => PatchFlagNames[n]).join(`, `);
+          patchFlagString = patchFlag + ` /* ${flagNames} */`;
         }
       }
-    } else if (!el.pre) {
-      // non root node in pre blocks with no attributes
-      el.plain = true;
+    }
+    if (directives) {
+      push(helper(WITH_DIRECTIVES) + `(`);
+    }
+    if (isBlock) {
+      push(`(${helper(OPEN_BLOCK)}(${disableTracking ? `true` : ``}), `);
+    }
+    if (pure) {
+      push(PURE_ANNOTATION);
+    }
+    const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
+    push(helper(callHelper) + `(`, -2 /* None */, node);
+    genNodeList(
+      genNullableArgs([tag, props, children, patchFlagString, dynamicProps]),
+      context
+    );
+    push(`)`);
+    if (isBlock) {
+      push(`)`);
+    }
+    if (directives) {
+      push(`, `);
+      genNode(directives, context);
+      push(`)`);
     }
   }
-
-  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
+  function genNullableArgs(args) {
+    let i = args.length;
+    while (i--) {
+      if (args[i] != null) break;
+    }
+    return args.slice(0, i + 1).map((arg) => arg || `null`);
+  }
+  function genCallExpression(node, context) {
+    const { push, helper, pure } = context;
+    const callee = isString(node.callee) ? node.callee : helper(node.callee);
+    if (pure) {
+      push(PURE_ANNOTATION);
+    }
+    push(callee + `(`, -2 /* None */, node);
+    genNodeList(node.arguments, context);
+    push(`)`);
+  }
+  function genObjectExpression(node, context) {
+    const { push, indent, deindent, newline } = context;
+    const { properties } = node;
+    if (!properties.length) {
+      push(`{}`, -2 /* None */, node);
+      return;
+    }
+    const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
+    push(multilines ? `{` : `{ `);
+    multilines && indent();
+    for (let i = 0; i < properties.length; i++) {
+      const { key, value } = properties[i];
+      genExpressionAsPropertyKey(key, context);
+      push(`: `);
+      genNode(value, context);
+      if (i < properties.length - 1) {
+        push(`,`);
+        newline();
+      }
+    }
+    multilines && deindent();
+    push(multilines ? `}` : ` }`);
+  }
+  function genArrayExpression(node, context) {
+    genNodeListAsArray(node.elements, context);
+  }
+  function genFunctionExpression(node, context) {
+    const { push, indent, deindent } = context;
+    const { params, returns, body, newline, isSlot } = node;
+    if (isSlot) {
+      push(`_${helperNameMap[WITH_CTX]}(`);
+    }
+    push(`(`, -2 /* None */, node);
+    if (isArray(params)) {
+      genNodeList(params, context);
+    } else if (params) {
+      genNode(params, context);
+    }
+    push(`) => `);
+    if (newline || body) {
+      push(`{`);
+      indent();
+    }
+    if (returns) {
+      if (newline) {
+        push(`return `);
+      }
+      if (isArray(returns)) {
+        genNodeListAsArray(returns, context);
+      } else {
+        genNode(returns, context);
+      }
+    } else if (body) {
+      genNode(body, context);
+    }
+    if (newline || body) {
+      deindent();
+      push(`}`);
+    }
+    if (isSlot) {
+      push(`)`);
+    }
+  }
+  function genConditionalExpression(node, context) {
+    const { test, consequent, alternate, newline: needNewline } = node;
+    const { push, indent, deindent, newline } = context;
+    if (test.type === 4) {
+      const needsParens = !isSimpleIdentifier(test.content);
+      needsParens && push(`(`);
+      genExpression(test, context);
+      needsParens && push(`)`);
+    } else {
+      push(`(`);
+      genNode(test, context);
+      push(`)`);
+    }
+    needNewline && indent();
+    context.indentLevel++;
+    needNewline || push(` `);
+    push(`? `);
+    genNode(consequent, context);
+    context.indentLevel--;
+    needNewline && newline();
+    needNewline || push(` `);
+    push(`: `);
+    const isNested = alternate.type === 19;
+    if (!isNested) {
+      context.indentLevel++;
+    }
+    genNode(alternate, context);
+    if (!isNested) {
+      context.indentLevel--;
+    }
+    needNewline && deindent(
+      true
+      /* without newline */
     );
-
-    processRef(element);
-    processSlotContent(element);
-    processSlotOutlet(element);
-    processComponent(element);
-    for (var i = 0; i < transforms.length; i++) {
-      element = transforms[i](element, options) || element;
+  }
+  function genCacheExpression(node, context) {
+    const { push, helper, indent, deindent, newline } = context;
+    const { needPauseTracking, needArraySpread } = node;
+    if (needArraySpread) {
+      push(`[...(`);
+    }
+    push(`_cache[${node.index}] || (`);
+    if (needPauseTracking) {
+      indent();
+      push(`${helper(SET_BLOCK_TRACKING)}(-1`);
+      if (node.inVOnce) push(`, true`);
+      push(`),`);
+      newline();
+      push(`(`);
+    }
+    push(`_cache[${node.index}] = `);
+    genNode(node.value, context);
+    if (needPauseTracking) {
+      push(`).cacheIndex = ${node.index},`);
+      newline();
+      push(`${helper(SET_BLOCK_TRACKING)}(1),`);
+      newline();
+      push(`_cache[${node.index}]`);
+      deindent();
+    }
+    push(`)`);
+    if (needArraySpread) {
+      push(`)]`);
+    }
+  }
+
+  const prohibitedKeywordRE = new RegExp(
+    "\\b" + "arguments,await,break,case,catch,class,const,continue,debugger,default,delete,do,else,export,extends,finally,for,function,if,import,let,new,return,super,switch,throw,try,var,void,while,with,yield".split(",").join("\\b|\\b") + "\\b"
+  );
+  const stripStringRE = /'(?:[^'\\]|\\.)*'|"(?:[^"\\]|\\.)*"|`(?:[^`\\]|\\.)*\$\{|\}(?:[^`\\]|\\.)*`|`(?:[^`\\]|\\.)*`/g;
+  function validateBrowserExpression(node, context, asParams = false, asRawStatements = false) {
+    const exp = node.content;
+    if (!exp.trim()) {
+      return;
+    }
+    try {
+      new Function(
+        asRawStatements ? ` ${exp} ` : `return ${asParams ? `(${exp}) => {}` : `(${exp})`}`
+      );
+    } catch (e) {
+      let message = e.message;
+      const keywordMatch = exp.replace(stripStringRE, "").match(prohibitedKeywordRE);
+      if (keywordMatch) {
+        message = `avoid using JavaScript keyword as property name: "${keywordMatch[0]}"`;
+      }
+      context.onError(
+        createCompilerError(
+          45,
+          node.loc,
+          void 0,
+          message
+        )
+      );
     }
-    processAttrs(element);
-    return element
   }
 
-  function processKey (el) {
-    var exp = getBindingAttr(el, 'key');
-    if (exp) {
+  const transformExpression = (node, context) => {
+    if (node.type === 5) {
+      node.content = processExpression(
+        node.content,
+        context
+      );
+    } else if (node.type === 1) {
+      const memo = findDir(node, "memo");
+      for (let i = 0; i < node.props.length; i++) {
+        const dir = node.props[i];
+        if (dir.type === 7 && dir.name !== "for") {
+          const exp = dir.exp;
+          const arg = dir.arg;
+          if (exp && exp.type === 4 && !(dir.name === "on" && arg) && // key has been processed in transformFor(vMemo + vFor)
+          !(memo && arg && arg.type === 4 && arg.content === "key")) {
+            dir.exp = processExpression(
+              exp,
+              context,
+              // slot args must be processed as function params
+              dir.name === "slot"
+            );
+          }
+          if (arg && arg.type === 4 && !arg.isStatic) {
+            dir.arg = processExpression(arg, context);
+          }
+        }
+      }
+    }
+  };
+  function processExpression(node, context, asParams = false, asRawStatements = false, localVars = Object.create(context.identifiers)) {
+    {
       {
-        if (el.tag === 'template') {
-          warn$2(
-            "<template> cannot be keyed. Place the key on real elements instead.",
-            getRawBindingAttr(el, 'key')
-          );
+        validateBrowserExpression(node, context, asParams, asRawStatements);
+      }
+      return node;
+    }
+  }
+
+  const transformIf = createStructuralDirectiveTransform(
+    /^(if|else|else-if)$/,
+    (node, dir, context) => {
+      return processIf(node, dir, context, (ifNode, branch, isRoot) => {
+        const siblings = context.parent.children;
+        let i = siblings.indexOf(ifNode);
+        let key = 0;
+        while (i-- >= 0) {
+          const sibling = siblings[i];
+          if (sibling && sibling.type === 9) {
+            key += sibling.branches.length;
+          }
+        }
+        return () => {
+          if (isRoot) {
+            ifNode.codegenNode = createCodegenNodeForBranch(
+              branch,
+              key,
+              context
+            );
+          } else {
+            const parentCondition = getParentCondition(ifNode.codegenNode);
+            parentCondition.alternate = createCodegenNodeForBranch(
+              branch,
+              key + ifNode.branches.length - 1,
+              context
+            );
+          }
+        };
+      });
+    }
+  );
+  function processIf(node, dir, context, processCodegen) {
+    if (dir.name !== "else" && (!dir.exp || !dir.exp.content.trim())) {
+      const loc = dir.exp ? dir.exp.loc : node.loc;
+      context.onError(
+        createCompilerError(28, dir.loc)
+      );
+      dir.exp = createSimpleExpression(`true`, false, loc);
+    }
+    if (dir.exp) {
+      validateBrowserExpression(dir.exp, context);
+    }
+    if (dir.name === "if") {
+      const branch = createIfBranch(node, dir);
+      const ifNode = {
+        type: 9,
+        loc: cloneLoc(node.loc),
+        branches: [branch]
+      };
+      context.replaceNode(ifNode);
+      if (processCodegen) {
+        return processCodegen(ifNode, branch, true);
+      }
+    } else {
+      const siblings = context.parent.children;
+      const comments = [];
+      let i = siblings.indexOf(node);
+      while (i-- >= -1) {
+        const sibling = siblings[i];
+        if (sibling && sibling.type === 3) {
+          context.removeNode(sibling);
+          comments.unshift(sibling);
+          continue;
         }
-        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 */
+        if (sibling && sibling.type === 2 && !sibling.content.trim().length) {
+          context.removeNode(sibling);
+          continue;
+        }
+        if (sibling && sibling.type === 9) {
+          if (dir.name === "else-if" && sibling.branches[sibling.branches.length - 1].condition === void 0) {
+            context.onError(
+              createCompilerError(30, node.loc)
             );
           }
+          context.removeNode();
+          const branch = createIfBranch(node, dir);
+          if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition>
+          !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) {
+            branch.children = [...comments, ...branch.children];
+          }
+          {
+            const key = branch.userKey;
+            if (key) {
+              sibling.branches.forEach(({ userKey }) => {
+                if (isSameKey(userKey, key)) {
+                  context.onError(
+                    createCompilerError(
+                      29,
+                      branch.userKey.loc
+                    )
+                  );
+                }
+              });
+            }
+          }
+          sibling.branches.push(branch);
+          const onExit = processCodegen && processCodegen(sibling, branch, false);
+          traverseNode(branch, context);
+          if (onExit) onExit();
+          context.currentNode = null;
+        } else {
+          context.onError(
+            createCompilerError(30, node.loc)
+          );
         }
+        break;
       }
-      el.key = exp;
     }
   }
-
-  function processRef (el) {
-    var ref = getBindingAttr(el, 'ref');
-    if (ref) {
-      el.ref = ref;
-      el.refInFor = checkInFor(el);
-    }
+  function createIfBranch(node, dir) {
+    const isTemplateIf = node.tagType === 3;
+    return {
+      type: 10,
+      loc: node.loc,
+      condition: dir.name === "else" ? void 0 : dir.exp,
+      children: isTemplateIf && !findDir(node, "for") ? node.children : [node],
+      userKey: findProp(node, `key`),
+      isTemplateIf
+    };
   }
-
-  function processFor (el) {
-    var exp;
-    if ((exp = getAndRemoveAttr(el, 'v-for'))) {
-      var res = parseFor(exp);
-      if (res) {
-        extend(el, res);
+  function createCodegenNodeForBranch(branch, keyIndex, context) {
+    if (branch.condition) {
+      return createConditionalExpression(
+        branch.condition,
+        createChildrenCodegenNode(branch, keyIndex, context),
+        // make sure to pass in asBlock: true so that the comment node call
+        // closes the current block.
+        createCallExpression(context.helper(CREATE_COMMENT), [
+          '"v-if"' ,
+          "true"
+        ])
+      );
+    } else {
+      return createChildrenCodegenNode(branch, keyIndex, context);
+    }
+  }
+  function createChildrenCodegenNode(branch, keyIndex, context) {
+    const { helper } = context;
+    const keyProperty = createObjectProperty(
+      `key`,
+      createSimpleExpression(
+        `${keyIndex}`,
+        false,
+        locStub,
+        2
+      )
+    );
+    const { children } = branch;
+    const firstChild = children[0];
+    const needFragmentWrapper = children.length !== 1 || firstChild.type !== 1;
+    if (needFragmentWrapper) {
+      if (children.length === 1 && firstChild.type === 11) {
+        const vnodeCall = firstChild.codegenNode;
+        injectProp(vnodeCall, keyProperty, context);
+        return vnodeCall;
       } else {
-        warn$2(
-          ("Invalid v-for expression: " + exp),
-          el.rawAttrsMap['v-for']
+        let patchFlag = 64;
+        if (!branch.isTemplateIf && children.filter((c) => c.type !== 3).length === 1) {
+          patchFlag |= 2048;
+        }
+        return createVNodeCall(
+          context,
+          helper(FRAGMENT),
+          createObjectExpression([keyProperty]),
+          children,
+          patchFlag,
+          void 0,
+          void 0,
+          true,
+          false,
+          false,
+          branch.loc
         );
       }
-    }
-  }
-
-
-
-  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;
+      const ret = firstChild.codegenNode;
+      const vnodeCall = getMemoedVNodeCall(ret);
+      if (vnodeCall.type === 13) {
+        convertToBlock(vnodeCall, context);
+      }
+      injectProp(vnodeCall, keyProperty, context);
+      return ret;
     }
-    return res
   }
-
-  function processIf (el) {
-    var exp = getAndRemoveAttr(el, 'v-if');
-    if (exp) {
-      el.if = exp;
-      addIfCondition(el, {
-        exp: exp,
-        block: el
-      });
+  function isSameKey(a, b) {
+    if (!a || a.type !== b.type) {
+      return false;
+    }
+    if (a.type === 6) {
+      if (a.value.content !== b.value.content) {
+        return false;
+      }
     } else {
-      if (getAndRemoveAttr(el, 'v-else') != null) {
-        el.else = true;
+      const exp = a.exp;
+      const branchExp = b.exp;
+      if (exp.type !== branchExp.type) {
+        return false;
       }
-      var elseif = getAndRemoveAttr(el, 'v-else-if');
-      if (elseif) {
-        el.elseif = elseif;
+      if (exp.type !== 4 || exp.isStatic !== branchExp.isStatic || exp.content !== branchExp.content) {
+        return false;
       }
     }
+    return true;
   }
-
-  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]
-          );
+  function getParentCondition(node) {
+    while (true) {
+      if (node.type === 19) {
+        if (node.alternate.type === 19) {
+          node = node.alternate;
+        } else {
+          return node;
         }
-        children.pop();
+      } else if (node.type === 20) {
+        node = node.value;
       }
     }
   }
 
-  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
-        );
+  const transformBind = (dir, _node, context) => {
+    const { modifiers, loc } = dir;
+    const arg = dir.arg;
+    let { exp } = dir;
+    if (exp && exp.type === 4 && !exp.content.trim()) {
+      {
+        exp = void 0;
       }
-      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
+    }
+    if (!exp) {
+      if (arg.type !== 4 || !arg.isStatic) {
+        context.onError(
+          createCompilerError(
+            52,
+            arg.loc
+          )
         );
+        return {
+          props: [
+            createObjectProperty(arg, createSimpleExpression("", true, loc))
+          ]
+        };
       }
-      el.slotScope = slotScope;
+      transformBindShorthand(dir);
+      exp = dir.exp;
     }
-
-    // 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'));
-      }
+    if (arg.type !== 4) {
+      arg.children.unshift(`(`);
+      arg.children.push(`) || ""`);
+    } else if (!arg.isStatic) {
+      arg.content = `${arg.content} || ""`;
     }
-
-    // 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 the 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
+    if (modifiers.some((mod) => mod.content === "camel")) {
+      if (arg.type === 4) {
+        if (arg.isStatic) {
+          arg.content = camelize(arg.content);
+        } else {
+          arg.content = `${context.helperString(CAMELIZE)}(${arg.content})`;
         }
       } 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;
-        }
+        arg.children.unshift(`${context.helperString(CAMELIZE)}(`);
+        arg.children.push(`)`);
       }
     }
-  }
-
-  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
-        );
+    if (!context.inSSR) {
+      if (modifiers.some((mod) => mod.content === "prop")) {
+        injectPrefix(arg, ".");
       }
-    }
-    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')
-        );
+      if (modifiers.some((mod) => mod.content === "attr")) {
+        injectPrefix(arg, "^");
       }
     }
-  }
-
-  function processComponent (el) {
-    var binding;
-    if ((binding = getBindingAttr(el, 'is'))) {
-      el.component = binding;
-    }
-    if (getAndRemoveAttr(el, 'inline-template') != null) {
-      el.inlineTemplate = true;
+    return {
+      props: [createObjectProperty(arg, exp)]
+    };
+  };
+  const transformBindShorthand = (dir, context) => {
+    const arg = dir.arg;
+    const propName = camelize(arg.content);
+    dir.exp = createSimpleExpression(propName, false, arg.loc);
+  };
+  const injectPrefix = (arg, prefix) => {
+    if (arg.type === 4) {
+      if (arg.isStatic) {
+        arg.content = prefix + arg.content;
+      } else {
+        arg.content = `\`${prefix}\${${arg.content}}\``;
+      }
+    } else {
+      arg.children.unshift(`'${prefix}' + (`);
+      arg.children.push(`)`);
     }
-  }
+  };
 
-  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, '');
+  const transformFor = createStructuralDirectiveTransform(
+    "for",
+    (node, dir, context) => {
+      const { helper, removeHelper } = context;
+      return processFor(node, dir, context, (forNode) => {
+        const renderExp = createCallExpression(helper(RENDER_LIST), [
+          forNode.source
+        ]);
+        const isTemplate = isTemplateNode(node);
+        const memo = findDir(node, "memo");
+        const keyProp = findProp(node, `key`, false, true);
+        const isDirKey = keyProp && keyProp.type === 7;
+        if (isDirKey && !keyProp.exp) {
+          transformBindShorthand(keyProp);
         }
-        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 + "\"")
-            );
+        let keyExp = keyProp && (keyProp.type === 6 ? keyProp.value ? createSimpleExpression(keyProp.value.content, true) : void 0 : keyProp.exp);
+        const keyProperty = keyProp && keyExp ? createObjectProperty(`key`, keyExp) : null;
+        const isStableFragment = forNode.source.type === 4 && forNode.source.constType > 0;
+        const fragmentFlag = isStableFragment ? 64 : keyProp ? 128 : 256;
+        forNode.codegenNode = createVNodeCall(
+          context,
+          helper(FRAGMENT),
+          void 0,
+          renderExp,
+          fragmentFlag,
+          void 0,
+          void 0,
+          true,
+          !isStableFragment,
+          false,
+          node.loc
+        );
+        return () => {
+          let childBlock;
+          const { children } = forNode;
+          if (isTemplate) {
+            node.children.some((c) => {
+              if (c.type === 1) {
+                const key = findProp(c, "key");
+                if (key) {
+                  context.onError(
+                    createCompilerError(
+                      33,
+                      key.loc
+                    )
+                  );
+                  return true;
+                }
+              }
+            });
           }
-          if (modifiers) {
-            if (modifiers.prop && !isDynamic) {
-              name = camelize(name);
-              if (name === 'innerHtml') { name = 'innerHTML'; }
+          const needFragmentWrapper = children.length !== 1 || children[0].type !== 1;
+          const slotOutlet = isSlotOutlet(node) ? node : isTemplate && node.children.length === 1 && isSlotOutlet(node.children[0]) ? node.children[0] : null;
+          if (slotOutlet) {
+            childBlock = slotOutlet.codegenNode;
+            if (isTemplate && keyProperty) {
+              injectProp(childBlock, keyProperty, context);
             }
-            if (modifiers.camel && !isDynamic) {
-              name = camelize(name);
+          } else if (needFragmentWrapper) {
+            childBlock = createVNodeCall(
+              context,
+              helper(FRAGMENT),
+              keyProperty ? createObjectExpression([keyProperty]) : void 0,
+              node.children,
+              64,
+              void 0,
+              void 0,
+              true,
+              void 0,
+              false
+            );
+          } else {
+            childBlock = children[0].codegenNode;
+            if (isTemplate && keyProperty) {
+              injectProp(childBlock, keyProperty, context);
             }
-            if (modifiers.sync) {
-              syncGen = genAssignmentCode(value, "$event");
-              if (!isDynamic) {
-                addHandler(
-                  el,
-                  ("update:" + (camelize(name))),
-                  syncGen,
-                  null,
-                  false,
-                  warn$2,
-                  list[i]
+            if (childBlock.isBlock !== !isStableFragment) {
+              if (childBlock.isBlock) {
+                removeHelper(OPEN_BLOCK);
+                removeHelper(
+                  getVNodeBlockHelper(context.inSSR, childBlock.isComponent)
                 );
-                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
+                removeHelper(
+                  getVNodeHelper(context.inSSR, childBlock.isComponent)
                 );
               }
             }
-          }
-          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;
+            childBlock.isBlock = !isStableFragment;
+            if (childBlock.isBlock) {
+              helper(OPEN_BLOCK);
+              helper(getVNodeBlockHelper(context.inSSR, childBlock.isComponent));
+            } else {
+              helper(getVNodeHelper(context.inSSR, childBlock.isComponent));
             }
           }
-          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]
+          if (memo) {
+            const loop = createFunctionExpression(
+              createForLoopParams(forNode.parseResult, [
+                createSimpleExpression(`_cached`)
+              ])
+            );
+            loop.body = createBlockStatement([
+              createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
+              createCompoundExpression([
+                `if (_cached`,
+                ...keyExp ? [` && _cached.key === `, keyExp] : [],
+                ` && ${context.helperString(
+                IS_MEMO_SAME
+              )}(_cached, _memo)) return _cached`
+              ]),
+              createCompoundExpression([`const _item = `, childBlock]),
+              createSimpleExpression(`_item.memo = _memo`),
+              createSimpleExpression(`return _item`)
+            ]);
+            renderExp.arguments.push(
+              loop,
+              createSimpleExpression(`_cache`),
+              createSimpleExpression(String(context.cached.length))
+            );
+            context.cached.push(null);
+          } else {
+            renderExp.arguments.push(
+              createFunctionExpression(
+                createForLoopParams(forNode.parseResult),
+                childBlock,
+                true
+              )
             );
           }
-        }
-        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 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 processFor(node, dir, context, processCodegen) {
+    if (!dir.exp) {
+      context.onError(
+        createCompilerError(31, dir.loc)
+      );
+      return;
     }
-    return res
+    const parseResult = dir.forParseResult;
+    if (!parseResult) {
+      context.onError(
+        createCompilerError(32, dir.loc)
+      );
+      return;
+    }
+    finalizeForParseResult(parseResult, context);
+    const { addIdentifiers, removeIdentifiers, scopes } = context;
+    const { source, value, key, index } = parseResult;
+    const forNode = {
+      type: 11,
+      loc: dir.loc,
+      source,
+      valueAlias: value,
+      keyAlias: key,
+      objectIndexAlias: index,
+      parseResult,
+      children: isTemplateNode(node) ? node.children : [node]
+    };
+    context.replaceNode(forNode);
+    scopes.vFor++;
+    const onExit = processCodegen && processCodegen(forNode);
+    return () => {
+      scopes.vFor--;
+      if (onExit) onExit();
+    };
   }
-
-  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']
+  function finalizeForParseResult(result, context) {
+    if (result.finalized) return;
+    {
+      validateBrowserExpression(result.source, context);
+      if (result.key) {
+        validateBrowserExpression(
+          result.key,
+          context,
+          true
         );
       }
-      _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 (result.index) {
+        validateBrowserExpression(
+          result.index,
+          context,
+          true
+        );
       }
-
-      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
+      if (result.value) {
+        validateBrowserExpression(
+          result.value,
+          context,
+          true
+        );
       }
     }
+    result.finalized = true;
   }
-
-  function cloneASTElement (el) {
-    return createASTElement(el.tag, el.attrsList.slice(), el.parent)
+  function createForLoopParams({ value, key, index }, memoArgs = []) {
+    return createParamsList([value, key, index, ...memoArgs]);
   }
-
-  var model$1 = {
-    preTransformNode: preTransformNode
-  };
-
-  var modules$1 = [
-    klass$1,
-    style$1,
-    model$1
-  ];
-
-  /*  */
-
-  function text (el, dir) {
-    if (dir.value) {
-      addProp(el, 'textContent', ("_s(" + (dir.value) + ")"), dir);
+  function createParamsList(args) {
+    let i = args.length;
+    while (i--) {
+      if (args[i]) break;
     }
+    return args.slice(0, i + 1).map((arg, i2) => arg || createSimpleExpression(`_`.repeat(i2 + 1), false));
   }
 
-  /*  */
-
-  function html (el, dir) {
-    if (dir.value) {
-      addProp(el, 'innerHTML', ("_s(" + (dir.value) + ")"), dir);
+  const defaultFallback = createSimpleExpression(`undefined`, false);
+  const trackSlotScopes = (node, context) => {
+    if (node.type === 1 && (node.tagType === 1 || node.tagType === 3)) {
+      const vSlot = findDir(node, "slot");
+      if (vSlot) {
+        vSlot.exp;
+        context.scopes.vSlot++;
+        return () => {
+          context.scopes.vSlot--;
+        };
+      }
     }
-  }
-
-  var directives$1 = {
-    model: model,
-    text: text,
-    html: html
-  };
-
-  /*  */
-
-  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)
   };
-
-  /*  */
-
-  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$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;
-          }
-        }
-      }
+  const buildClientSlotFn = (props, _vForExp, children, loc) => createFunctionExpression(
+    props,
+    children,
+    false,
+    true,
+    children.length ? children[0].loc : loc
+  );
+  function buildSlots(node, context, buildSlotFn = buildClientSlotFn) {
+    context.helper(WITH_CTX);
+    const { children, loc } = node;
+    const slotsProperties = [];
+    const dynamicSlots = [];
+    let hasDynamicSlots = context.scopes.vSlot > 0 || context.scopes.vFor > 0;
+    const onComponentSlot = findDir(node, "slot", true);
+    if (onComponentSlot) {
+      const { arg, exp } = onComponentSlot;
+      if (arg && !isStaticExp(arg)) {
+        hasDynamicSlots = true;
+      }
+      slotsProperties.push(
+        createObjectProperty(
+          arg || createSimpleExpression("default", true),
+          buildSlotFn(exp, void 0, children, loc)
+        )
+      );
     }
-  }
-
-  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);
+    let hasTemplateSlots = false;
+    let hasNamedDefaultSlot = false;
+    const implicitDefaultChildren = [];
+    const seenSlotNames = /* @__PURE__ */ new Set();
+    let conditionalBranchIndex = 0;
+    for (let i = 0; i < children.length; i++) {
+      const slotElement = children[i];
+      let slotDir;
+      if (!isTemplateNode(slotElement) || !(slotDir = findDir(slotElement, "slot", true))) {
+        if (slotElement.type !== 3) {
+          implicitDefaultChildren.push(slotElement);
         }
+        continue;
       }
-      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 (onComponentSlot) {
+        context.onError(
+          createCompilerError(37, slotDir.loc)
+        );
+        break;
+      }
+      hasTemplateSlots = true;
+      const { children: slotChildren, loc: slotLoc } = slotElement;
+      const {
+        arg: slotName = createSimpleExpression(`default`, true),
+        exp: slotProps,
+        loc: dirLoc
+      } = slotDir;
+      let staticSlotName;
+      if (isStaticExp(slotName)) {
+        staticSlotName = slotName ? slotName.content : `default`;
+      } else {
+        hasDynamicSlots = true;
+      }
+      const vFor = findDir(slotElement, "for");
+      const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
+      let vIf;
+      let vElse;
+      if (vIf = findDir(slotElement, "if")) {
+        hasDynamicSlots = true;
+        dynamicSlots.push(
+          createConditionalExpression(
+            vIf.exp,
+            buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++),
+            defaultFallback
+          )
+        );
+      } else if (vElse = findDir(
+        slotElement,
+        /^else(-if)?$/,
+        true
+        /* allowEmpty */
+      )) {
+        let j = i;
+        let prev;
+        while (j--) {
+          prev = children[j];
+          if (prev.type !== 3 && isNonWhitespaceContent(prev)) {
+            break;
+          }
+        }
+        if (prev && isTemplateNode(prev) && findDir(prev, /^(else-)?if$/)) {
+          let conditional = dynamicSlots[dynamicSlots.length - 1];
+          while (conditional.alternate.type === 19) {
+            conditional = conditional.alternate;
+          }
+          conditional.alternate = vElse.exp ? createConditionalExpression(
+            vElse.exp,
+            buildDynamicSlot(
+              slotName,
+              slotFunction,
+              conditionalBranchIndex++
+            ),
+            defaultFallback
+          ) : buildDynamicSlot(slotName, slotFunction, conditionalBranchIndex++);
+        } else {
+          context.onError(
+            createCompilerError(30, vElse.loc)
+          );
+        }
+      } else if (vFor) {
+        hasDynamicSlots = true;
+        const parseResult = vFor.forParseResult;
+        if (parseResult) {
+          finalizeForParseResult(parseResult, context);
+          dynamicSlots.push(
+            createCallExpression(context.helper(RENDER_LIST), [
+              parseResult.source,
+              createFunctionExpression(
+                createForLoopParams(parseResult),
+                buildDynamicSlot(slotName, slotFunction),
+                true
+              )
+            ])
+          );
+        } else {
+          context.onError(
+            createCompilerError(
+              32,
+              vFor.loc
+            )
+          );
         }
-      }
-    }
-  }
-
-  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 + ",";
+        if (staticSlotName) {
+          if (seenSlotNames.has(staticSlotName)) {
+            context.onError(
+              createCompilerError(
+                38,
+                dirLoc
+              )
+            );
+            continue;
+          }
+          seenSlotNames.add(staticSlotName);
+          if (staticSlotName === "default") {
+            hasNamedDefaultSlot = true;
+          }
+        }
+        slotsProperties.push(createObjectProperty(slotName, slotFunction));
       }
     }
-    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('||')
+    if (!onComponentSlot) {
+      const buildDefaultSlotProperty = (props, children2) => {
+        const fn = buildSlotFn(props, void 0, children2, loc);
+        return createObjectProperty(`default`, fn);
+      };
+      if (!hasTemplateSlots) {
+        slotsProperties.push(buildDefaultSlotProperty(void 0, children));
+      } else if (implicitDefaultChildren.length && // #3766
+      // with whitespace: 'preserve', whitespaces between slots will end up in
+      // implicitDefaultChildren. Ignore if all implicit children are whitespaces.
+      implicitDefaultChildren.some((node2) => isNonWhitespaceContent(node2))) {
+        if (hasNamedDefaultSlot) {
+          context.onError(
+            createCompilerError(
+              39,
+              implicitDefaultChildren[0].loc
+            )
           );
         } else {
-          keys.push(key);
+          slotsProperties.push(
+            buildDefaultSlotProperty(void 0, implicitDefaultChildren)
+          );
         }
       }
-      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 (
-      // 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)
+    const slotFlag = hasDynamicSlots ? 2 : hasForwardedSlots(node.children) ? 3 : 1;
+    let slots = createObjectExpression(
+      slotsProperties.concat(
+        createObjectProperty(
+          `_`,
+          // 2 = compiled but dynamic = can skip normalization, but must run diff
+          // 1 = compiled and static = can skip normalization AND diff as optimized
+          createSimpleExpression(
+            slotFlag + (` /* ${slotFlagsText[slotFlag]} */` ),
+            false
+          )
+        )
+      ),
+      loc
+    );
+    if (dynamicSlots.length) {
+      slots = createCallExpression(context.helper(CREATE_SLOTS), [
+        slots,
+        createArrayExpression(dynamicSlots)
+      ]);
     }
-    var keyCode = keyCodes[key];
-    var keyName = keyNames[key];
-    return (
-      "_k($event.keyCode," +
-      (JSON.stringify(key)) + "," +
-      (JSON.stringify(keyCode)) + "," +
-      "$event.key," +
-      "" + (JSON.stringify(keyName)) +
-      ")"
-    )
+    return {
+      slots,
+      hasDynamicSlots
+    };
   }
-
-  /*  */
-
-  function on (el, dir) {
-    if (dir.modifiers) {
-      warn("v-on without argument does not support modifiers.");
+  function buildDynamicSlot(name, fn, index) {
+    const props = [
+      createObjectProperty(`name`, name),
+      createObjectProperty(`fn`, fn)
+    ];
+    if (index != null) {
+      props.push(
+        createObjectProperty(`key`, createSimpleExpression(String(index), true))
+      );
     }
-    el.wrapListeners = function (code) { return ("_g(" + code + "," + (dir.value) + ")"); };
+    return createObjectExpression(props);
   }
-
-  /*  */
-
-  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 hasForwardedSlots(children) {
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      switch (child.type) {
+        case 1:
+          if (child.tagType === 2 || hasForwardedSlots(child.children)) {
+            return true;
+          }
+          break;
+        case 9:
+          if (hasForwardedSlots(child.branches)) return true;
+          break;
+        case 10:
+        case 11:
+          if (hasForwardedSlots(child.children)) return true;
+          break;
+      }
+    }
+    return false;
+  }
+  function isNonWhitespaceContent(node) {
+    if (node.type !== 2 && node.type !== 12)
+      return true;
+    return node.type === 2 ? !!node.content.trim() : isNonWhitespaceContent(node.content);
+  }
+
+  const directiveImportMap = /* @__PURE__ */ new WeakMap();
+  const transformElement = (node, context) => {
+    return function postTransformElement() {
+      node = context.currentNode;
+      if (!(node.type === 1 && (node.tagType === 0 || node.tagType === 1))) {
+        return;
+      }
+      const { tag, props } = node;
+      const isComponent = node.tagType === 1;
+      let vnodeTag = isComponent ? resolveComponentType(node, context) : `"${tag}"`;
+      const isDynamicComponent = isObject(vnodeTag) && vnodeTag.callee === RESOLVE_DYNAMIC_COMPONENT;
+      let vnodeProps;
+      let vnodeChildren;
+      let patchFlag = 0;
+      let vnodeDynamicProps;
+      let dynamicPropNames;
+      let vnodeDirectives;
+      let shouldUseBlock = (
+        // dynamic component may resolve to plain elements
+        isDynamicComponent || vnodeTag === TELEPORT || vnodeTag === SUSPENSE || !isComponent && // <svg> and <foreignObject> must be forced into blocks so that block
+        // updates inside get proper isSVG flag at runtime. (#639, #643)
+        // This is technically web-specific, but splitting the logic out of core
+        // leads to too much unnecessary complexity.
+        (tag === "svg" || tag === "foreignObject" || tag === "math")
+      );
+      if (props.length > 0) {
+        const propsBuildResult = buildProps(
+          node,
+          context,
+          void 0,
+          isComponent,
+          isDynamicComponent
+        );
+        vnodeProps = propsBuildResult.props;
+        patchFlag = propsBuildResult.patchFlag;
+        dynamicPropNames = propsBuildResult.dynamicPropNames;
+        const directives = propsBuildResult.directives;
+        vnodeDirectives = directives && directives.length ? createArrayExpression(
+          directives.map((dir) => buildDirectiveArgs(dir, context))
+        ) : void 0;
+        if (propsBuildResult.shouldUseBlock) {
+          shouldUseBlock = true;
+        }
+      }
+      if (node.children.length > 0) {
+        if (vnodeTag === KEEP_ALIVE) {
+          shouldUseBlock = true;
+          patchFlag |= 1024;
+          if (node.children.length > 1) {
+            context.onError(
+              createCompilerError(46, {
+                start: node.children[0].loc.start,
+                end: node.children[node.children.length - 1].loc.end,
+                source: ""
+              })
+            );
+          }
+        }
+        const shouldBuildAsSlots = isComponent && // Teleport is not a real component and has dedicated runtime handling
+        vnodeTag !== TELEPORT && // explained above.
+        vnodeTag !== KEEP_ALIVE;
+        if (shouldBuildAsSlots) {
+          const { slots, hasDynamicSlots } = buildSlots(node, context);
+          vnodeChildren = slots;
+          if (hasDynamicSlots) {
+            patchFlag |= 1024;
+          }
+        } else if (node.children.length === 1 && vnodeTag !== TELEPORT) {
+          const child = node.children[0];
+          const type = child.type;
+          const hasDynamicTextChild = type === 5 || type === 8;
+          if (hasDynamicTextChild && getConstantType(child, context) === 0) {
+            patchFlag |= 1;
+          }
+          if (hasDynamicTextChild || type === 2) {
+            vnodeChildren = child;
+          } else {
+            vnodeChildren = node.children;
+          }
+        } else {
+          vnodeChildren = node.children;
+        }
+      }
+      if (dynamicPropNames && dynamicPropNames.length) {
+        vnodeDynamicProps = stringifyDynamicPropNames(dynamicPropNames);
+      }
+      node.codegenNode = createVNodeCall(
+        context,
+        vnodeTag,
+        vnodeProps,
+        vnodeChildren,
+        patchFlag === 0 ? void 0 : patchFlag,
+        vnodeDynamicProps,
+        vnodeDirectives,
+        !!shouldUseBlock,
+        false,
+        isComponent,
+        node.loc
+      );
     };
-  }
-
-  /*  */
-
-  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$2(el, state);
+  function resolveComponentType(node, context, ssr = false) {
+    let { tag } = node;
+    const isExplicitDynamic = isComponentTag(tag);
+    const isProp = findProp(
+      node,
+      "is",
+      false,
+      true
+      /* allow empty */
+    );
+    if (isProp) {
+      if (isExplicitDynamic || false) {
+        let exp;
+        if (isProp.type === 6) {
+          exp = isProp.value && createSimpleExpression(isProp.value.content, true);
+        } else {
+          exp = isProp.exp;
+          if (!exp) {
+            exp = createSimpleExpression(`is`, false, isProp.arg.loc);
+          }
         }
-
-        var children = el.inlineTemplate ? null : genChildren(el, state, true);
-        code = "_c('" + (el.tag) + "'" + (data ? ("," + data) : '') + (children ? ("," + children) : '') + ")";
+        if (exp) {
+          return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
+            exp
+          ]);
+        }
+      } else if (isProp.type === 6 && isProp.value.content.startsWith("vue:")) {
+        tag = isProp.value.content.slice(4);
+      }
+    }
+    const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
+    if (builtIn) {
+      if (!ssr) context.helper(builtIn);
+      return builtIn;
+    }
+    context.helper(RESOLVE_COMPONENT);
+    context.components.add(tag);
+    return toValidAssetId(tag, `component`);
+  }
+  function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
+    const { tag, loc: elementLoc, children } = node;
+    let properties = [];
+    const mergeArgs = [];
+    const runtimeDirectives = [];
+    const hasChildren = children.length > 0;
+    let shouldUseBlock = false;
+    let patchFlag = 0;
+    let hasRef = false;
+    let hasClassBinding = false;
+    let hasStyleBinding = false;
+    let hasHydrationEventBinding = false;
+    let hasDynamicKeys = false;
+    let hasVnodeHook = false;
+    const dynamicPropNames = [];
+    const pushMergeArg = (arg) => {
+      if (properties.length) {
+        mergeArgs.push(
+          createObjectExpression(dedupeProperties(properties), elementLoc)
+        );
+        properties = [];
       }
-      // module transforms
-      for (var i = 0; i < state.transforms.length; i++) {
-        code = state.transforms[i](el, code);
+      if (arg) mergeArgs.push(arg);
+    };
+    const pushRefVForMarker = () => {
+      if (context.scopes.vFor > 0) {
+        properties.push(
+          createObjectProperty(
+            createSimpleExpression("ref_for", true),
+            createSimpleExpression("true")
+          )
+        );
       }
-      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
+    };
+    const analyzePatchFlag = ({ key, value }) => {
+      if (isStaticExp(key)) {
+        const name = key.content;
+        const isEventHandler = isOn(name);
+        if (isEventHandler && (!isComponent || isDynamicComponent) && // omit the flag for click handlers because hydration gives click
+        // dedicated fast path.
+        name.toLowerCase() !== "onclick" && // omit v-model handlers
+        name !== "onUpdate:modelValue" && // omit onVnodeXXX hooks
+        !isReservedProp(name)) {
+          hasHydrationEventBinding = true;
+        }
+        if (isEventHandler && isReservedProp(name)) {
+          hasVnodeHook = true;
+        }
+        if (isEventHandler && value.type === 14) {
+          value = value.arguments[0];
+        }
+        if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
+          return;
+        }
+        if (name === "ref") {
+          hasRef = true;
+        } else if (name === "class") {
+          hasClassBinding = true;
+        } else if (name === "style") {
+          hasStyleBinding = true;
+        } else if (name !== "key" && !dynamicPropNames.includes(name)) {
+          dynamicPropNames.push(name);
+        }
+        if (isComponent && (name === "class" || name === "style") && !dynamicPropNames.includes(name)) {
+          dynamicPropNames.push(name);
+        }
+      } else {
+        hasDynamicKeys = true;
+      }
+    };
+    for (let i = 0; i < props.length; i++) {
+      const prop = props[i];
+      if (prop.type === 6) {
+        const { loc, name, nameLoc, value } = prop;
+        let isStatic = true;
+        if (name === "ref") {
+          hasRef = true;
+          pushRefVForMarker();
+        }
+        if (name === "is" && (isComponentTag(tag) || value && value.content.startsWith("vue:") || false)) {
+          continue;
+        }
+        properties.push(
+          createObjectProperty(
+            createSimpleExpression(name, true, nameLoc),
+            createSimpleExpression(
+              value ? value.content : "",
+              isStatic,
+              value ? value.loc : loc
+            )
+          )
+        );
+      } else {
+        const { name, arg, exp, loc, modifiers } = prop;
+        const isVBind = name === "bind";
+        const isVOn = name === "on";
+        if (name === "slot") {
+          if (!isComponent) {
+            context.onError(
+              createCompilerError(40, loc)
+            );
+          }
+          continue;
+        }
+        if (name === "once" || name === "memo") {
+          continue;
+        }
+        if (name === "is" || isVBind && isStaticArgOf(arg, "is") && (isComponentTag(tag) || false)) {
+          continue;
+        }
+        if (isVOn && ssr) {
+          continue;
+        }
+        if (
+          // #938: elements with dynamic keys should be forced into blocks
+          isVBind && isStaticArgOf(arg, "key") || // inline before-update hooks need to force block so that it is invoked
+          // before children
+          isVOn && hasChildren && isStaticArgOf(arg, "vue:before-update")
+        ) {
+          shouldUseBlock = true;
+        }
+        if (isVBind && isStaticArgOf(arg, "ref")) {
+          pushRefVForMarker();
+        }
+        if (!arg && (isVBind || isVOn)) {
+          hasDynamicKeys = true;
+          if (exp) {
+            if (isVBind) {
+              pushRefVForMarker();
+              pushMergeArg();
+              mergeArgs.push(exp);
+            } else {
+              pushMergeArg({
+                type: 14,
+                loc,
+                callee: context.helper(TO_HANDLERS),
+                arguments: isComponent ? [exp] : [exp, `true`]
+              });
+            }
+          } else {
+            context.onError(
+              createCompilerError(
+                isVBind ? 34 : 35,
+                loc
+              )
+            );
+          }
+          continue;
+        }
+        if (isVBind && modifiers.some((mod) => mod.content === "prop")) {
+          patchFlag |= 32;
+        }
+        const directiveTransform = context.directiveTransforms[name];
+        if (directiveTransform) {
+          const { props: props2, needRuntime } = directiveTransform(prop, node, context);
+          !ssr && props2.forEach(analyzePatchFlag);
+          if (isVOn && arg && !isStaticExp(arg)) {
+            pushMergeArg(createObjectExpression(props2, elementLoc));
+          } else {
+            properties.push(...props2);
+          }
+          if (needRuntime) {
+            runtimeDirectives.push(prop);
+            if (isSymbol(needRuntime)) {
+              directiveImportMap.set(prop, needRuntime);
+            }
+          }
+        } else if (!isBuiltInDirective(name)) {
+          runtimeDirectives.push(prop);
+          if (hasChildren) {
+            shouldUseBlock = true;
+          }
         }
-        parent = parent.parent;
       }
-      if (!key) {
-        state.warn(
-          "v-once can only be used inside v-for that is keyed. ",
-          el.rawAttrsMap['v-once']
+    }
+    let propsExpression = void 0;
+    if (mergeArgs.length) {
+      pushMergeArg();
+      if (mergeArgs.length > 1) {
+        propsExpression = createCallExpression(
+          context.helper(MERGE_PROPS),
+          mergeArgs,
+          elementLoc
         );
-        return genElement(el, state)
+      } else {
+        propsExpression = mergeArgs[0];
       }
-      return ("_o(" + (genElement(el, state)) + "," + (state.onceId++) + "," + key + ")")
+    } else if (properties.length) {
+      propsExpression = createObjectExpression(
+        dedupeProperties(properties),
+        elementLoc
+      );
+    }
+    if (hasDynamicKeys) {
+      patchFlag |= 16;
     } else {
-      return genStatic(el, state)
+      if (hasClassBinding && !isComponent) {
+        patchFlag |= 2;
+      }
+      if (hasStyleBinding && !isComponent) {
+        patchFlag |= 4;
+      }
+      if (dynamicPropNames.length) {
+        patchFlag |= 8;
+      }
+      if (hasHydrationEventBinding) {
+        patchFlag |= 32;
+      }
+    }
+    if (!shouldUseBlock && (patchFlag === 0 || patchFlag === 32) && (hasRef || hasVnodeHook || runtimeDirectives.length > 0)) {
+      patchFlag |= 512;
+    }
+    if (!context.inSSR && propsExpression) {
+      switch (propsExpression.type) {
+        case 15:
+          let classKeyIndex = -1;
+          let styleKeyIndex = -1;
+          let hasDynamicKey = false;
+          for (let i = 0; i < propsExpression.properties.length; i++) {
+            const key = propsExpression.properties[i].key;
+            if (isStaticExp(key)) {
+              if (key.content === "class") {
+                classKeyIndex = i;
+              } else if (key.content === "style") {
+                styleKeyIndex = i;
+              }
+            } else if (!key.isHandlerKey) {
+              hasDynamicKey = true;
+            }
+          }
+          const classProp = propsExpression.properties[classKeyIndex];
+          const styleProp = propsExpression.properties[styleKeyIndex];
+          if (!hasDynamicKey) {
+            if (classProp && !isStaticExp(classProp.value)) {
+              classProp.value = createCallExpression(
+                context.helper(NORMALIZE_CLASS),
+                [classProp.value]
+              );
+            }
+            if (styleProp && // the static style is compiled into an object,
+            // so use `hasStyleBinding` to ensure that it is a dynamic style binding
+            (hasStyleBinding || styleProp.value.type === 4 && styleProp.value.content.trim()[0] === `[` || // v-bind:style and style both exist,
+            // v-bind:style with static literal object
+            styleProp.value.type === 17)) {
+              styleProp.value = createCallExpression(
+                context.helper(NORMALIZE_STYLE),
+                [styleProp.value]
+              );
+            }
+          } else {
+            propsExpression = createCallExpression(
+              context.helper(NORMALIZE_PROPS),
+              [propsExpression]
+            );
+          }
+          break;
+        case 14:
+          break;
+        default:
+          propsExpression = createCallExpression(
+            context.helper(NORMALIZE_PROPS),
+            [
+              createCallExpression(context.helper(GUARD_REACTIVE_PROPS), [
+                propsExpression
+              ])
+            ]
+          );
+          break;
+      }
     }
+    return {
+      props: propsExpression,
+      directives: runtimeDirectives,
+      patchFlag,
+      dynamicPropNames,
+      shouldUseBlock
+    };
   }
-
-  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()'
+  function dedupeProperties(properties) {
+    const knownProps = /* @__PURE__ */ new Map();
+    const deduped = [];
+    for (let i = 0; i < properties.length; i++) {
+      const prop = properties[i];
+      if (prop.key.type === 8 || !prop.key.isStatic) {
+        deduped.push(prop);
+        continue;
+      }
+      const name = prop.key.content;
+      const existing = knownProps.get(name);
+      if (existing) {
+        if (name === "style" || name === "class" || isOn(name)) {
+          mergeAsArray(existing, prop);
+        }
+      } else {
+        knownProps.set(name, prop);
+        deduped.push(prop);
+      }
     }
-
-    var condition = conditions.shift();
-    if (condition.exp) {
-      return ("(" + (condition.exp) + ")?" + (genTernaryExp(condition.block)) + ":" + (genIfConditions(conditions, state, altGen, altEmpty)))
+    return deduped;
+  }
+  function mergeAsArray(existing, incoming) {
+    if (existing.value.type === 17) {
+      existing.value.elements.push(incoming.value);
     } 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 */
+      existing.value = createArrayExpression(
+        [existing.value, incoming.value],
+        existing.loc
       );
     }
-
-    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 buildDirectiveArgs(dir, context) {
+    const dirArgs = [];
+    const runtime = directiveImportMap.get(dir);
+    if (runtime) {
+      dirArgs.push(context.helperString(runtime));
+    } else {
+      {
+        context.helper(RESOLVE_DIRECTIVE);
+        context.directives.add(dir.name);
+        dirArgs.push(toValidAssetId(dir.name, `directive`));
       }
     }
-    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)) + ")";
+    const { loc } = dir;
+    if (dir.exp) dirArgs.push(dir.exp);
+    if (dir.arg) {
+      if (!dir.exp) {
+        dirArgs.push(`void 0`);
+      }
+      dirArgs.push(dir.arg);
     }
-    // v-bind data wrap
-    if (el.wrapData) {
-      data = el.wrapData(data);
+    if (Object.keys(dir.modifiers).length) {
+      if (!dir.arg) {
+        if (!dir.exp) {
+          dirArgs.push(`void 0`);
+        }
+        dirArgs.push(`void 0`);
+      }
+      const trueExpression = createSimpleExpression(`true`, false, loc);
+      dirArgs.push(
+        createObjectExpression(
+          dir.modifiers.map(
+            (modifier) => createObjectProperty(modifier, trueExpression)
+          ),
+          loc
+        )
+      );
     }
-    // v-on data wrap
-    if (el.wrapListeners) {
-      data = el.wrapListeners(data);
+    return createArrayExpression(dirArgs, dir.loc);
+  }
+  function stringifyDynamicPropNames(props) {
+    let propsNamesString = `[`;
+    for (let i = 0, l = props.length; i < l; i++) {
+      propsNamesString += JSON.stringify(props[i]);
+      if (i < l - 1) propsNamesString += ", ";
+    }
+    return propsNamesString + `]`;
+  }
+  function isComponentTag(tag) {
+    return tag === "component" || tag === "Component";
+  }
+
+  const transformSlotOutlet = (node, context) => {
+    if (isSlotOutlet(node)) {
+      const { children, loc } = node;
+      const { slotName, slotProps } = processSlotOutlet(node, context);
+      const slotArgs = [
+        context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
+        slotName,
+        "{}",
+        "undefined",
+        "true"
+      ];
+      let expectedLen = 2;
+      if (slotProps) {
+        slotArgs[2] = slotProps;
+        expectedLen = 3;
+      }
+      if (children.length) {
+        slotArgs[3] = createFunctionExpression([], children, false, false, loc);
+        expectedLen = 4;
+      }
+      if (context.scopeId && !context.slotted) {
+        expectedLen = 5;
+      }
+      slotArgs.splice(expectedLen);
+      node.codegenNode = createCallExpression(
+        context.helper(RENDER_SLOT),
+        slotArgs,
+        loc
+      );
     }
-    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);
+  };
+  function processSlotOutlet(node, context) {
+    let slotName = `"default"`;
+    let slotProps = void 0;
+    const nonNameProps = [];
+    for (let i = 0; i < node.props.length; i++) {
+      const p = node.props[i];
+      if (p.type === 6) {
+        if (p.value) {
+          if (p.name === "name") {
+            slotName = JSON.stringify(p.value.content);
+          } else {
+            p.name = camelize(p.name);
+            nonNameProps.push(p);
+          }
+        }
+      } else {
+        if (p.name === "bind" && isStaticArgOf(p.arg, "name")) {
+          if (p.exp) {
+            slotName = p.exp;
+          } else if (p.arg && p.arg.type === 4) {
+            const name = camelize(p.arg.content);
+            slotName = p.exp = createSimpleExpression(name, false, p.arg.loc);
+          }
+        } else {
+          if (p.name === "bind" && p.arg && isStaticExp(p.arg)) {
+            p.arg.content = camelize(p.arg.content);
+          }
+          nonNameProps.push(p);
+        }
       }
-      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 (nonNameProps.length > 0) {
+      const { props, directives } = buildProps(
+        node,
+        context,
+        nonNameProps,
+        false,
+        false
+      );
+      slotProps = props;
+      if (directives.length) {
+        context.onError(
+          createCompilerError(
+            36,
+            directives[0].loc
+          )
+        );
       }
     }
-    if (hasRuntime) {
-      return res.slice(0, -1) + ']'
-    }
+    return {
+      slotName,
+      slotProps
+    };
   }
 
-  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 }
-      );
+  const transformOn$1 = (dir, node, context, augmentor) => {
+    const { loc, modifiers, arg } = dir;
+    if (!dir.exp && !modifiers.length) {
+      context.onError(createCompilerError(35, loc));
     }
-    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
+    let eventName;
+    if (arg.type === 4) {
+      if (arg.isStatic) {
+        let rawName = arg.content;
+        if (rawName.startsWith("vnode")) {
+          context.onError(createCompilerError(51, arg.loc));
         }
-        if (parent.if) {
-          needsKey = true;
+        if (rawName.startsWith("vue:")) {
+          rawName = `vnode-${rawName.slice(4)}`;
         }
-        parent = parent.parent;
+        const eventString = node.tagType !== 0 || rawName.startsWith("vnode") || !/[A-Z]/.test(rawName) ? (
+          // for non-element and vnode lifecycle event listeners, auto convert
+          // it to camelCase. See issue #2249
+          toHandlerKey(camelize(rawName))
+        ) : (
+          // preserve case for plain element listeners that have uppercase
+          // letters, as these may be custom elements' custom events
+          `on:${rawName}`
+        );
+        eventName = createSimpleExpression(eventString, true, arg.loc);
+      } else {
+        eventName = createCompoundExpression([
+          `${context.helperString(TO_HANDLER_KEY)}(`,
+          arg,
+          `)`
+        ]);
       }
+    } else {
+      eventName = arg;
+      eventName.children.unshift(`${context.helperString(TO_HANDLER_KEY)}(`);
+      eventName.children.push(`)`);
     }
-
-    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);
+    let exp = dir.exp;
+    if (exp && !exp.content.trim()) {
+      exp = void 0;
     }
-    return hash >>> 0
-  }
-
-  function containsSlotChild (el) {
-    if (el.type === 1) {
-      if (el.tag === 'slot') {
-        return true
+    let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
+    if (exp) {
+      const isMemberExp = isMemberExpression(exp);
+      const isInlineStatement = !(isMemberExp || isFnExpression(exp));
+      const hasMultipleStatements = exp.content.includes(`;`);
+      {
+        validateBrowserExpression(
+          exp,
+          context,
+          false,
+          hasMultipleStatements
+        );
+      }
+      if (isInlineStatement || shouldCache && isMemberExp) {
+        exp = createCompoundExpression([
+          `${isInlineStatement ? `$event` : `${``}(...args)`} => ${hasMultipleStatements ? `{` : `(`}`,
+          exp,
+          hasMultipleStatements ? `}` : `)`
+        ]);
       }
-      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")
+    let ret = {
+      props: [
+        createObjectProperty(
+          eventName,
+          exp || createSimpleExpression(`() => {}`, false, loc)
+        )
+      ]
+    };
+    if (augmentor) {
+      ret = augmentor(ret);
     }
-    if (el.for && !el.forProcessed) {
-      return genFor(el, state, genScopedSlot)
+    if (shouldCache) {
+      ret.props[0].value = context.cache(ret.props[0].value);
     }
-    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 + "}")
-  }
+    ret.props.forEach((p) => p.key.isHandlerKey = true);
+    return ret;
+  };
 
-  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) : ''))
+  const transformText = (node, context) => {
+    if (node.type === 0 || node.type === 1 || node.type === 11 || node.type === 10) {
+      return () => {
+        const children = node.children;
+        let currentContainer = void 0;
+        let hasText = false;
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+          if (isText$1(child)) {
+            hasText = true;
+            for (let j = i + 1; j < children.length; j++) {
+              const next = children[j];
+              if (isText$1(next)) {
+                if (!currentContainer) {
+                  currentContainer = children[i] = createCompoundExpression(
+                    [child],
+                    child.loc
+                  );
+                }
+                currentContainer.children.push(` + `, next);
+                children.splice(j, 1);
+                j--;
+              } else {
+                currentContainer = void 0;
+                break;
+              }
+            }
+          }
+        }
+        if (!hasText || // if this is a plain element with a single text child, leave it
+        // as-is since the runtime has dedicated fast path for this by directly
+        // setting textContent of the element.
+        // for component root it's always normalized anyway.
+        children.length === 1 && (node.type === 0 || node.type === 1 && node.tagType === 0 && // #3756
+        // custom directives can potentially add DOM elements arbitrarily,
+        // we need to avoid setting textContent of the element at runtime
+        // to avoid accidentally overwriting the DOM elements added
+        // by the user through custom directives.
+        !node.props.find(
+          (p) => p.type === 7 && !context.directiveTransforms[p.name]
+        ) && // in compat mode, <template> tags with no special directives
+        // will be rendered as a fragment so its children must be
+        // converted into vnodes.
+        true)) {
+          return;
+        }
+        for (let i = 0; i < children.length; i++) {
+          const child = children[i];
+          if (isText$1(child) || child.type === 8) {
+            const callArgs = [];
+            if (child.type !== 2 || child.content !== " ") {
+              callArgs.push(child);
+            }
+            if (!context.ssr && getConstantType(child, context) === 0) {
+              callArgs.push(
+                1 + (` /* ${PatchFlagNames[1]} */` )
+              );
+            }
+            children[i] = {
+              type: 12,
+              content: child,
+              loc: child.loc,
+              codegenNode: createCallExpression(
+                context.helper(CREATE_TEXT),
+                callArgs
+              )
+            };
+          }
+        }
+      };
     }
-  }
+  };
 
-  // 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;
-      }
+  const seen$1 = /* @__PURE__ */ new WeakSet();
+  const transformOnce = (node, context) => {
+    if (node.type === 1 && findDir(node, "once", true)) {
+      if (seen$1.has(node) || context.inVOnce || context.inSSR) {
+        return;
+      }
+      seen$1.add(node);
+      context.inVOnce = true;
+      context.helper(SET_BLOCK_TRACKING);
+      return () => {
+        context.inVOnce = false;
+        const cur = context.currentNode;
+        if (cur.codegenNode) {
+          cur.codegenNode = context.cache(
+            cur.codegenNode,
+            true,
+            true
+          );
+        }
+      };
     }
-    return res
-  }
+  };
 
-  function needsNormalization (el) {
-    return el.for !== undefined || el.tag === 'template' || el.tag === 'slot'
+  const transformModel$1 = (dir, node, context) => {
+    const { exp, arg } = dir;
+    if (!exp) {
+      context.onError(
+        createCompilerError(41, dir.loc)
+      );
+      return createTransformProps();
+    }
+    const rawExp = exp.loc.source.trim();
+    const expString = exp.type === 4 ? exp.content : rawExp;
+    const bindingType = context.bindingMetadata[rawExp];
+    if (bindingType === "props" || bindingType === "props-aliased") {
+      context.onError(createCompilerError(44, exp.loc));
+      return createTransformProps();
+    }
+    if (!expString.trim() || !isMemberExpression(exp) && true) {
+      context.onError(
+        createCompilerError(42, exp.loc)
+      );
+      return createTransformProps();
+    }
+    const propName = arg ? arg : createSimpleExpression("modelValue", true);
+    const eventName = arg ? isStaticExp(arg) ? `onUpdate:${camelize(arg.content)}` : createCompoundExpression(['"onUpdate:" + ', arg]) : `onUpdate:modelValue`;
+    let assignmentExp;
+    const eventArg = context.isTS ? `($event: any)` : `$event`;
+    {
+      assignmentExp = createCompoundExpression([
+        `${eventArg} => ((`,
+        exp,
+        `) = $event)`
+      ]);
+    }
+    const props = [
+      // modelValue: foo
+      createObjectProperty(propName, dir.exp),
+      // "onUpdate:modelValue": $event => (foo = $event)
+      createObjectProperty(eventName, assignmentExp)
+    ];
+    if (dir.modifiers.length && node.tagType === 1) {
+      const modifiers = dir.modifiers.map((m) => m.content).map((m) => (isSimpleIdentifier(m) ? m : JSON.stringify(m)) + `: true`).join(`, `);
+      const modifiersKey = arg ? isStaticExp(arg) ? `${arg.content}Modifiers` : createCompoundExpression([arg, ' + "Modifiers"']) : `modelModifiers`;
+      props.push(
+        createObjectProperty(
+          modifiersKey,
+          createSimpleExpression(
+            `{ ${modifiers} }`,
+            false,
+            dir.loc,
+            2
+          )
+        )
+      );
+    }
+    return createTransformProps(props);
+  };
+  function createTransformProps(props = []) {
+    return { props };
   }
 
-  function genNode (node, state) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const transformMemo = (node, context) => {
     if (node.type === 1) {
-      return genElement(node, state)
-    } else if (node.type === 3 && node.isComment) {
-      return genComment(node)
-    } else {
-      return genText(node)
+      const dir = findDir(node, "memo");
+      if (!dir || seen.has(node)) {
+        return;
+      }
+      seen.add(node);
+      return () => {
+        const codegenNode = node.codegenNode || context.currentNode.codegenNode;
+        if (codegenNode && codegenNode.type === 13) {
+          if (node.tagType !== 1) {
+            convertToBlock(codegenNode, context);
+          }
+          node.codegenNode = createCallExpression(context.helper(WITH_MEMO), [
+            dir.exp,
+            createFunctionExpression(void 0, codegenNode),
+            `_cache`,
+            String(context.cached.length)
+          ]);
+          context.cached.push(null);
+        }
+      };
     }
-  }
-
-  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 getBaseTransformPreset(prefixIdentifiers) {
+    return [
+      [
+        transformOnce,
+        transformIf,
+        transformMemo,
+        transformFor,
+        ...[],
+        ...[transformExpression] ,
+        transformSlotOutlet,
+        transformElement,
+        trackSlotScopes,
+        transformText
+      ],
+      {
+        on: transformOn$1,
+        bind: transformBind,
+        model: transformModel$1
+      }
+    ];
   }
-
-  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";
+  function baseCompile(source, options = {}) {
+    const onError = options.onError || defaultOnError;
+    const isModuleMode = options.mode === "module";
+    {
+      if (options.prefixIdentifiers === true) {
+        onError(createCompilerError(47));
+      } else if (isModuleMode) {
+        onError(createCompilerError(48));
+      }
     }
-    if (attrs) {
-      res += "," + attrs;
+    const prefixIdentifiers = false;
+    if (options.cacheHandlers) {
+      onError(createCompilerError(49));
     }
-    if (bind$$1) {
-      res += (attrs ? '' : ',null') + "," + bind$$1;
+    if (options.scopeId && !isModuleMode) {
+      onError(createCompilerError(50));
     }
-    return res + ')'
+    const resolvedOptions = extend({}, options, {
+      prefixIdentifiers
+    });
+    const ast = isString(source) ? baseParse(source, resolvedOptions) : source;
+    const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
+    transform(
+      ast,
+      extend({}, resolvedOptions, {
+        nodeTransforms: [
+          ...nodeTransforms,
+          ...options.nodeTransforms || []
+          // user transforms
+        ],
+        directiveTransforms: extend(
+          {},
+          directiveTransforms,
+          options.directiveTransforms || {}
+          // user transforms
+        )
+      })
+    );
+    return generate(ast, resolvedOptions);
   }
 
-  // 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) : '') + ")")
-  }
+  const noopDirectiveTransform = () => ({ props: [] });
 
-  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 + ",";
-      }
+  const V_MODEL_RADIO = Symbol(`vModelRadio` );
+  const V_MODEL_CHECKBOX = Symbol(
+    `vModelCheckbox` 
+  );
+  const V_MODEL_TEXT = Symbol(`vModelText` );
+  const V_MODEL_SELECT = Symbol(
+    `vModelSelect` 
+  );
+  const V_MODEL_DYNAMIC = Symbol(
+    `vModelDynamic` 
+  );
+  const V_ON_WITH_MODIFIERS = Symbol(
+    `vOnModifiersGuard` 
+  );
+  const V_ON_WITH_KEYS = Symbol(
+    `vOnKeysGuard` 
+  );
+  const V_SHOW = Symbol(`vShow` );
+  const TRANSITION = Symbol(`Transition` );
+  const TRANSITION_GROUP = Symbol(
+    `TransitionGroup` 
+  );
+  registerRuntimeHelpers({
+    [V_MODEL_RADIO]: `vModelRadio`,
+    [V_MODEL_CHECKBOX]: `vModelCheckbox`,
+    [V_MODEL_TEXT]: `vModelText`,
+    [V_MODEL_SELECT]: `vModelSelect`,
+    [V_MODEL_DYNAMIC]: `vModelDynamic`,
+    [V_ON_WITH_MODIFIERS]: `withModifiers`,
+    [V_ON_WITH_KEYS]: `withKeys`,
+    [V_SHOW]: `vShow`,
+    [TRANSITION]: `Transition`,
+    [TRANSITION_GROUP]: `TransitionGroup`
+  });
+
+  let decoder;
+  function decodeHtmlBrowser(raw, asAttr = false) {
+    if (!decoder) {
+      decoder = document.createElement("div");
     }
-    staticProps = "{" + (staticProps.slice(0, -1)) + "}";
-    if (dynamicProps) {
-      return ("_d(" + staticProps + ",[" + (dynamicProps.slice(0, -1)) + "])")
+    if (asAttr) {
+      decoder.innerHTML = `<div foo="${raw.replace(/"/g, "&quot;")}">`;
+      return decoder.children[0].getAttribute("foo");
     } 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);
+      decoder.innerHTML = raw;
+      return decoder.textContent;
     }
   }
 
-  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 (onRE.test(name)) {
-              checkEvent(value, (name + "=\"" + value + "\""), warn, range);
-            } else {
-              checkExpression(value, (name + "=\"" + value + "\""), warn, range);
-            }
+  const parserOptions = {
+    parseMode: "html",
+    isVoidTag,
+    isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag) || isMathMLTag(tag),
+    isPreTag: (tag) => tag === "pre",
+    isIgnoreNewlineTag: (tag) => tag === "pre" || tag === "textarea",
+    decodeEntities: decodeHtmlBrowser ,
+    isBuiltInComponent: (tag) => {
+      if (tag === "Transition" || tag === "transition") {
+        return TRANSITION;
+      } else if (tag === "TransitionGroup" || tag === "transition-group") {
+        return TRANSITION_GROUP;
+      }
+    },
+    // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
+    getNamespace(tag, parent, rootNamespace) {
+      let ns = parent ? parent.ns : rootNamespace;
+      if (parent && ns === 2) {
+        if (parent.tag === "annotation-xml") {
+          if (tag === "svg") {
+            return 1;
           }
+          if (parent.props.some(
+            (a) => a.type === 6 && a.name === "encoding" && a.value != null && (a.value.content === "text/html" || a.value.content === "application/xhtml+xml")
+          )) {
+            ns = 0;
+          }
+        } else if (/^m(?:[ions]|text)$/.test(parent.tag) && tag !== "mglyph" && tag !== "malignmark") {
+          ns = 0;
+        }
+      } else if (parent && ns === 1) {
+        if (parent.tag === "foreignObject" || parent.tag === "desc" || parent.tag === "title") {
+          ns = 0;
         }
       }
-      if (node.children) {
-        for (var i = 0; i < node.children.length; i++) {
-          checkNode(node.children[i], warn);
+      if (ns === 0) {
+        if (tag === "svg") {
+          return 1;
+        }
+        if (tag === "math") {
+          return 2;
         }
       }
-    } else if (node.type === 2) {
-      checkExpression(node.expression, node.text, warn, node);
+      return ns;
     }
-  }
+  };
 
-  function checkEvent (exp, text, warn, range) {
-    var stipped = exp.replace(stripStringRE, '');
-    var keywordMatch = stipped.match(unaryOperatorsRE);
-    if (keywordMatch && stipped.charAt(keywordMatch.index - 1) !== '$') {
-      warn(
-        "avoid using JavaScript unary operator as property name: " +
-        "\"" + (keywordMatch[0]) + "\" in expression " + (text.trim()),
-        range
-      );
+  const transformStyle = (node) => {
+    if (node.type === 1) {
+      node.props.forEach((p, i) => {
+        if (p.type === 6 && p.name === "style" && p.value) {
+          node.props[i] = {
+            type: 7,
+            name: `bind`,
+            arg: createSimpleExpression(`style`, true, p.loc),
+            exp: parseInlineCSS(p.value.content, p.loc),
+            modifiers: [],
+            loc: p.loc
+          };
+        }
+      });
     }
-    checkExpression(exp, text, warn, range);
-  }
+  };
+  const parseInlineCSS = (cssText, loc) => {
+    const normalized = parseStringStyle(cssText);
+    return createSimpleExpression(
+      JSON.stringify(normalized),
+      false,
+      loc,
+      3
+    );
+  };
 
-  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 createDOMCompilerError(code, loc) {
+    return createCompilerError(
+      code,
+      loc,
+      DOMErrorMessages 
+    );
   }
+  const DOMErrorMessages = {
+    [53]: `v-html is missing expression.`,
+    [54]: `v-html will override element children.`,
+    [55]: `v-text is missing expression.`,
+    [56]: `v-text will override element children.`,
+    [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+    [58]: `v-model argument is not supported on plain elements.`,
+    [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+    [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+    [61]: `v-show is missing expression.`,
+    [62]: `<Transition> expects exactly one child element or component.`,
+    [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+  };
 
-  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);
-      }
+  const transformVHtml = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+      context.onError(
+        createDOMCompilerError(53, loc)
+      );
     }
-  }
-
-  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
-        );
-      }
+    if (node.children.length) {
+      context.onError(
+        createDOMCompilerError(54, loc)
+      );
+      node.children.length = 0;
     }
-  }
-
-  /*  */
-
-  var range = 2;
-
-  function generateCodeFrame (
-    source,
-    start,
-    end
-  ) {
-    if ( start === void 0 ) start = 0;
-    if ( end === void 0 ) end = source.length;
+    return {
+      props: [
+        createObjectProperty(
+          createSimpleExpression(`innerHTML`, true, loc),
+          exp || createSimpleExpression("", true)
+        )
+      ]
+    };
+  };
 
-    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
-      }
+  const transformVText = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+      context.onError(
+        createDOMCompilerError(55, loc)
+      );
     }
-    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;
-      }
+    if (node.children.length) {
+      context.onError(
+        createDOMCompilerError(56, loc)
+      );
+      node.children.length = 0;
     }
-    return result
-  }
-
-  /*  */
-
-
+    return {
+      props: [
+        createObjectProperty(
+          createSimpleExpression(`textContent`, true),
+          exp ? getConstantType(exp, context) > 0 ? exp : createCallExpression(
+            context.helperString(TO_DISPLAY_STRING),
+            [exp],
+            loc
+          ) : createSimpleExpression("", true)
+        )
+      ]
+    };
+  };
 
-  function createFunction (code, errors) {
-    try {
-      return new Function(code)
-    } catch (err) {
-      errors.push({ err: err, code: code });
-      return noop
+  const transformModel = (dir, node, context) => {
+    const baseResult = transformModel$1(dir, node, context);
+    if (!baseResult.props.length || node.tagType === 1) {
+      return baseResult;
     }
-  }
-
-  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 (dir.arg) {
+      context.onError(
+        createDOMCompilerError(
+          58,
+          dir.arg.loc
+        )
+      );
+    }
+    function checkDuplicatedValue() {
+      const value = findDir(node, "bind");
+      if (value && isStaticArgOf(value.arg, "value")) {
+        context.onError(
+          createDOMCompilerError(
+            60,
+            value.loc
+          )
+        );
+      }
+    }
+    const { tag } = node;
+    const isCustomElement = context.isCustomElement(tag);
+    if (tag === "input" || tag === "textarea" || tag === "select" || isCustomElement) {
+      let directiveToUse = V_MODEL_TEXT;
+      let isInvalidType = false;
+      if (tag === "input" || isCustomElement) {
+        const type = findProp(node, `type`);
+        if (type) {
+          if (type.type === 7) {
+            directiveToUse = V_MODEL_DYNAMIC;
+          } else if (type.value) {
+            switch (type.value.content) {
+              case "radio":
+                directiveToUse = V_MODEL_RADIO;
+                break;
+              case "checkbox":
+                directiveToUse = V_MODEL_CHECKBOX;
+                break;
+              case "file":
+                isInvalidType = true;
+                context.onError(
+                  createDOMCompilerError(
+                    59,
+                    dir.loc
+                  )
+                );
+                break;
+              default:
+                checkDuplicatedValue();
+                break;
+            }
           }
+        } else if (hasDynamicKeyVBind(node)) {
+          directiveToUse = V_MODEL_DYNAMIC;
+        } else {
+          checkDuplicatedValue();
         }
+      } else if (tag === "select") {
+        directiveToUse = V_MODEL_SELECT;
+      } else {
+        checkDuplicatedValue();
       }
-
-      // check cache
-      var key = options.delimiters
-        ? String(options.delimiters) + template
-        : template;
-      if (cache[key]) {
-        return cache[key]
+      if (!isInvalidType) {
+        baseResult.needRuntime = context.helper(directiveToUse);
       }
+    } else {
+      context.onError(
+        createDOMCompilerError(
+          57,
+          dir.loc
+        )
+      );
+    }
+    baseResult.props = baseResult.props.filter(
+      (p) => !(p.key.type === 4 && p.key.content === "modelValue")
+    );
+    return baseResult;
+  };
 
-      // 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
-              );
-            });
+  const isEventOptionModifier = /* @__PURE__ */ makeMap(`passive,once,capture`);
+  const isNonKeyModifier = /* @__PURE__ */ makeMap(
+    // event propagation management
+    `stop,prevent,self,ctrl,shift,alt,meta,exact,middle`
+  );
+  const maybeKeyModifier = /* @__PURE__ */ makeMap("left,right");
+  const isKeyboardEvent = /* @__PURE__ */ makeMap(`onkeyup,onkeydown,onkeypress`);
+  const resolveModifiers = (key, modifiers, context, loc) => {
+    const keyModifiers = [];
+    const nonKeyModifiers = [];
+    const eventOptionModifiers = [];
+    for (let i = 0; i < modifiers.length; i++) {
+      const modifier = modifiers[i].content;
+      if (isEventOptionModifier(modifier)) {
+        eventOptionModifiers.push(modifier);
+      } else {
+        if (maybeKeyModifier(modifier)) {
+          if (isStaticExp(key)) {
+            if (isKeyboardEvent(key.content.toLowerCase())) {
+              keyModifiers.push(modifier);
+            } else {
+              nonKeyModifiers.push(modifier);
+            }
           } else {
-            warn$$1(
-              "Error compiling template:\n\n" + template + "\n\n" +
-              compiled.errors.map(function (e) { return ("- " + e); }).join('\n') + '\n',
-              vm
-            );
+            keyModifiers.push(modifier);
+            nonKeyModifiers.push(modifier);
           }
-        }
-        if (compiled.tips && compiled.tips.length) {
-          if (options.outputSourceRange) {
-            compiled.tips.forEach(function (e) { return tip(e.msg, vm); });
+        } else {
+          if (isNonKeyModifier(modifier)) {
+            nonKeyModifiers.push(modifier);
           } else {
-            compiled.tips.forEach(function (msg) { return tip(msg, vm); });
+            keyModifiers.push(modifier);
           }
         }
       }
-
-      // 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 {
+      keyModifiers,
+      nonKeyModifiers,
+      eventOptionModifiers
+    };
+  };
+  const transformClick = (key, event) => {
+    const isStaticClick = isStaticExp(key) && key.content.toLowerCase() === "onclick";
+    return isStaticClick ? createSimpleExpression(event, true) : key.type !== 4 ? createCompoundExpression([
+      `(`,
+      key,
+      `) === "onClick" ? "${event}" : (`,
+      key,
+      `)`
+    ]) : key;
+  };
+  const transformOn = (dir, node, context) => {
+    return transformOn$1(dir, node, context, (baseResult) => {
+      const { modifiers } = dir;
+      if (!modifiers.length) return baseResult;
+      let { key, value: handlerExp } = baseResult.props[0];
+      const { keyModifiers, nonKeyModifiers, eventOptionModifiers } = resolveModifiers(key, modifiers, context, dir.loc);
+      if (nonKeyModifiers.includes("right")) {
+        key = transformClick(key, `onContextmenu`);
+      }
+      if (nonKeyModifiers.includes("middle")) {
+        key = transformClick(key, `onMouseup`);
+      }
+      if (nonKeyModifiers.length) {
+        handlerExp = createCallExpression(context.helper(V_ON_WITH_MODIFIERS), [
+          handlerExp,
+          JSON.stringify(nonKeyModifiers)
+        ]);
+      }
+      if (keyModifiers.length && // if event name is dynamic, always wrap with keys guard
+      (!isStaticExp(key) || isKeyboardEvent(key.content.toLowerCase()))) {
+        handlerExp = createCallExpression(context.helper(V_ON_WITH_KEYS), [
+          handlerExp,
+          JSON.stringify(keyModifiers)
+        ]);
+      }
+      if (eventOptionModifiers.length) {
+        const modifierPostfix = eventOptionModifiers.map(capitalize).join("");
+        key = isStaticExp(key) ? createSimpleExpression(`${key.content}${modifierPostfix}`, true) : createCompoundExpression([`(`, key, `) + "${modifierPostfix}"`]);
       }
+      return {
+        props: [createObjectProperty(key, handlerExp)]
+      };
+    });
+  };
 
-      return (cache[key] = res)
+  const transformShow = (dir, node, context) => {
+    const { exp, loc } = dir;
+    if (!exp) {
+      context.onError(
+        createDOMCompilerError(61, loc)
+      );
     }
-  }
-
-  /*  */
-
-  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;
+    return {
+      props: [],
+      needRuntime: context.helper(V_SHOW)
+    };
+  };
 
-            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);
-            };
+  const transformTransition = (node, context) => {
+    if (node.type === 1 && node.tagType === 1) {
+      const component = context.isBuiltInComponent(node.tag);
+      if (component === TRANSITION) {
+        return () => {
+          if (!node.children.length) {
+            return;
           }
-          // 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
+          if (hasMultipleChildren(node)) {
+            context.onError(
+              createDOMCompilerError(
+                62,
+                {
+                  start: node.children[0].loc.start,
+                  end: node.children[node.children.length - 1].loc.end,
+                  source: ""
+                }
+              )
             );
           }
-          // copy other options
-          for (var key in options) {
-            if (key !== 'modules' && key !== 'directives') {
-              finalOptions[key] = options[key];
+          const child = node.children[0];
+          if (child.type === 1) {
+            for (const p of child.props) {
+              if (p.type === 7 && p.name === "show") {
+                node.props.push({
+                  type: 6,
+                  name: "persisted",
+                  nameLoc: node.loc,
+                  value: void 0,
+                  loc: node.loc
+                });
+              }
             }
           }
-        }
-
-        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)
+        };
       }
     }
+  };
+  function hasMultipleChildren(node) {
+    const children = node.children = node.children.filter(
+      (c) => c.type !== 3 && !(c.type === 2 && !c.content.trim())
+    );
+    const child = children[0];
+    return children.length !== 1 || child.type === 11 || child.type === 9 && child.branches.some(hasMultipleChildren);
   }
 
-  /*  */
-
-  // `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 ignoreSideEffectTags = (node, context) => {
+    if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
+      context.onError(
+        createDOMCompilerError(
+          63,
+          node.loc
+        )
+      );
+      context.removeNode();
     }
-  });
-
-  /*  */
+  };
 
-  var ref$1 = createCompiler(baseOptions);
-  var compile = ref$1.compile;
-  var compileToFunctions = ref$1.compileToFunctions;
+  function isValidHTMLNesting(parent, child) {
+    if (parent === "template") {
+      return true;
+    }
+    if (parent in onlyValidChildren) {
+      return onlyValidChildren[parent].has(child);
+    }
+    if (child in onlyValidParents) {
+      return onlyValidParents[child].has(parent);
+    }
+    if (parent in knownInvalidChildren) {
+      if (knownInvalidChildren[parent].has(child)) return false;
+    }
+    if (child in knownInvalidParents) {
+      if (knownInvalidParents[child].has(parent)) return false;
+    }
+    return true;
+  }
+  const headings = /* @__PURE__ */ new Set(["h1", "h2", "h3", "h4", "h5", "h6"]);
+  const emptySet = /* @__PURE__ */ new Set([]);
+  const onlyValidChildren = {
+    head: /* @__PURE__ */ new Set([
+      "base",
+      "basefront",
+      "bgsound",
+      "link",
+      "meta",
+      "title",
+      "noscript",
+      "noframes",
+      "style",
+      "script",
+      "template"
+    ]),
+    optgroup: /* @__PURE__ */ new Set(["option"]),
+    select: /* @__PURE__ */ new Set(["optgroup", "option", "hr"]),
+    // table
+    table: /* @__PURE__ */ new Set(["caption", "colgroup", "tbody", "tfoot", "thead"]),
+    tr: /* @__PURE__ */ new Set(["td", "th"]),
+    colgroup: /* @__PURE__ */ new Set(["col"]),
+    tbody: /* @__PURE__ */ new Set(["tr"]),
+    thead: /* @__PURE__ */ new Set(["tr"]),
+    tfoot: /* @__PURE__ */ new Set(["tr"]),
+    // these elements can not have any children elements
+    script: emptySet,
+    iframe: emptySet,
+    option: emptySet,
+    textarea: emptySet,
+    style: emptySet,
+    title: emptySet
+  };
+  const onlyValidParents = {
+    // sections
+    html: emptySet,
+    body: /* @__PURE__ */ new Set(["html"]),
+    head: /* @__PURE__ */ new Set(["html"]),
+    // table
+    td: /* @__PURE__ */ new Set(["tr"]),
+    colgroup: /* @__PURE__ */ new Set(["table"]),
+    caption: /* @__PURE__ */ new Set(["table"]),
+    tbody: /* @__PURE__ */ new Set(["table"]),
+    tfoot: /* @__PURE__ */ new Set(["table"]),
+    col: /* @__PURE__ */ new Set(["colgroup"]),
+    th: /* @__PURE__ */ new Set(["tr"]),
+    thead: /* @__PURE__ */ new Set(["table"]),
+    tr: /* @__PURE__ */ new Set(["tbody", "thead", "tfoot"]),
+    // data list
+    dd: /* @__PURE__ */ new Set(["dl", "div"]),
+    dt: /* @__PURE__ */ new Set(["dl", "div"]),
+    // other
+    figcaption: /* @__PURE__ */ new Set(["figure"]),
+    // li: new Set(["ul", "ol"]),
+    summary: /* @__PURE__ */ new Set(["details"]),
+    area: /* @__PURE__ */ new Set(["map"])
+  };
+  const knownInvalidChildren = {
+    p: /* @__PURE__ */ new Set([
+      "address",
+      "article",
+      "aside",
+      "blockquote",
+      "center",
+      "details",
+      "dialog",
+      "dir",
+      "div",
+      "dl",
+      "fieldset",
+      "figure",
+      "footer",
+      "form",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "header",
+      "hgroup",
+      "hr",
+      "li",
+      "main",
+      "nav",
+      "menu",
+      "ol",
+      "p",
+      "pre",
+      "section",
+      "table",
+      "ul"
+    ]),
+    svg: /* @__PURE__ */ new Set([
+      "b",
+      "blockquote",
+      "br",
+      "code",
+      "dd",
+      "div",
+      "dl",
+      "dt",
+      "em",
+      "embed",
+      "h1",
+      "h2",
+      "h3",
+      "h4",
+      "h5",
+      "h6",
+      "hr",
+      "i",
+      "img",
+      "li",
+      "menu",
+      "meta",
+      "ol",
+      "p",
+      "pre",
+      "ruby",
+      "s",
+      "small",
+      "span",
+      "strong",
+      "sub",
+      "sup",
+      "table",
+      "u",
+      "ul",
+      "var"
+    ])
+  };
+  const knownInvalidParents = {
+    a: /* @__PURE__ */ new Set(["a"]),
+    button: /* @__PURE__ */ new Set(["button"]),
+    dd: /* @__PURE__ */ new Set(["dd", "dt"]),
+    dt: /* @__PURE__ */ new Set(["dd", "dt"]),
+    form: /* @__PURE__ */ new Set(["form"]),
+    li: /* @__PURE__ */ new Set(["li"]),
+    h1: headings,
+    h2: headings,
+    h3: headings,
+    h4: headings,
+    h5: headings,
+    h6: headings
+  };
 
-  /*  */
+  const validateHtmlNesting = (node, context) => {
+    if (node.type === 1 && node.tagType === 0 && context.parent && context.parent.type === 1 && context.parent.tagType === 0 && !isValidHTMLNesting(context.parent.tag, node.tag)) {
+      const error = new SyntaxError(
+        `<${node.tag}> cannot be child of <${context.parent.tag}>, according to HTML specifications. This can cause hydration errors or potentially disrupt future functionality.`
+      );
+      error.loc = node.loc;
+      context.onWarn(error);
+    }
+  };
 
-  // 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
+  const DOMNodeTransforms = [
+    transformStyle,
+    ...[transformTransition, validateHtmlNesting] 
+  ];
+  const DOMDirectiveTransforms = {
+    cloak: noopDirectiveTransform,
+    html: transformVHtml,
+    text: transformVText,
+    model: transformModel,
+    // override compiler-core
+    on: transformOn,
+    // override compiler-core
+    show: transformShow
+  };
+  function compile(src, options = {}) {
+    return baseCompile(
+      src,
+      extend({}, parserOptions, options, {
+        nodeTransforms: [
+          // ignore <script> and <tag>
+          // this is not put inside DOMNodeTransforms because that list is used
+          // by compiler-ssr to generate vnode fallback branches
+          ignoreSideEffectTags,
+          ...DOMNodeTransforms,
+          ...options.nodeTransforms || []
+        ],
+        directiveTransforms: extend(
+          {},
+          DOMDirectiveTransforms,
+          options.directiveTransforms || {}
+        ),
+        transformHoist: null 
+      })
+    );
   }
 
-  // #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 idToTemplate = cached(function (id) {
-    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
-              );
-            }
-          }
-        } else if (template.nodeType) {
-          template = template.innerHTML;
-        } else {
-          {
-            warn('invalid template option:' + template, this);
-          }
-          return this
-        }
-      } else if (el) {
-        template = getOuterHTML(el);
+  {
+    initDev();
+  }
+  const compileCache = /* @__PURE__ */ Object.create(null);
+  function compileToFunction(template, options) {
+    if (!isString(template)) {
+      if (template.nodeType) {
+        template = template.innerHTML;
+      } else {
+        warn(`invalid template option: `, template);
+        return NOOP;
       }
-      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');
-        }
+    }
+    const key = genCacheKey(template, options);
+    const cached = compileCache[key];
+    if (cached) {
+      return cached;
+    }
+    if (template[0] === "#") {
+      const el = document.querySelector(template);
+      if (!el) {
+        warn(`Template element not found or is empty: ${template}`);
       }
+      template = el ? el.innerHTML : ``;
     }
-    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
+    const opts = extend(
+      {
+        hoistStatic: true,
+        onError: onError ,
+        onWarn: (e) => onError(e, true) 
+      },
+      options
+    );
+    if (!opts.isCustomElement && typeof customElements !== "undefined") {
+      opts.isCustomElement = (tag) => !!customElements.get(tag);
     }
-  }
-
-  Vue.compile = compileToFunctions;
-
-  return Vue;
-
-}));
+    const { code } = compile(template, opts);
+    function onError(err, asWarning = false) {
+      const message = asWarning ? err.message : `Template compilation error: ${err.message}`;
+      const codeFrame = err.loc && generateCodeFrame(
+        template,
+        err.loc.start.offset,
+        err.loc.end.offset
+      );
+      warn(codeFrame ? `${message}
+${codeFrame}` : message);
+    }
+    const render = new Function(code)() ;
+    render._rc = true;
+    return compileCache[key] = render;
+  }
+  registerRuntimeCompiler(compileToFunction);
+
+  exports.BaseTransition = BaseTransition;
+  exports.BaseTransitionPropsValidators = BaseTransitionPropsValidators;
+  exports.Comment = Comment;
+  exports.DeprecationTypes = DeprecationTypes;
+  exports.EffectScope = EffectScope;
+  exports.ErrorCodes = ErrorCodes;
+  exports.ErrorTypeStrings = ErrorTypeStrings;
+  exports.Fragment = Fragment;
+  exports.KeepAlive = KeepAlive;
+  exports.ReactiveEffect = ReactiveEffect;
+  exports.Static = Static;
+  exports.Suspense = Suspense;
+  exports.Teleport = Teleport;
+  exports.Text = Text;
+  exports.TrackOpTypes = TrackOpTypes;
+  exports.Transition = Transition;
+  exports.TransitionGroup = TransitionGroup;
+  exports.TriggerOpTypes = TriggerOpTypes;
+  exports.VueElement = VueElement;
+  exports.assertNumber = assertNumber;
+  exports.callWithAsyncErrorHandling = callWithAsyncErrorHandling;
+  exports.callWithErrorHandling = callWithErrorHandling;
+  exports.camelize = camelize;
+  exports.capitalize = capitalize;
+  exports.cloneVNode = cloneVNode;
+  exports.compatUtils = compatUtils;
+  exports.compile = compileToFunction;
+  exports.computed = computed;
+  exports.createApp = createApp;
+  exports.createBlock = createBlock;
+  exports.createCommentVNode = createCommentVNode;
+  exports.createElementBlock = createElementBlock;
+  exports.createElementVNode = createBaseVNode;
+  exports.createHydrationRenderer = createHydrationRenderer;
+  exports.createPropsRestProxy = createPropsRestProxy;
+  exports.createRenderer = createRenderer;
+  exports.createSSRApp = createSSRApp;
+  exports.createSlots = createSlots;
+  exports.createStaticVNode = createStaticVNode;
+  exports.createTextVNode = createTextVNode;
+  exports.createVNode = createVNode;
+  exports.customRef = customRef;
+  exports.defineAsyncComponent = defineAsyncComponent;
+  exports.defineComponent = defineComponent;
+  exports.defineCustomElement = defineCustomElement;
+  exports.defineEmits = defineEmits;
+  exports.defineExpose = defineExpose;
+  exports.defineModel = defineModel;
+  exports.defineOptions = defineOptions;
+  exports.defineProps = defineProps;
+  exports.defineSSRCustomElement = defineSSRCustomElement;
+  exports.defineSlots = defineSlots;
+  exports.devtools = devtools;
+  exports.effect = effect;
+  exports.effectScope = effectScope;
+  exports.getCurrentInstance = getCurrentInstance;
+  exports.getCurrentScope = getCurrentScope;
+  exports.getCurrentWatcher = getCurrentWatcher;
+  exports.getTransitionRawChildren = getTransitionRawChildren;
+  exports.guardReactiveProps = guardReactiveProps;
+  exports.h = h;
+  exports.handleError = handleError;
+  exports.hasInjectionContext = hasInjectionContext;
+  exports.hydrate = hydrate;
+  exports.hydrateOnIdle = hydrateOnIdle;
+  exports.hydrateOnInteraction = hydrateOnInteraction;
+  exports.hydrateOnMediaQuery = hydrateOnMediaQuery;
+  exports.hydrateOnVisible = hydrateOnVisible;
+  exports.initCustomFormatter = initCustomFormatter;
+  exports.initDirectivesForSSR = initDirectivesForSSR;
+  exports.inject = inject;
+  exports.isMemoSame = isMemoSame;
+  exports.isProxy = isProxy;
+  exports.isReactive = isReactive;
+  exports.isReadonly = isReadonly;
+  exports.isRef = isRef;
+  exports.isRuntimeOnly = isRuntimeOnly;
+  exports.isShallow = isShallow;
+  exports.isVNode = isVNode;
+  exports.markRaw = markRaw;
+  exports.mergeDefaults = mergeDefaults;
+  exports.mergeModels = mergeModels;
+  exports.mergeProps = mergeProps;
+  exports.nextTick = nextTick;
+  exports.normalizeClass = normalizeClass;
+  exports.normalizeProps = normalizeProps;
+  exports.normalizeStyle = normalizeStyle;
+  exports.onActivated = onActivated;
+  exports.onBeforeMount = onBeforeMount;
+  exports.onBeforeUnmount = onBeforeUnmount;
+  exports.onBeforeUpdate = onBeforeUpdate;
+  exports.onDeactivated = onDeactivated;
+  exports.onErrorCaptured = onErrorCaptured;
+  exports.onMounted = onMounted;
+  exports.onRenderTracked = onRenderTracked;
+  exports.onRenderTriggered = onRenderTriggered;
+  exports.onScopeDispose = onScopeDispose;
+  exports.onServerPrefetch = onServerPrefetch;
+  exports.onUnmounted = onUnmounted;
+  exports.onUpdated = onUpdated;
+  exports.onWatcherCleanup = onWatcherCleanup;
+  exports.openBlock = openBlock;
+  exports.popScopeId = popScopeId;
+  exports.provide = provide;
+  exports.proxyRefs = proxyRefs;
+  exports.pushScopeId = pushScopeId;
+  exports.queuePostFlushCb = queuePostFlushCb;
+  exports.reactive = reactive;
+  exports.readonly = readonly;
+  exports.ref = ref;
+  exports.registerRuntimeCompiler = registerRuntimeCompiler;
+  exports.render = render;
+  exports.renderList = renderList;
+  exports.renderSlot = renderSlot;
+  exports.resolveComponent = resolveComponent;
+  exports.resolveDirective = resolveDirective;
+  exports.resolveDynamicComponent = resolveDynamicComponent;
+  exports.resolveFilter = resolveFilter;
+  exports.resolveTransitionHooks = resolveTransitionHooks;
+  exports.setBlockTracking = setBlockTracking;
+  exports.setDevtoolsHook = setDevtoolsHook;
+  exports.setTransitionHooks = setTransitionHooks;
+  exports.shallowReactive = shallowReactive;
+  exports.shallowReadonly = shallowReadonly;
+  exports.shallowRef = shallowRef;
+  exports.ssrContextKey = ssrContextKey;
+  exports.ssrUtils = ssrUtils;
+  exports.stop = stop;
+  exports.toDisplayString = toDisplayString;
+  exports.toHandlerKey = toHandlerKey;
+  exports.toHandlers = toHandlers;
+  exports.toRaw = toRaw;
+  exports.toRef = toRef;
+  exports.toRefs = toRefs;
+  exports.toValue = toValue;
+  exports.transformVNodeArgs = transformVNodeArgs;
+  exports.triggerRef = triggerRef;
+  exports.unref = unref;
+  exports.useAttrs = useAttrs;
+  exports.useCssModule = useCssModule;
+  exports.useCssVars = useCssVars;
+  exports.useHost = useHost;
+  exports.useId = useId;
+  exports.useModel = useModel;
+  exports.useSSRContext = useSSRContext;
+  exports.useShadowRoot = useShadowRoot;
+  exports.useSlots = useSlots;
+  exports.useTemplateRef = useTemplateRef;
+  exports.useTransitionState = useTransitionState;
+  exports.vModelCheckbox = vModelCheckbox;
+  exports.vModelDynamic = vModelDynamic;
+  exports.vModelRadio = vModelRadio;
+  exports.vModelSelect = vModelSelect;
+  exports.vModelText = vModelText;
+  exports.vShow = vShow;
+  exports.version = version;
+  exports.warn = warn;
+  exports.watch = watch;
+  exports.watchEffect = watchEffect;
+  exports.watchPostEffect = watchPostEffect;
+  exports.watchSyncEffect = watchSyncEffect;
+  exports.withAsyncContext = withAsyncContext;
+  exports.withCtx = withCtx;
+  exports.withDefaults = withDefaults;
+  exports.withDirectives = withDirectives;
+  exports.withKeys = withKeys;
+  exports.withMemo = withMemo;
+  exports.withModifiers = withModifiers;
+  exports.withScopeId = withScopeId;
+
+  return exports;
+
+})({});
diff --git a/src/pretalx/static/vendored/vue.min.js b/src/pretalx/static/vendored/vue.min.js
index 087ee42cd1..f5cd83936c 100644
--- a/src/pretalx/static/vendored/vue.min.js
+++ b/src/pretalx/static/vendored/vue.min.js
@@ -1,6 +1,12 @@
-/*!
- * Vue.js v2.6.10
- * (c) 2014-2019 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.10";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,i){for(;r<=i;++r){var o=t[r];n(o)&&(n(o.tag)?(w(o),b(o)):l(o.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&&$(0,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)?$(0,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)?$(0,[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
+/**
+* vue v3.5.17
+* (c) 2018-present Yuxi (Evan) You and Vue contributors
+* @license MIT
+**/var Vue=function(e){"use strict";var t,n,r;let i,l,s,o,a,c,u,d,p,h,f,m,g;function y(e){let t=Object.create(null);for(let n of e.split(","))t[n]=1;return e=>e in t}let b={},_=[],S=()=>{},x=()=>!1,C=e=>111===e.charCodeAt(0)&&110===e.charCodeAt(1)&&(e.charCodeAt(2)>122||97>e.charCodeAt(2)),k=e=>e.startsWith("onUpdate:"),T=Object.assign,N=(e,t)=>{let n=e.indexOf(t);n>-1&&e.splice(n,1)},w=Object.prototype.hasOwnProperty,A=(e,t)=>w.call(e,t),E=Array.isArray,I=e=>"[object Map]"===V(e),R=e=>"[object Set]"===V(e),O=e=>"[object Date]"===V(e),P=e=>"function"==typeof e,M=e=>"string"==typeof e,L=e=>"symbol"==typeof e,$=e=>null!==e&&"object"==typeof e,D=e=>($(e)||P(e))&&P(e.then)&&P(e.catch),F=Object.prototype.toString,V=e=>F.call(e),B=e=>"[object Object]"===V(e),U=e=>M(e)&&"NaN"!==e&&"-"!==e[0]&&""+parseInt(e,10)===e,j=y(",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted"),H=y("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"),q=e=>{let t=Object.create(null);return n=>t[n]||(t[n]=e(n))},W=/-(\w)/g,K=q(e=>e.replace(W,(e,t)=>t?t.toUpperCase():"")),z=/\B([A-Z])/g,J=q(e=>e.replace(z,"-$1").toLowerCase()),G=q(e=>e.charAt(0).toUpperCase()+e.slice(1)),X=q(e=>e?`on${G(e)}`:""),Q=(e,t)=>!Object.is(e,t),Z=(e,...t)=>{for(let n=0;n<e.length;n++)e[n](...t)},Y=(e,t,n,r=!1)=>{Object.defineProperty(e,t,{configurable:!0,enumerable:!1,writable:r,value:n})},ee=e=>{let t=parseFloat(e);return isNaN(t)?e:t},et=e=>{let t=M(e)?Number(e):NaN;return isNaN(t)?e:t},en=()=>i||(i="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:"undefined"!=typeof window?window:"undefined"!=typeof global?global:{}),er=y("Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error,Symbol");function ei(e){if(E(e)){let t={};for(let n=0;n<e.length;n++){let r=e[n],i=M(r)?ea(r):ei(r);if(i)for(let e in i)t[e]=i[e]}return t}if(M(e)||$(e))return e}let el=/;(?![^(]*\))/g,es=/:([^]+)/,eo=/\/\*[^]*?\*\//g;function ea(e){let t={};return e.replace(eo,"").split(el).forEach(e=>{if(e){let n=e.split(es);n.length>1&&(t[n[0].trim()]=n[1].trim())}}),t}function ec(e){let t="";if(M(e))t=e;else if(E(e))for(let n=0;n<e.length;n++){let r=ec(e[n]);r&&(t+=r+" ")}else if($(e))for(let n in e)e[n]&&(t+=n+" ");return t.trim()}let eu=y("html,body,base,head,link,meta,style,title,address,article,aside,footer,header,hgroup,h1,h2,h3,h4,h5,h6,nav,section,div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,ruby,s,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,embed,object,param,source,canvas,script,noscript,del,ins,caption,col,colgroup,table,thead,tbody,td,th,tr,button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,output,progress,select,textarea,details,dialog,menu,summary,template,blockquote,iframe,tfoot"),ed=y("svg,animate,animateMotion,animateTransform,circle,clipPath,color-profile,defs,desc,discard,ellipse,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feDropShadow,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,filter,foreignObject,g,hatch,hatchpath,image,line,linearGradient,marker,mask,mesh,meshgradient,meshpatch,meshrow,metadata,mpath,path,pattern,polygon,polyline,radialGradient,rect,set,solidcolor,stop,switch,symbol,text,textPath,title,tspan,unknown,use,view"),ep=y("annotation,annotation-xml,maction,maligngroup,malignmark,math,menclose,merror,mfenced,mfrac,mfraction,mglyph,mi,mlabeledtr,mlongdiv,mmultiscripts,mn,mo,mover,mpadded,mphantom,mprescripts,mroot,mrow,ms,mscarries,mscarry,msgroup,msline,mspace,msqrt,msrow,mstack,mstyle,msub,msubsup,msup,mtable,mtd,mtext,mtr,munder,munderover,none,semantics"),eh=y("area,base,br,col,embed,hr,img,input,link,meta,param,source,track,wbr"),ef=y("itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly");function em(e,t){if(e===t)return!0;let n=O(e),r=O(t);if(n||r)return!!n&&!!r&&e.getTime()===t.getTime();if(n=L(e),r=L(t),n||r)return e===t;if(n=E(e),r=E(t),n||r)return!!n&&!!r&&function(e,t){if(e.length!==t.length)return!1;let n=!0;for(let r=0;n&&r<e.length;r++)n=em(e[r],t[r]);return n}(e,t);if(n=$(e),r=$(t),n||r){if(!n||!r||Object.keys(e).length!==Object.keys(t).length)return!1;for(let n in e){let r=e.hasOwnProperty(n),i=t.hasOwnProperty(n);if(r&&!i||!r&&i||!em(e[n],t[n]))return!1}}return String(e)===String(t)}function eg(e,t){return e.findIndex(e=>em(e,t))}let ev=e=>!!(e&&!0===e.__v_isRef),ey=e=>M(e)?e:null==e?"":E(e)||$(e)&&(e.toString===F||!P(e.toString))?ev(e)?ey(e.value):JSON.stringify(e,eb,2):String(e),eb=(e,t)=>{if(ev(t))return eb(e,t.value);if(I(t))return{[`Map(${t.size})`]:[...t.entries()].reduce((e,[t,n],r)=>(e[e_(t,r)+" =>"]=n,e),{})};if(R(t))return{[`Set(${t.size})`]:[...t.values()].map(e=>e_(e))};if(L(t))return e_(t);if($(t)&&!E(t)&&!B(t))return String(t);return t},e_=(e,t="")=>{var n;return L(e)?`Symbol(${null!=(n=e.description)?n:t})`:e};class eS{constructor(e=!1){this.detached=e,this._active=!0,this._on=0,this.effects=[],this.cleanups=[],this._isPaused=!1,this.parent=l,!e&&l&&(this.index=(l.scopes||(l.scopes=[])).push(this)-1)}get active(){return this._active}pause(){if(this._active){let e,t;if(this._isPaused=!0,this.scopes)for(e=0,t=this.scopes.length;e<t;e++)this.scopes[e].pause();for(e=0,t=this.effects.length;e<t;e++)this.effects[e].pause()}}resume(){if(this._active&&this._isPaused){let e,t;if(this._isPaused=!1,this.scopes)for(e=0,t=this.scopes.length;e<t;e++)this.scopes[e].resume();for(e=0,t=this.effects.length;e<t;e++)this.effects[e].resume()}}run(e){if(this._active){let t=l;try{return l=this,e()}finally{l=t}}}on(){1==++this._on&&(this.prevScope=l,l=this)}off(){this._on>0&&0==--this._on&&(l=this.prevScope,this.prevScope=void 0)}stop(e){if(this._active){let t,n;for(t=0,this._active=!1,n=this.effects.length;t<n;t++)this.effects[t].stop();for(t=0,this.effects.length=0,n=this.cleanups.length;t<n;t++)this.cleanups[t]();if(this.cleanups.length=0,this.scopes){for(t=0,n=this.scopes.length;t<n;t++)this.scopes[t].stop(!0);this.scopes.length=0}if(!this.detached&&this.parent&&!e){let e=this.parent.scopes.pop();e&&e!==this&&(this.parent.scopes[this.index]=e,e.index=this.index)}this.parent=void 0}}}let ex=new WeakSet;class eC{constructor(e){this.fn=e,this.deps=void 0,this.depsTail=void 0,this.flags=5,this.next=void 0,this.cleanup=void 0,this.scheduler=void 0,l&&l.active&&l.effects.push(this)}pause(){this.flags|=64}resume(){64&this.flags&&(this.flags&=-65,ex.has(this)&&(ex.delete(this),this.trigger()))}notify(){(!(2&this.flags)||32&this.flags)&&(8&this.flags||eT(this))}run(){if(!(1&this.flags))return this.fn();this.flags|=2,e$(this),ew(this);let e=s,t=eO;s=this,eO=!0;try{return this.fn()}finally{eA(this),s=e,eO=t,this.flags&=-3}}stop(){if(1&this.flags){for(let e=this.deps;e;e=e.nextDep)eR(e);this.deps=this.depsTail=void 0,e$(this),this.onStop&&this.onStop(),this.flags&=-2}}trigger(){64&this.flags?ex.add(this):this.scheduler?this.scheduler():this.runIfDirty()}runIfDirty(){eE(this)&&this.run()}get dirty(){return eE(this)}}let ek=0;function eT(e,t=!1){if(e.flags|=8,t){e.next=a,a=e;return}e.next=o,o=e}function eN(){let e;if(!(--ek>0)){if(a){let e=a;for(a=void 0;e;){let t=e.next;e.next=void 0,e.flags&=-9,e=t}}for(;o;){let t=o;for(o=void 0;t;){let n=t.next;if(t.next=void 0,t.flags&=-9,1&t.flags)try{t.trigger()}catch(t){e||(e=t)}t=n}}if(e)throw e}}function ew(e){for(let t=e.deps;t;t=t.nextDep)t.version=-1,t.prevActiveLink=t.dep.activeLink,t.dep.activeLink=t}function eA(e){let t,n=e.depsTail,r=n;for(;r;){let e=r.prevDep;-1===r.version?(r===n&&(n=e),eR(r),function(e){let{prevDep:t,nextDep:n}=e;t&&(t.nextDep=n,e.prevDep=void 0),n&&(n.prevDep=t,e.nextDep=void 0)}(r)):t=r,r.dep.activeLink=r.prevActiveLink,r.prevActiveLink=void 0,r=e}e.deps=t,e.depsTail=n}function eE(e){for(let t=e.deps;t;t=t.nextDep)if(t.dep.version!==t.version||t.dep.computed&&(eI(t.dep.computed)||t.dep.version!==t.version))return!0;return!!e._dirty}function eI(e){if(4&e.flags&&!(16&e.flags)||(e.flags&=-17,e.globalVersion===eD)||(e.globalVersion=eD,!e.isSSR&&128&e.flags&&(!e.deps&&!e._dirty||!eE(e))))return;e.flags|=2;let t=e.dep,n=s,r=eO;s=e,eO=!0;try{ew(e);let n=e.fn(e._value);(0===t.version||Q(n,e._value))&&(e.flags|=128,e._value=n,t.version++)}catch(e){throw t.version++,e}finally{s=n,eO=r,eA(e),e.flags&=-3}}function eR(e,t=!1){let{dep:n,prevSub:r,nextSub:i}=e;if(r&&(r.nextSub=i,e.prevSub=void 0),i&&(i.prevSub=r,e.nextSub=void 0),n.subs===e&&(n.subs=r,!r&&n.computed)){n.computed.flags&=-5;for(let e=n.computed.deps;e;e=e.nextDep)eR(e,!0)}t||--n.sc||!n.map||n.map.delete(n.key)}let eO=!0,eP=[];function eM(){eP.push(eO),eO=!1}function eL(){let e=eP.pop();eO=void 0===e||e}function e$(e){let{cleanup:t}=e;if(e.cleanup=void 0,t){let e=s;s=void 0;try{t()}finally{s=e}}}let eD=0;class eF{constructor(e,t){this.sub=e,this.dep=t,this.version=t.version,this.nextDep=this.prevDep=this.nextSub=this.prevSub=this.prevActiveLink=void 0}}class eV{constructor(e){this.computed=e,this.version=0,this.activeLink=void 0,this.subs=void 0,this.map=void 0,this.key=void 0,this.sc=0,this.__v_skip=!0}track(e){if(!s||!eO||s===this.computed)return;let t=this.activeLink;if(void 0===t||t.sub!==s)t=this.activeLink=new eF(s,this),s.deps?(t.prevDep=s.depsTail,s.depsTail.nextDep=t,s.depsTail=t):s.deps=s.depsTail=t,function e(t){if(t.dep.sc++,4&t.sub.flags){let n=t.dep.computed;if(n&&!t.dep.subs){n.flags|=20;for(let t=n.deps;t;t=t.nextDep)e(t)}let r=t.dep.subs;r!==t&&(t.prevSub=r,r&&(r.nextSub=t)),t.dep.subs=t}}(t);else if(-1===t.version&&(t.version=this.version,t.nextDep)){let e=t.nextDep;e.prevDep=t.prevDep,t.prevDep&&(t.prevDep.nextDep=e),t.prevDep=s.depsTail,t.nextDep=void 0,s.depsTail.nextDep=t,s.depsTail=t,s.deps===t&&(s.deps=e)}return t}trigger(e){this.version++,eD++,this.notify(e)}notify(e){ek++;try{for(let e=this.subs;e;e=e.prevSub)e.sub.notify()&&e.sub.dep.notify()}finally{eN()}}}let eB=new WeakMap,eU=Symbol(""),ej=Symbol(""),eH=Symbol("");function eq(e,t,n){if(eO&&s){let t=eB.get(e);t||eB.set(e,t=new Map);let r=t.get(n);r||(t.set(n,r=new eV),r.map=t,r.key=n),r.track()}}function eW(e,t,n,r,i,l){let s=eB.get(e);if(!s)return void eD++;let o=e=>{e&&e.trigger()};if(ek++,"clear"===t)s.forEach(o);else{let i=E(e),l=i&&U(n);if(i&&"length"===n){let e=Number(r);s.forEach((t,n)=>{("length"===n||n===eH||!L(n)&&n>=e)&&o(t)})}else switch((void 0!==n||s.has(void 0))&&o(s.get(n)),l&&o(s.get(eH)),t){case"add":i?l&&o(s.get("length")):(o(s.get(eU)),I(e)&&o(s.get(ej)));break;case"delete":!i&&(o(s.get(eU)),I(e)&&o(s.get(ej)));break;case"set":I(e)&&o(s.get(eU))}}eN()}function eK(e){let t=tS(e);return t===e?t:(eq(t,"iterate",eH),tb(e)?t:t.map(tC))}function ez(e){return eq(e=tS(e),"iterate",eH),e}let eJ={__proto__:null,[Symbol.iterator](){return eG(this,Symbol.iterator,tC)},concat(...e){return eK(this).concat(...e.map(e=>E(e)?eK(e):e))},entries(){return eG(this,"entries",e=>(e[1]=tC(e[1]),e))},every(e,t){return eQ(this,"every",e,t,void 0,arguments)},filter(e,t){return eQ(this,"filter",e,t,e=>e.map(tC),arguments)},find(e,t){return eQ(this,"find",e,t,tC,arguments)},findIndex(e,t){return eQ(this,"findIndex",e,t,void 0,arguments)},findLast(e,t){return eQ(this,"findLast",e,t,tC,arguments)},findLastIndex(e,t){return eQ(this,"findLastIndex",e,t,void 0,arguments)},forEach(e,t){return eQ(this,"forEach",e,t,void 0,arguments)},includes(...e){return eY(this,"includes",e)},indexOf(...e){return eY(this,"indexOf",e)},join(e){return eK(this).join(e)},lastIndexOf(...e){return eY(this,"lastIndexOf",e)},map(e,t){return eQ(this,"map",e,t,void 0,arguments)},pop(){return e0(this,"pop")},push(...e){return e0(this,"push",e)},reduce(e,...t){return eZ(this,"reduce",e,t)},reduceRight(e,...t){return eZ(this,"reduceRight",e,t)},shift(){return e0(this,"shift")},some(e,t){return eQ(this,"some",e,t,void 0,arguments)},splice(...e){return e0(this,"splice",e)},toReversed(){return eK(this).toReversed()},toSorted(e){return eK(this).toSorted(e)},toSpliced(...e){return eK(this).toSpliced(...e)},unshift(...e){return e0(this,"unshift",e)},values(){return eG(this,"values",tC)}};function eG(e,t,n){let r=ez(e),i=r[t]();return r===e||tb(e)||(i._next=i.next,i.next=()=>{let e=i._next();return e.value&&(e.value=n(e.value)),e}),i}let eX=Array.prototype;function eQ(e,t,n,r,i,l){let s=ez(e),o=s!==e&&!tb(e),a=s[t];if(a!==eX[t]){let t=a.apply(e,l);return o?tC(t):t}let c=n;s!==e&&(o?c=function(t,r){return n.call(this,tC(t),r,e)}:n.length>2&&(c=function(t,r){return n.call(this,t,r,e)}));let u=a.call(s,c,r);return o&&i?i(u):u}function eZ(e,t,n,r){let i=ez(e),l=n;return i!==e&&(tb(e)?n.length>3&&(l=function(t,r,i){return n.call(this,t,r,i,e)}):l=function(t,r,i){return n.call(this,t,tC(r),i,e)}),i[t](l,...r)}function eY(e,t,n){let r=tS(e);eq(r,"iterate",eH);let i=r[t](...n);return(-1===i||!1===i)&&t_(n[0])?(n[0]=tS(n[0]),r[t](...n)):i}function e0(e,t,n=[]){eM(),ek++;let r=tS(e)[t].apply(e,n);return eN(),eL(),r}let e1=y("__proto__,__v_isRef,__isVue"),e2=new Set(Object.getOwnPropertyNames(Symbol).filter(e=>"arguments"!==e&&"caller"!==e).map(e=>Symbol[e]).filter(L));function e3(e){L(e)||(e=String(e));let t=tS(this);return eq(t,"has",e),t.hasOwnProperty(e)}class e6{constructor(e=!1,t=!1){this._isReadonly=e,this._isShallow=t}get(e,t,n){if("__v_skip"===t)return e.__v_skip;let r=this._isReadonly,i=this._isShallow;if("__v_isReactive"===t)return!r;if("__v_isReadonly"===t)return r;if("__v_isShallow"===t)return i;if("__v_raw"===t)return n===(r?i?tp:td:i?tu:tc).get(e)||Object.getPrototypeOf(e)===Object.getPrototypeOf(n)?e:void 0;let l=E(e);if(!r){let e;if(l&&(e=eJ[t]))return e;if("hasOwnProperty"===t)return e3}let s=Reflect.get(e,t,tT(e)?e:n);return(L(t)?e2.has(t):e1(t))||(r||eq(e,"get",t),i)?s:tT(s)?l&&U(t)?s:s.value:$(s)?r?tm(s):th(s):s}}class e4 extends e6{constructor(e=!1){super(!1,e)}set(e,t,n,r){let i=e[t];if(!this._isShallow){let t=ty(i);if(tb(n)||ty(n)||(i=tS(i),n=tS(n)),!E(e)&&tT(i)&&!tT(n))if(t)return!1;else return i.value=n,!0}let l=E(e)&&U(t)?Number(t)<e.length:A(e,t),s=Reflect.set(e,t,n,tT(e)?e:r);return e===tS(r)&&(l?Q(n,i)&&eW(e,"set",t,n):eW(e,"add",t,n)),s}deleteProperty(e,t){let n=A(e,t);e[t];let r=Reflect.deleteProperty(e,t);return r&&n&&eW(e,"delete",t,void 0),r}has(e,t){let n=Reflect.has(e,t);return L(t)&&e2.has(t)||eq(e,"has",t),n}ownKeys(e){return eq(e,"iterate",E(e)?"length":eU),Reflect.ownKeys(e)}}class e8 extends e6{constructor(e=!1){super(!0,e)}set(e,t){return!0}deleteProperty(e,t){return!0}}let e5=new e4,e9=new e8,e7=new e4(!0),te=new e8(!0),tt=e=>e,tn=e=>Reflect.getPrototypeOf(e);function tr(e){return function(...t){return"delete"!==e&&("clear"===e?void 0:this)}}function ti(e,t){let n=function(e,t){let n={get(n){let r=this.__v_raw,i=tS(r),l=tS(n);e||(Q(n,l)&&eq(i,"get",n),eq(i,"get",l));let{has:s}=tn(i),o=t?tt:e?tk:tC;return s.call(i,n)?o(r.get(n)):s.call(i,l)?o(r.get(l)):void(r!==i&&r.get(n))},get size(){let t=this.__v_raw;return e||eq(tS(t),"iterate",eU),Reflect.get(t,"size",t)},has(t){let n=this.__v_raw,r=tS(n),i=tS(t);return e||(Q(t,i)&&eq(r,"has",t),eq(r,"has",i)),t===i?n.has(t):n.has(t)||n.has(i)},forEach(n,r){let i=this,l=i.__v_raw,s=tS(l),o=t?tt:e?tk:tC;return e||eq(s,"iterate",eU),l.forEach((e,t)=>n.call(r,o(e),o(t),i))}};return T(n,e?{add:tr("add"),set:tr("set"),delete:tr("delete"),clear:tr("clear")}:{add(e){t||tb(e)||ty(e)||(e=tS(e));let n=tS(this);return tn(n).has.call(n,e)||(n.add(e),eW(n,"add",e,e)),this},set(e,n){t||tb(n)||ty(n)||(n=tS(n));let r=tS(this),{has:i,get:l}=tn(r),s=i.call(r,e);s||(e=tS(e),s=i.call(r,e));let o=l.call(r,e);return r.set(e,n),s?Q(n,o)&&eW(r,"set",e,n):eW(r,"add",e,n),this},delete(e){let t=tS(this),{has:n,get:r}=tn(t),i=n.call(t,e);i||(e=tS(e),i=n.call(t,e)),r&&r.call(t,e);let l=t.delete(e);return i&&eW(t,"delete",e,void 0),l},clear(){let e=tS(this),t=0!==e.size,n=e.clear();return t&&eW(e,"clear",void 0,void 0),n}}),["keys","values","entries",Symbol.iterator].forEach(r=>{n[r]=function(...n){let i=this.__v_raw,l=tS(i),s=I(l),o="entries"===r||r===Symbol.iterator&&s,a=i[r](...n),c=t?tt:e?tk:tC;return e||eq(l,"iterate","keys"===r&&s?ej:eU),{next(){let{value:e,done:t}=a.next();return t?{value:e,done:t}:{value:o?[c(e[0]),c(e[1])]:c(e),done:t}},[Symbol.iterator](){return this}}}}),n}(e,t);return(t,r,i)=>"__v_isReactive"===r?!e:"__v_isReadonly"===r?e:"__v_raw"===r?t:Reflect.get(A(n,r)&&r in t?n:t,r,i)}let tl={get:ti(!1,!1)},ts={get:ti(!1,!0)},to={get:ti(!0,!1)},ta={get:ti(!0,!0)},tc=new WeakMap,tu=new WeakMap,td=new WeakMap,tp=new WeakMap;function th(e){return ty(e)?e:tg(e,!1,e5,tl,tc)}function tf(e){return tg(e,!1,e7,ts,tu)}function tm(e){return tg(e,!0,e9,to,td)}function tg(e,t,n,r,i){var l;if(!$(e)||e.__v_raw&&!(t&&e.__v_isReactive))return e;let s=(l=e).__v_skip||!Object.isExtensible(l)?0:function(e){switch(e){case"Object":case"Array":return 1;case"Map":case"Set":case"WeakMap":case"WeakSet":return 2;default:return 0}}(V(l).slice(8,-1));if(0===s)return e;let o=i.get(e);if(o)return o;let a=new Proxy(e,2===s?r:n);return i.set(e,a),a}function tv(e){return ty(e)?tv(e.__v_raw):!!(e&&e.__v_isReactive)}function ty(e){return!!(e&&e.__v_isReadonly)}function tb(e){return!!(e&&e.__v_isShallow)}function t_(e){return!!e&&!!e.__v_raw}function tS(e){let t=e&&e.__v_raw;return t?tS(t):e}function tx(e){return!A(e,"__v_skip")&&Object.isExtensible(e)&&Y(e,"__v_skip",!0),e}let tC=e=>$(e)?th(e):e,tk=e=>$(e)?tm(e):e;function tT(e){return!!e&&!0===e.__v_isRef}function tN(e){return tA(e,!1)}function tw(e){return tA(e,!0)}function tA(e,t){return tT(e)?e:new tE(e,t)}class tE{constructor(e,t){this.dep=new eV,this.__v_isRef=!0,this.__v_isShallow=!1,this._rawValue=t?e:tS(e),this._value=t?e:tC(e),this.__v_isShallow=t}get value(){return this.dep.track(),this._value}set value(e){let t=this._rawValue,n=this.__v_isShallow||tb(e)||ty(e);Q(e=n?e:tS(e),t)&&(this._rawValue=e,this._value=n?e:tC(e),this.dep.trigger())}}function tI(e){return tT(e)?e.value:e}let tR={get:(e,t,n)=>"__v_raw"===t?e:tI(Reflect.get(e,t,n)),set:(e,t,n,r)=>{let i=e[t];return tT(i)&&!tT(n)?(i.value=n,!0):Reflect.set(e,t,n,r)}};function tO(e){return tv(e)?e:new Proxy(e,tR)}class tP{constructor(e){this.__v_isRef=!0,this._value=void 0;let t=this.dep=new eV,{get:n,set:r}=e(t.track.bind(t),t.trigger.bind(t));this._get=n,this._set=r}get value(){return this._value=this._get()}set value(e){this._set(e)}}function tM(e){return new tP(e)}class tL{constructor(e,t,n){this._object=e,this._key=t,this._defaultValue=n,this.__v_isRef=!0,this._value=void 0}get value(){let e=this._object[this._key];return this._value=void 0===e?this._defaultValue:e}set value(e){this._object[this._key]=e}get dep(){return function(e,t){let n=eB.get(e);return n&&n.get(t)}(tS(this._object),this._key)}}class t${constructor(e){this._getter=e,this.__v_isRef=!0,this.__v_isReadonly=!0,this._value=void 0}get value(){return this._value=this._getter()}}function tD(e,t,n){let r=e[t];return tT(r)?r:new tL(e,t,n)}class tF{constructor(e,t,n){this.fn=e,this.setter=t,this._value=void 0,this.dep=new eV(this),this.__v_isRef=!0,this.deps=void 0,this.depsTail=void 0,this.flags=16,this.globalVersion=eD-1,this.next=void 0,this.effect=this,this.__v_isReadonly=!t,this.isSSR=n}notify(){if(this.flags|=16,!(8&this.flags)&&s!==this)return eT(this,!0),!0}get value(){let e=this.dep.track();return eI(this),e&&(e.version=this.dep.version),this._value}set value(e){this.setter&&this.setter(e)}}let tV={},tB=new WeakMap;function tU(e,t=!1,n=m){if(n){let t=tB.get(n);t||tB.set(n,t=[]),t.push(e)}}function tj(e,t=1/0,n){if(t<=0||!$(e)||e.__v_skip||(n=n||new Set).has(e))return e;if(n.add(e),t--,tT(e))tj(e.value,t,n);else if(E(e))for(let r=0;r<e.length;r++)tj(e[r],t,n);else if(R(e)||I(e))e.forEach(e=>{tj(e,t,n)});else if(B(e)){for(let r in e)tj(e[r],t,n);for(let r of Object.getOwnPropertySymbols(e))Object.prototype.propertyIsEnumerable.call(e,r)&&tj(e[r],t,n)}return e}function tH(e,t,n,r){try{return r?e(...r):e()}catch(e){tW(e,t,n)}}function tq(e,t,n,r){if(P(e)){let i=tH(e,t,n,r);return i&&D(i)&&i.catch(e=>{tW(e,t,n)}),i}if(E(e)){let i=[];for(let l=0;l<e.length;l++)i.push(tq(e[l],t,n,r));return i}}function tW(e,t,n,r=!0){let i=t?t.vnode:null,{errorHandler:l,throwUnhandledErrorInProduction:s}=t&&t.appContext.config||b;if(t){let r=t.parent,i=t.proxy,s=`https://vuejs.org/error-reference/#runtime-${n}`;for(;r;){let t=r.ec;if(t){for(let n=0;n<t.length;n++)if(!1===t[n](e,i,s))return}r=r.parent}if(l){eM(),tH(l,null,10,[e,i,s]),eL();return}}!function(e,t,n,r=!0,i=!1){if(i)throw e;console.error(e)}(e,0,0,r,s)}let tK=[],tz=-1,tJ=[],tG=null,tX=0,tQ=Promise.resolve(),tZ=null;function tY(e){let t=tZ||tQ;return e?t.then(this?e.bind(this):e):t}function t0(e){if(!(1&e.flags)){let t=t4(e),n=tK[tK.length-1];!n||!(2&e.flags)&&t>=t4(n)?tK.push(e):tK.splice(function(e){let t=tz+1,n=tK.length;for(;t<n;){let r=t+n>>>1,i=tK[r],l=t4(i);l<e||l===e&&2&i.flags?t=r+1:n=r}return t}(t),0,e),e.flags|=1,t1()}}function t1(){tZ||(tZ=tQ.then(function e(t){try{for(tz=0;tz<tK.length;tz++){let e=tK[tz];e&&!(8&e.flags)&&(4&e.flags&&(e.flags&=-2),tH(e,e.i,e.i?15:14),4&e.flags||(e.flags&=-2))}}finally{for(;tz<tK.length;tz++){let e=tK[tz];e&&(e.flags&=-2)}tz=-1,tK.length=0,t6(),tZ=null,(tK.length||tJ.length)&&e()}}))}function t2(e){E(e)?tJ.push(...e):tG&&-1===e.id?tG.splice(tX+1,0,e):1&e.flags||(tJ.push(e),e.flags|=1),t1()}function t3(e,t,n=tz+1){for(;n<tK.length;n++){let t=tK[n];if(t&&2&t.flags){if(e&&t.id!==e.uid)continue;tK.splice(n,1),n--,4&t.flags&&(t.flags&=-2),t(),4&t.flags||(t.flags&=-2)}}}function t6(e){if(tJ.length){let e=[...new Set(tJ)].sort((e,t)=>t4(e)-t4(t));if(tJ.length=0,tG)return void tG.push(...e);for(tX=0,tG=e;tX<tG.length;tX++){let e=tG[tX];4&e.flags&&(e.flags&=-2),8&e.flags||e(),e.flags&=-2}tG=null,tX=0}}let t4=e=>null==e.id?2&e.flags?-1:1/0:e.id,t8=null,t5=null;function t9(e){let t=t8;return t8=e,t5=e&&e.type.__scopeId||null,t}function t7(e,t=t8,n){if(!t||e._n)return e;let r=(...n)=>{let i;r._d&&ia(-1);let l=t9(t);try{i=e(...n)}finally{t9(l),r._d&&ia(1)}return i};return r._n=!0,r._c=!0,r._d=!0,r}function ne(e,t,n,r){let i=e.dirs,l=t&&t.dirs;for(let s=0;s<i.length;s++){let o=i[s];l&&(o.oldValue=l[s].value);let a=o.dir[r];a&&(eM(),tq(a,n,8,[e.el,o,e,t]),eL())}}let nt=Symbol("_vte"),nn=e=>e&&(e.disabled||""===e.disabled),nr=e=>e&&(e.defer||""===e.defer),ni=e=>"undefined"!=typeof SVGElement&&e instanceof SVGElement,nl=e=>"function"==typeof MathMLElement&&e instanceof MathMLElement,ns=(e,t)=>{let n=e&&e.to;return M(n)?t?t(n):null:n},no={name:"Teleport",__isTeleport:!0,process(e,t,n,r,i,l,s,o,a,c){let{mc:u,pc:d,pbc:p,o:{insert:h,querySelector:f,createText:m,createComment:g}}=c,y=nn(t.props),{shapeFlag:b,children:_,dynamicChildren:S}=t;if(null==e){let e=t.el=m(""),c=t.anchor=m("");h(e,n,r),h(c,n,r);let d=(e,t)=>{16&b&&(i&&i.isCE&&(i.ce._teleportTarget=e),u(_,e,t,i,l,s,o,a))},p=()=>{let e=t.target=ns(t.props,f),n=nu(e,t,m,h);e&&("svg"!==s&&ni(e)?s="svg":"mathml"!==s&&nl(e)&&(s="mathml"),y||(d(e,n),nc(t,!1)))};y&&(d(n,c),nc(t,!0)),nr(t.props)?(t.el.__isMounted=!1,rM(()=>{p(),delete t.el.__isMounted},l)):p()}else{if(nr(t.props)&&!1===e.el.__isMounted)return void rM(()=>{no.process(e,t,n,r,i,l,s,o,a,c)},l);t.el=e.el,t.targetStart=e.targetStart;let u=t.anchor=e.anchor,h=t.target=e.target,m=t.targetAnchor=e.targetAnchor,g=nn(e.props),b=g?n:h,_=g?u:m;if("svg"===s||ni(h)?s="svg":("mathml"===s||nl(h))&&(s="mathml"),S?(p(e.dynamicChildren,S,b,i,l,s,o),rB(e,t,!0)):a||d(e,t,b,_,i,l,s,o,!1),y)g?t.props&&e.props&&t.props.to!==e.props.to&&(t.props.to=e.props.to):na(t,n,u,c,1);else if((t.props&&t.props.to)!==(e.props&&e.props.to)){let e=t.target=ns(t.props,f);e&&na(t,e,null,c,0)}else g&&na(t,h,m,c,1);nc(t,y)}},remove(e,t,n,{um:r,o:{remove:i}},l){let{shapeFlag:s,children:o,anchor:a,targetStart:c,targetAnchor:u,target:d,props:p}=e;if(d&&(i(c),i(u)),l&&i(a),16&s){let e=l||!nn(p);for(let i=0;i<o.length;i++){let l=o[i];r(l,t,n,e,!!l.dynamicChildren)}}},move:na,hydrate:function(e,t,n,r,i,l,{o:{nextSibling:s,parentNode:o,querySelector:a,insert:c,createText:u}},d){let p=t.target=ns(t.props,a);if(p){let a=nn(t.props),h=p._lpa||p.firstChild;if(16&t.shapeFlag)if(a)t.anchor=d(s(e),t,o(e),n,r,i,l),t.targetStart=h,t.targetAnchor=h&&s(h);else{t.anchor=s(e);let o=h;for(;o;){if(o&&8===o.nodeType){if("teleport start anchor"===o.data)t.targetStart=o;else if("teleport anchor"===o.data){t.targetAnchor=o,p._lpa=t.targetAnchor&&s(t.targetAnchor);break}}o=s(o)}t.targetAnchor||nu(p,t,u,c),d(h&&s(h),t,p,n,r,i,l)}nc(t,a)}return t.anchor&&s(t.anchor)}};function na(e,t,n,{o:{insert:r},m:i},l=2){0===l&&r(e.targetAnchor,t,n);let{el:s,anchor:o,shapeFlag:a,children:c,props:u}=e,d=2===l;if(d&&r(s,t,n),(!d||nn(u))&&16&a)for(let e=0;e<c.length;e++)i(c[e],t,n,2);d&&r(o,t,n)}function nc(e,t){let n=e.ctx;if(n&&n.ut){let r,i;for(t?(r=e.el,i=e.anchor):(r=e.targetStart,i=e.targetAnchor);r&&r!==i;)1===r.nodeType&&r.setAttribute("data-v-owner",n.uid),r=r.nextSibling;n.ut()}}function nu(e,t,n,r){let i=t.targetStart=n(""),l=t.targetAnchor=n("");return i[nt]=l,e&&(r(i,e),r(l,e)),l}let nd=Symbol("_leaveCb"),np=Symbol("_enterCb");function nh(){let e={isMounted:!1,isLeaving:!1,isUnmounting:!1,leavingVNodes:new Map};return nX(()=>{e.isMounted=!0}),nY(()=>{e.isUnmounting=!0}),e}let nf=[Function,Array],nm={mode:String,appear:Boolean,persisted:Boolean,onBeforeEnter:nf,onEnter:nf,onAfterEnter:nf,onEnterCancelled:nf,onBeforeLeave:nf,onLeave:nf,onAfterLeave:nf,onLeaveCancelled:nf,onBeforeAppear:nf,onAppear:nf,onAfterAppear:nf,onAppearCancelled:nf},ng=e=>{let t=e.subTree;return t.component?ng(t.component):t};function nv(e){let t=e[0];if(e.length>1){for(let n of e)if(n.type!==ie){t=n;break}}return t}let ny={name:"BaseTransition",props:nm,setup(e,{slots:t}){let n=iE(),r=nh();return()=>{let i=t.default&&nk(t.default(),!0);if(!i||!i.length)return;let l=nv(i),s=tS(e),{mode:o}=s;if(r.isLeaving)return nS(l);let a=nx(l);if(!a)return nS(l);let c=n_(a,s,r,n,e=>c=e);a.type!==ie&&nC(a,c);let u=n.subTree&&nx(n.subTree);if(u&&u.type!==ie&&!ip(a,u)&&ng(n).type!==ie){let e=n_(u,s,r,n);if(nC(u,e),"out-in"===o&&a.type!==ie)return r.isLeaving=!0,e.afterLeave=()=>{r.isLeaving=!1,8&n.job.flags||n.update(),delete e.afterLeave,u=void 0},nS(l);"in-out"===o&&a.type!==ie?e.delayLeave=(e,t,n)=>{nb(r,u)[String(u.key)]=u,e[nd]=()=>{t(),e[nd]=void 0,delete c.delayedLeave,u=void 0},c.delayedLeave=()=>{n(),delete c.delayedLeave,u=void 0}}:u=void 0}else u&&(u=void 0);return l}}};function nb(e,t){let{leavingVNodes:n}=e,r=n.get(t.type);return r||(r=Object.create(null),n.set(t.type,r)),r}function n_(e,t,n,r,i){let{appear:l,mode:s,persisted:o=!1,onBeforeEnter:a,onEnter:c,onAfterEnter:u,onEnterCancelled:d,onBeforeLeave:p,onLeave:h,onAfterLeave:f,onLeaveCancelled:m,onBeforeAppear:g,onAppear:y,onAfterAppear:b,onAppearCancelled:_}=t,S=String(e.key),x=nb(n,e),C=(e,t)=>{e&&tq(e,r,9,t)},k=(e,t)=>{let n=t[1];C(e,t),E(e)?e.every(e=>e.length<=1)&&n():e.length<=1&&n()},T={mode:s,persisted:o,beforeEnter(t){let r=a;if(!n.isMounted)if(!l)return;else r=g||a;t[nd]&&t[nd](!0);let i=x[S];i&&ip(e,i)&&i.el[nd]&&i.el[nd](),C(r,[t])},enter(e){let t=c,r=u,i=d;if(!n.isMounted)if(!l)return;else t=y||c,r=b||u,i=_||d;let s=!1,o=e[np]=t=>{s||(s=!0,t?C(i,[e]):C(r,[e]),T.delayedLeave&&T.delayedLeave(),e[np]=void 0)};t?k(t,[e,o]):o()},leave(t,r){let i=String(e.key);if(t[np]&&t[np](!0),n.isUnmounting)return r();C(p,[t]);let l=!1,s=t[nd]=n=>{l||(l=!0,r(),n?C(m,[t]):C(f,[t]),t[nd]=void 0,x[i]===e&&delete x[i])};x[i]=e,h?k(h,[t,s]):s()},clone(e){let l=n_(e,t,n,r,i);return i&&i(l),l}};return T}function nS(e){if(nB(e))return(e=ib(e)).children=null,e}function nx(e){if(!nB(e))return e.type.__isTeleport&&e.children?nv(e.children):e;if(e.component)return e.component.subTree;let{shapeFlag:t,children:n}=e;if(n){if(16&t)return n[0];if(32&t&&P(n.default))return n.default()}}function nC(e,t){6&e.shapeFlag&&e.component?(e.transition=t,nC(e.component.subTree,t)):128&e.shapeFlag?(e.ssContent.transition=t.clone(e.ssContent),e.ssFallback.transition=t.clone(e.ssFallback)):e.transition=t}function nk(e,t=!1,n){let r=[],i=0;for(let l=0;l<e.length;l++){let s=e[l],o=null==n?s.key:String(n)+String(null!=s.key?s.key:l);s.type===r9?(128&s.patchFlag&&i++,r=r.concat(nk(s.children,t,o))):(t||s.type!==ie)&&r.push(null!=o?ib(s,{key:o}):s)}if(i>1)for(let e=0;e<r.length;e++)r[e].patchFlag=-2;return r}function nT(e,t){return P(e)?T({name:e.name},t,{setup:e}):e}function nN(e){e.ids=[e.ids[0]+e.ids[2]+++"-",0,0]}function nw(e,t,n,r,i=!1){if(E(e))return void e.forEach((e,l)=>nw(e,t&&(E(t)?t[l]:t),n,r,i));if(nF(r)&&!i){512&r.shapeFlag&&r.type.__asyncResolved&&r.component.subTree.component&&nw(e,t,n,r.component.subTree);return}let l=4&r.shapeFlag?iV(r.component):r.el,s=i?null:l,{i:o,r:a}=e,c=t&&t.r,u=o.refs===b?o.refs={}:o.refs,d=o.setupState,p=tS(d),h=d===b?()=>!1:e=>A(p,e);if(null!=c&&c!==a&&(M(c)?(u[c]=null,h(c)&&(d[c]=null)):tT(c)&&(c.value=null)),P(a))tH(a,o,12,[s,u]);else{let t=M(a),r=tT(a);if(t||r){let o=()=>{if(e.f){let n=t?h(a)?d[a]:u[a]:a.value;i?E(n)&&N(n,l):E(n)?n.includes(l)||n.push(l):t?(u[a]=[l],h(a)&&(d[a]=u[a])):(a.value=[l],e.k&&(u[e.k]=a.value))}else t?(u[a]=s,h(a)&&(d[a]=s)):r&&(a.value=s,e.k&&(u[e.k]=s))};s?(o.id=-1,rM(o,n)):o()}}}let nA=!1,nE=()=>{nA||(console.error("Hydration completed but contains mismatches."),nA=!0)},nI=e=>{if(1===e.nodeType){if(e.namespaceURI.includes("svg")&&"foreignObject"!==e.tagName)return"svg";if(e.namespaceURI.includes("MathML"))return"mathml"}},nR=e=>8===e.nodeType;function nO(e){let{mt:t,p:n,o:{patchProp:r,createText:i,nextSibling:l,parentNode:s,remove:o,insert:a,createComment:c}}=e,u=(n,r,o,c,b,_=!1)=>{_=_||!!r.dynamicChildren;let S=nR(n)&&"["===n.data,x=()=>f(n,r,o,c,b,S),{type:C,ref:k,shapeFlag:T,patchFlag:N}=r,w=n.nodeType;r.el=n,-2===N&&(_=!1,r.dynamicChildren=null);let A=null;switch(C){case r7:3!==w?""===r.children?(a(r.el=i(""),s(n),n),A=n):A=x():(n.data!==r.children&&(nE(),n.data=r.children),A=l(n));break;case ie:y(n)?(A=l(n),g(r.el=n.content.firstChild,n,o)):A=8!==w||S?x():l(n);break;case it:if(S&&(w=(n=l(n)).nodeType),1===w||3===w){A=n;let e=!r.children.length;for(let t=0;t<r.staticCount;t++)e&&(r.children+=1===A.nodeType?A.outerHTML:A.data),t===r.staticCount-1&&(r.anchor=A),A=l(A);return S?l(A):A}x();break;case r9:A=S?h(n,r,o,c,b,_):x();break;default:if(1&T)A=1===w&&r.type.toLowerCase()===n.tagName.toLowerCase()||y(n)?d(n,r,o,c,b,_):x();else if(6&T){r.slotScopeIds=b;let e=s(n);if(A=S?m(n):nR(n)&&"teleport start"===n.data?m(n,n.data,"teleport end"):l(n),t(r,e,null,o,c,nI(e),_),nF(r)&&!r.type.__asyncResolved){let t;S?(t=iv(r9)).anchor=A?A.previousSibling:e.lastChild:t=3===n.nodeType?i_(""):iv("div"),t.el=n,r.component.subTree=t}}else 64&T?A=8!==w?x():r.type.hydrate(n,r,o,c,b,_,e,p):128&T&&(A=r.type.hydrate(n,r,o,c,nI(s(n)),b,_,e,u))}return null!=k&&nw(k,null,c,r),A},d=(e,t,n,i,l,s)=>{s=s||!!t.dynamicChildren;let{type:a,props:c,patchFlag:u,shapeFlag:d,dirs:h,transition:f}=t,m="input"===a||"option"===a;if(m||-1!==u){let a;h&&ne(t,null,n,"created");let b=!1;if(y(e)){b=rV(null,f)&&n&&n.vnode.props&&n.vnode.props.appear;let r=e.content.firstChild;if(b){let e=r.getAttribute("class");e&&(r.$cls=e),f.beforeEnter(r)}g(r,e,n),t.el=e=r}if(16&d&&!(c&&(c.innerHTML||c.textContent))){let r=p(e.firstChild,t,e,n,i,l,s);for(;r;){nL(e,1)||nE();let t=r;r=r.nextSibling,o(t)}}else if(8&d){let n=t.children;`
+`===n[0]&&("PRE"===e.tagName||"TEXTAREA"===e.tagName)&&(n=n.slice(1)),e.textContent!==n&&(nL(e,0)||nE(),e.textContent=t.children)}if(c){if(m||!s||48&u){let t=e.tagName.includes("-");for(let i in c)(m&&(i.endsWith("value")||"indeterminate"===i)||C(i)&&!j(i)||"."===i[0]||t)&&r(e,i,null,c[i],void 0,n)}else if(c.onClick)r(e,"onClick",null,c.onClick,void 0,n);else if(4&u&&tv(c.style))for(let e in c.style)c.style[e]}(a=c&&c.onVnodeBeforeMount)&&iT(a,n,t),h&&ne(t,null,n,"beforeMount"),((a=c&&c.onVnodeMounted)||h||b)&&r8(()=>{a&&iT(a,n,t),b&&f.enter(e),h&&ne(t,null,n,"mounted")},i)}return e.nextSibling},p=(e,t,r,s,o,c,d)=>{d=d||!!t.dynamicChildren;let p=t.children,h=p.length;for(let t=0;t<h;t++){let f=d?p[t]:p[t]=iS(p[t]),m=f.type===r7;e?(m&&!d&&t+1<h&&iS(p[t+1]).type===r7&&(a(i(e.data.slice(f.children.length)),r,l(e)),e.data=f.children),e=u(e,f,s,o,c,d)):m&&!f.children?a(f.el=i(""),r):(nL(r,1)||nE(),n(null,f,r,null,s,o,nI(r),c))}return e},h=(e,t,n,r,i,o)=>{let{slotScopeIds:u}=t;u&&(i=i?i.concat(u):u);let d=s(e),h=p(l(e),t,d,n,r,i,o);return h&&nR(h)&&"]"===h.data?l(t.anchor=h):(nE(),a(t.anchor=c("]"),d,h),h)},f=(e,t,r,i,a,c)=>{if(nL(e.parentElement,1)||nE(),t.el=null,c){let t=m(e);for(;;){let n=l(e);if(n&&n!==t)o(n);else break}}let u=l(e),d=s(e);return o(e),n(null,t,d,u,r,i,nI(d),a),r&&(r.vnode.el=t.el,r0(r,t.el)),u},m=(e,t="[",n="]")=>{let r=0;for(;e;)if((e=l(e))&&nR(e)&&(e.data===t&&r++,e.data===n))if(0===r)return l(e);else r--;return e},g=(e,t,n)=>{let r=t.parentNode;r&&r.replaceChild(e,t);let i=n;for(;i;)i.vnode.el===t&&(i.vnode.el=i.subTree.el=e),i=i.parent},y=e=>1===e.nodeType&&"TEMPLATE"===e.tagName;return[(e,t)=>{if(!t.hasChildNodes()){n(null,e,t),t6(),t._vnode=e;return}u(t.firstChild,e,null,null,null),t6(),t._vnode=e},u]}let nP="data-allow-mismatch",nM={0:"text",1:"children",2:"class",3:"style",4:"attribute"};function nL(e,t){if(0===t||1===t)for(;e&&!e.hasAttribute(nP);)e=e.parentElement;let n=e&&e.getAttribute(nP);if(null==n)return!1;{if(""===n)return!0;let e=n.split(",");return!!(0===t&&e.includes("children"))||e.includes(nM[t])}}let n$=en().requestIdleCallback||(e=>setTimeout(e,1)),nD=en().cancelIdleCallback||(e=>clearTimeout(e)),nF=e=>!!e.type.__asyncLoader;function nV(e,t){let{ref:n,props:r,children:i,ce:l}=t.vnode,s=iv(e,r,i);return s.ref=n,s.ce=l,delete t.vnode.ce,s}let nB=e=>e.type.__isKeepAlive;function nU(e,t){return E(e)?e.some(e=>nU(e,t)):M(e)?e.split(",").includes(t):"[object RegExp]"===V(e)&&(e.lastIndex=0,e.test(t))}function nj(e,t){nq(e,"a",t)}function nH(e,t){nq(e,"da",t)}function nq(e,t,n=iA){let r=e.__wdc||(e.__wdc=()=>{let t=n;for(;t;){if(t.isDeactivated)return;t=t.parent}return e()});if(nz(t,r,n),n){let e=n.parent;for(;e&&e.parent;)nB(e.parent.vnode)&&function(e,t,n,r){let i=nz(t,e,r,!0);n0(()=>{N(r[t],i)},n)}(r,t,n,e),e=e.parent}}function nW(e){e.shapeFlag&=-257,e.shapeFlag&=-513}function nK(e){return 128&e.shapeFlag?e.ssContent:e}function nz(e,t,n=iA,r=!1){if(n){let i=n[e]||(n[e]=[]),l=t.__weh||(t.__weh=(...r)=>{eM();let i=iI(n),l=tq(t,n,e,r);return i(),eL(),l});return r?i.unshift(l):i.push(l),l}}let nJ=e=>(t,n=iA)=>{iP&&"sp"!==e||nz(e,(...e)=>t(...e),n)},nG=nJ("bm"),nX=nJ("m"),nQ=nJ("bu"),nZ=nJ("u"),nY=nJ("bum"),n0=nJ("um"),n1=nJ("sp"),n2=nJ("rtg"),n3=nJ("rtc");function n6(e,t=iA){nz("ec",e,t)}let n4="components",n8=Symbol.for("v-ndc");function n5(e,t,n=!0,r=!1){let i=t8||iA;if(i){let n=i.type;if(e===n4){let e=iB(n,!1);if(e&&(e===t||e===K(t)||e===G(K(t))))return n}let l=n9(i[e]||n[e],t)||n9(i.appContext[e],t);return!l&&r?n:l}}function n9(e,t){return e&&(e[t]||e[K(t)]||e[G(K(t))])}let n7=e=>e?iO(e)?iV(e):n7(e.parent):null,re=T(Object.create(null),{$:e=>e,$el:e=>e.vnode.el,$data:e=>e.data,$props:e=>e.props,$attrs:e=>e.attrs,$slots:e=>e.slots,$refs:e=>e.refs,$parent:e=>n7(e.parent),$root:e=>n7(e.root),$host:e=>e.ce,$emit:e=>e.emit,$options:e=>ra(e),$forceUpdate:e=>e.f||(e.f=()=>{t0(e.update)}),$nextTick:e=>e.n||(e.n=tY.bind(e.proxy)),$watch:e=>rW.bind(e)}),rt=(e,t)=>e!==b&&!e.__isScriptSetup&&A(e,t),rn={get({_:e},t){let n,r,i;if("__v_skip"===t)return!0;let{ctx:l,setupState:s,data:o,props:a,accessCache:c,type:u,appContext:d}=e;if("$"!==t[0]){let r=c[t];if(void 0!==r)switch(r){case 1:return s[t];case 2:return o[t];case 4:return l[t];case 3:return a[t]}else{if(rt(s,t))return c[t]=1,s[t];if(o!==b&&A(o,t))return c[t]=2,o[t];if((n=e.propsOptions[0])&&A(n,t))return c[t]=3,a[t];if(l!==b&&A(l,t))return c[t]=4,l[t];rs&&(c[t]=0)}}let p=re[t];return p?("$attrs"===t&&eq(e.attrs,"get",""),p(e)):(r=u.__cssModules)&&(r=r[t])?r:l!==b&&A(l,t)?(c[t]=4,l[t]):A(i=d.config.globalProperties,t)?i[t]:void 0},set({_:e},t,n){let{data:r,setupState:i,ctx:l}=e;return rt(i,t)?(i[t]=n,!0):r!==b&&A(r,t)?(r[t]=n,!0):!A(e.props,t)&&!("$"===t[0]&&t.slice(1)in e)&&(l[t]=n,!0)},has({_:{data:e,setupState:t,accessCache:n,ctx:r,appContext:i,propsOptions:l}},s){let o;return!!n[s]||e!==b&&A(e,s)||rt(t,s)||(o=l[0])&&A(o,s)||A(r,s)||A(re,s)||A(i.config.globalProperties,s)},defineProperty(e,t,n){return null!=n.get?e._.accessCache[t]=0:A(n,"value")&&this.set(e,t,n.value,null),Reflect.defineProperty(e,t,n)}},rr=T({},rn,{get(e,t){if(t!==Symbol.unscopables)return rn.get(e,t,e)},has:(e,t)=>"_"!==t[0]&&!er(t)});function ri(){let e=iE();return e.setupContext||(e.setupContext=iF(e))}function rl(e){return E(e)?e.reduce((e,t)=>(e[t]=null,e),{}):e}let rs=!0;function ro(e,t,n){tq(E(e)?e.map(e=>e.bind(t.proxy)):e.bind(t.proxy),t,n)}function ra(e){let t,n=e.type,{mixins:r,extends:i}=n,{mixins:l,optionsCache:s,config:{optionMergeStrategies:o}}=e.appContext,a=s.get(n);return a?t=a:l.length||r||i?(t={},l.length&&l.forEach(e=>rc(t,e,o,!0)),rc(t,n,o)):t=n,$(n)&&s.set(n,t),t}function rc(e,t,n,r=!1){let{mixins:i,extends:l}=t;for(let s in l&&rc(e,l,n,!0),i&&i.forEach(t=>rc(e,t,n,!0)),t)if(r&&"expose"===s);else{let r=ru[s]||n&&n[s];e[s]=r?r(e[s],t[s]):t[s]}return e}let ru={data:rd,props:rm,emits:rm,methods:rf,computed:rf,beforeCreate:rh,created:rh,beforeMount:rh,mounted:rh,beforeUpdate:rh,updated:rh,beforeDestroy:rh,beforeUnmount:rh,destroyed:rh,unmounted:rh,activated:rh,deactivated:rh,errorCaptured:rh,serverPrefetch:rh,components:rf,directives:rf,watch:function(e,t){if(!e)return t;if(!t)return e;let n=T(Object.create(null),e);for(let r in t)n[r]=rh(e[r],t[r]);return n},provide:rd,inject:function(e,t){return rf(rp(e),rp(t))}};function rd(e,t){return t?e?function(){return T(P(e)?e.call(this,this):e,P(t)?t.call(this,this):t)}:t:e}function rp(e){if(E(e)){let t={};for(let n=0;n<e.length;n++)t[e[n]]=e[n];return t}return e}function rh(e,t){return e?[...new Set([].concat(e,t))]:t}function rf(e,t){return e?T(Object.create(null),e,t):t}function rm(e,t){return e?E(e)&&E(t)?[...new Set([...e,...t])]:T(Object.create(null),rl(e),rl(null!=t?t:{})):t}function rg(){return{app:null,config:{isNativeTag:x,performance:!1,globalProperties:{},optionMergeStrategies:{},errorHandler:void 0,warnHandler:void 0,compilerOptions:{}},mixins:[],components:{},directives:{},provides:Object.create(null),optionsCache:new WeakMap,propsCache:new WeakMap,emitsCache:new WeakMap}}let rv=0,ry=null;function rb(e,t){if(iA){let n=iA.provides,r=iA.parent&&iA.parent.provides;r===n&&(n=iA.provides=Object.create(r)),n[e]=t}}function r_(e,t,n=!1){let r=iA||t8;if(r||ry){let i=ry?ry._context.provides:r?null==r.parent||r.ce?r.vnode.appContext&&r.vnode.appContext.provides:r.parent.provides:void 0;if(i&&e in i)return i[e];if(arguments.length>1)return n&&P(t)?t.call(r&&r.proxy):t}}let rS={},rx=()=>Object.create(rS),rC=e=>Object.getPrototypeOf(e)===rS;function rk(e,t,n,r){let i,[l,s]=e.propsOptions,o=!1;if(t)for(let a in t){let c;if(j(a))continue;let u=t[a];l&&A(l,c=K(a))?s&&s.includes(c)?(i||(i={}))[c]=u:n[c]=u:rG(e.emitsOptions,a)||a in r&&u===r[a]||(r[a]=u,o=!0)}if(s){let t=tS(n),r=i||b;for(let i=0;i<s.length;i++){let o=s[i];n[o]=rT(l,t,o,r[o],e,!A(r,o))}}return o}function rT(e,t,n,r,i,l){let s=e[n];if(null!=s){let e=A(s,"default");if(e&&void 0===r){let e=s.default;if(s.type!==Function&&!s.skipFactory&&P(e)){let{propsDefaults:l}=i;if(n in l)r=l[n];else{let s=iI(i);r=l[n]=e.call(null,t),s()}}else r=e;i.ce&&i.ce._setProp(n,r)}s[0]&&(l&&!e?r=!1:s[1]&&(""===r||r===J(n))&&(r=!0))}return r}let rN=new WeakMap;function rw(e){return!("$"===e[0]||j(e))}let rA=e=>"_"===e[0]||"$stable"===e,rE=e=>E(e)?e.map(iS):[iS(e)],rI=(e,t,n)=>{if(t._n)return t;let r=t7((...e)=>rE(t(...e)),n);return r._c=!1,r},rR=(e,t,n)=>{let r=e._ctx;for(let n in e){if(rA(n))continue;let i=e[n];if(P(i))t[n]=rI(n,i,r);else if(null!=i){let e=rE(i);t[n]=()=>e}}},rO=(e,t)=>{let n=rE(t);e.slots.default=()=>n},rP=(e,t,n)=>{for(let r in t)(n||!rA(r))&&(e[r]=t[r])},rM=r8;function rL(e){return r$(e,nO)}function r$(e,t){var n;let r,i;en().__VUE__=!0;let{insert:l,remove:s,patchProp:o,createElement:a,createText:c,createComment:d,setText:p,setElementText:h,parentNode:f,nextSibling:m,setScopeId:g=S,insertStaticContent:y}=e,x=(e,t,n,r=null,i=null,l=null,s,o=null,a=!!t.dynamicChildren)=>{if(e===t)return;e&&!ip(e,t)&&(r=es(e),ee(e,i,l,!0),e=null),-2===t.patchFlag&&(a=!1,t.dynamicChildren=null);let{type:c,ref:u,shapeFlag:d}=t;switch(c){case r7:C(e,t,n,r);break;case ie:k(e,t,n,r);break;case it:null==e&&N(t,n,r,s);break;case r9:V(e,t,n,r,i,l,s,o,a);break;default:1&d?w(e,t,n,r,i,l,s,o,a):6&d?B(e,t,n,r,i,l,s,o,a):64&d?c.process(e,t,n,r,i,l,s,o,a,ec):128&d&&c.process(e,t,n,r,i,l,s,o,a,ec)}null!=u&&i?nw(u,e&&e.ref,l,t||e,!t):null==u&&e&&null!=e.ref&&nw(e.ref,null,l,e,!0)},C=(e,t,n,r)=>{if(null==e)l(t.el=c(t.children),n,r);else{let n=t.el=e.el;t.children!==e.children&&p(n,t.children)}},k=(e,t,n,r)=>{null==e?l(t.el=d(t.children||""),n,r):t.el=e.el},N=(e,t,n,r)=>{[e.el,e.anchor]=y(e.children,t,n,r,e.el,e.anchor)},w=(e,t,n,r,i,l,s,o,a)=>{"svg"===t.type?s="svg":"math"===t.type&&(s="mathml"),null==e?I(t,n,r,i,l,s,o,a):M(e,t,i,l,s,o,a)},I=(e,t,n,r,i,s,c,u)=>{let d,p,{props:f,shapeFlag:m,transition:g,dirs:y}=e;if(d=e.el=a(e.type,s,f&&f.is,f),8&m?h(d,e.children):16&m&&O(e.children,d,null,r,i,rD(e,s),c,u),y&&ne(e,null,r,"created"),R(d,e,e.scopeId,c,r),f){for(let e in f)"value"===e||j(e)||o(d,e,null,f[e],s,r);"value"in f&&o(d,"value",null,f.value,s),(p=f.onVnodeBeforeMount)&&iT(p,r,e)}y&&ne(e,null,r,"beforeMount");let b=rV(i,g);b&&g.beforeEnter(d),l(d,t,n),((p=f&&f.onVnodeMounted)||b||y)&&rM(()=>{p&&iT(p,r,e),b&&g.enter(d),y&&ne(e,null,r,"mounted")},i)},R=(e,t,n,r,i)=>{if(n&&g(e,n),r)for(let t=0;t<r.length;t++)g(e,r[t]);if(i){let n=i.subTree;if(t===n||r1(n.type)&&(n.ssContent===t||n.ssFallback===t)){let t=i.vnode;R(e,t,t.scopeId,t.slotScopeIds,i.parent)}}},O=(e,t,n,r,i,l,s,o,a=0)=>{for(let c=a;c<e.length;c++)x(null,e[c]=o?ix(e[c]):iS(e[c]),t,n,r,i,l,s,o)},M=(e,t,n,r,i,l,s)=>{let a,c=t.el=e.el,{patchFlag:u,dynamicChildren:d,dirs:p}=t;u|=16&e.patchFlag;let f=e.props||b,m=t.props||b;if(n&&rF(n,!1),(a=m.onVnodeBeforeUpdate)&&iT(a,n,t,e),p&&ne(t,e,n,"beforeUpdate"),n&&rF(n,!0),(f.innerHTML&&null==m.innerHTML||f.textContent&&null==m.textContent)&&h(c,""),d?L(e.dynamicChildren,d,c,n,r,rD(t,i),l):s||z(e,t,c,null,n,r,rD(t,i),l,!1),u>0){if(16&u)F(c,f,m,n,i);else if(2&u&&f.class!==m.class&&o(c,"class",null,m.class,i),4&u&&o(c,"style",f.style,m.style,i),8&u){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let r=e[t],l=f[r],s=m[r];(s!==l||"value"===r)&&o(c,r,l,s,i,n)}}1&u&&e.children!==t.children&&h(c,t.children)}else s||null!=d||F(c,f,m,n,i);((a=m.onVnodeUpdated)||p)&&rM(()=>{a&&iT(a,n,t,e),p&&ne(t,e,n,"updated")},r)},L=(e,t,n,r,i,l,s)=>{for(let o=0;o<t.length;o++){let a=e[o],c=t[o],u=a.el&&(a.type===r9||!ip(a,c)||198&a.shapeFlag)?f(a.el):n;x(a,c,u,null,r,i,l,s,!0)}},F=(e,t,n,r,i)=>{if(t!==n){if(t!==b)for(let l in t)j(l)||l in n||o(e,l,t[l],null,i,r);for(let l in n){if(j(l))continue;let s=n[l],a=t[l];s!==a&&"value"!==l&&o(e,l,a,s,i,r)}"value"in n&&o(e,"value",t.value,n.value,i)}},V=(e,t,n,r,i,s,o,a,u)=>{let d=t.el=e?e.el:c(""),p=t.anchor=e?e.anchor:c(""),{patchFlag:h,dynamicChildren:f,slotScopeIds:m}=t;m&&(a=a?a.concat(m):m),null==e?(l(d,n,r),l(p,n,r),O(t.children||[],n,p,i,s,o,a,u)):h>0&&64&h&&f&&e.dynamicChildren?(L(e.dynamicChildren,f,n,i,s,o,a),(null!=t.key||i&&t===i.subTree)&&rB(e,t,!0)):z(e,t,n,p,i,s,o,a,u)},B=(e,t,n,r,i,l,s,o,a)=>{t.slotScopeIds=o,null==e?512&t.shapeFlag?i.ctx.activate(t,n,r,s,a):U(t,n,r,i,l,s,a):H(e,t,a)},U=(e,t,n,r,i,l,s)=>{let o=e.component=function(e,t,n){let r=e.type,i=(t?t.appContext:e.appContext)||iN,l={uid:iw++,vnode:e,type:r,parent:t,appContext:i,root:null,next:null,subTree:null,effect:null,update:null,job:null,scope:new eS(!0),render:null,proxy:null,exposed:null,exposeProxy:null,withProxy:null,provides:t?t.provides:Object.create(i.provides),ids:t?t.ids:["",0,0],accessCache:null,renderCache:[],components:null,directives:null,propsOptions:function e(t,n,r=!1){let i=r?rN:n.propsCache,l=i.get(t);if(l)return l;let s=t.props,o={},a=[],c=!1;if(!P(t)){let i=t=>{c=!0;let[r,i]=e(t,n,!0);T(o,r),i&&a.push(...i)};!r&&n.mixins.length&&n.mixins.forEach(i),t.extends&&i(t.extends),t.mixins&&t.mixins.forEach(i)}if(!s&&!c)return $(t)&&i.set(t,_),_;if(E(s))for(let e=0;e<s.length;e++){let t=K(s[e]);rw(t)&&(o[t]=b)}else if(s)for(let e in s){let t=K(e);if(rw(t)){let n=s[e],r=o[t]=E(n)||P(n)?{type:n}:T({},n),i=r.type,l=!1,c=!0;if(E(i))for(let e=0;e<i.length;++e){let t=i[e],n=P(t)&&t.name;if("Boolean"===n){l=!0;break}"String"===n&&(c=!1)}else l=P(i)&&"Boolean"===i.name;r[0]=l,r[1]=c,(l||A(r,"default"))&&a.push(t)}}let u=[o,a];return $(t)&&i.set(t,u),u}(r,i),emitsOptions:function e(t,n,r=!1){let i=n.emitsCache,l=i.get(t);if(void 0!==l)return l;let s=t.emits,o={},a=!1;if(!P(t)){let i=t=>{let r=e(t,n,!0);r&&(a=!0,T(o,r))};!r&&n.mixins.length&&n.mixins.forEach(i),t.extends&&i(t.extends),t.mixins&&t.mixins.forEach(i)}return s||a?(E(s)?s.forEach(e=>o[e]=null):T(o,s),$(t)&&i.set(t,o),o):($(t)&&i.set(t,null),null)}(r,i),emit:null,emitted:null,propsDefaults:b,inheritAttrs:r.inheritAttrs,ctx:b,data:b,props:b,attrs:b,slots:b,refs:b,setupState:b,setupContext:null,suspense:n,suspenseId:n?n.pendingId:0,asyncDep:null,asyncResolved:!1,isMounted:!1,isUnmounted:!1,isDeactivated:!1,bc:null,c:null,bm:null,m:null,bu:null,u:null,um:null,bum:null,da:null,a:null,rtg:null,rtc:null,ec:null,sp:null};return l.ctx={_:l},l.root=t?t.root:l,l.emit=rJ.bind(null,l),e.ce&&e.ce(l),l}(e,r,i);nB(e)&&(o.ctx.renderer=ec),function(e,t=!1,n=!1){t&&u(t);let{props:r,children:i}=e.vnode,l=iO(e);!function(e,t,n,r=!1){let i={},l=rx();for(let n in e.propsDefaults=Object.create(null),rk(e,t,i,l),e.propsOptions[0])n in i||(i[n]=void 0);n?e.props=r?i:tf(i):e.type.props?e.props=i:e.props=l,e.attrs=l}(e,r,l,t),((e,t,n)=>{let r=e.slots=rx();if(32&e.vnode.shapeFlag){let e=t.__;e&&Y(r,"__",e,!0);let i=t._;i?(rP(r,t,n),n&&Y(r,"_",i,!0)):rR(t,r)}else t&&rO(e,t)})(e,i,n||t),l&&function(e,t){let n=e.type;e.accessCache=Object.create(null),e.proxy=new Proxy(e.ctx,rn);let{setup:r}=n;if(r){eM();let n=e.setupContext=r.length>1?iF(e):null,i=iI(e),l=tH(r,e,0,[e.props,n]),s=D(l);if(eL(),i(),(s||e.sp)&&!nF(e)&&nN(e),s){if(l.then(iR,iR),t)return l.then(n=>{iM(e,n,t)}).catch(t=>{tW(t,e,0)});e.asyncDep=l}else iM(e,l,t)}else i$(e,t)}(e,t),t&&u(!1)}(o,!1,s),o.asyncDep?(i&&i.registerDep(o,q,s),e.el||k(null,o.subTree=iv(ie),t,n)):q(o,e,t,n,i,l,s)},H=(e,t,n)=>{let r=t.component=e.component;if(function(e,t,n){let{props:r,children:i,component:l}=e,{props:s,children:o,patchFlag:a}=t,c=l.emitsOptions;if(t.dirs||t.transition)return!0;if(!n||!(a>=0))return(!!i||!!o)&&(!o||!o.$stable)||r!==s&&(r?!s||rY(r,s,c):!!s);if(1024&a)return!0;if(16&a)return r?rY(r,s,c):!!s;if(8&a){let e=t.dynamicProps;for(let t=0;t<e.length;t++){let n=e[t];if(s[n]!==r[n]&&!rG(c,n))return!0}}return!1}(e,t,n))if(r.asyncDep&&!r.asyncResolved)return void W(r,t,n);else r.next=t,r.update();else t.el=e.el,r.vnode=t},q=(e,t,n,r,l,s,o)=>{let a=()=>{if(e.isMounted){let t,{next:n,bu:r,u:i,parent:c,vnode:u}=e;{let t=function e(t){let n=t.subTree.component;if(n)if(n.asyncDep&&!n.asyncResolved)return n;else return e(n)}(e);if(t){n&&(n.el=u.el,W(e,n,o)),t.asyncDep.then(()=>{e.isUnmounted||a()});return}}let d=n;rF(e,!1),n?(n.el=u.el,W(e,n,o)):n=u,r&&Z(r),(t=n.props&&n.props.onVnodeBeforeUpdate)&&iT(t,c,n,u),rF(e,!0);let p=rX(e),h=e.subTree;e.subTree=p,x(h,p,f(h.el),es(h),e,l,s),n.el=p.el,null===d&&r0(e,p.el),i&&rM(i,l),(t=n.props&&n.props.onVnodeUpdated)&&rM(()=>iT(t,c,n,u),l)}else{let o,{el:a,props:c}=t,{bm:u,m:d,parent:p,root:h,type:f}=e,m=nF(t);if(rF(e,!1),u&&Z(u),!m&&(o=c&&c.onVnodeBeforeMount)&&iT(o,p,t),rF(e,!0),a&&i){let t=()=>{e.subTree=rX(e),i(a,e.subTree,e,l,null)};m&&f.__asyncHydrate?f.__asyncHydrate(a,e,t):t()}else{h.ce&&!1!==h.ce._def.shadowRoot&&h.ce._injectChildStyle(f);let i=e.subTree=rX(e);x(null,i,n,r,e,l,s),t.el=i.el}if(d&&rM(d,l),!m&&(o=c&&c.onVnodeMounted)){let e=t;rM(()=>iT(o,p,e),l)}(256&t.shapeFlag||p&&nF(p.vnode)&&256&p.vnode.shapeFlag)&&e.a&&rM(e.a,l),e.isMounted=!0,t=n=r=null}};e.scope.on();let c=e.effect=new eC(a);e.scope.off();let u=e.update=c.run.bind(c),d=e.job=c.runIfDirty.bind(c);d.i=e,d.id=e.uid,c.scheduler=()=>t0(d),rF(e,!0),u()},W=(e,t,n)=>{t.component=e;let r=e.vnode.props;e.vnode=t,e.next=null,function(e,t,n,r){let{props:i,attrs:l,vnode:{patchFlag:s}}=e,o=tS(i),[a]=e.propsOptions,c=!1;if((r||s>0)&&!(16&s)){if(8&s){let n=e.vnode.dynamicProps;for(let r=0;r<n.length;r++){let s=n[r];if(rG(e.emitsOptions,s))continue;let u=t[s];if(a)if(A(l,s))u!==l[s]&&(l[s]=u,c=!0);else{let t=K(s);i[t]=rT(a,o,t,u,e,!1)}else u!==l[s]&&(l[s]=u,c=!0)}}}else{let r;for(let s in rk(e,t,i,l)&&(c=!0),o)t&&(A(t,s)||(r=J(s))!==s&&A(t,r))||(a?n&&(void 0!==n[s]||void 0!==n[r])&&(i[s]=rT(a,o,s,void 0,e,!0)):delete i[s]);if(l!==o)for(let e in l)t&&A(t,e)||(delete l[e],c=!0)}c&&eW(e.attrs,"set","")}(e,t.props,r,n),((e,t,n)=>{let{vnode:r,slots:i}=e,l=!0,s=b;if(32&r.shapeFlag){let e=t._;e?n&&1===e?l=!1:rP(i,t,n):(l=!t.$stable,rR(t,i)),s=t}else t&&(rO(e,t),s={default:1});if(l)for(let e in i)rA(e)||null!=s[e]||delete i[e]})(e,t.children,n),eM(),t3(e),eL()},z=(e,t,n,r,i,l,s,o,a=!1)=>{let c=e&&e.children,u=e?e.shapeFlag:0,d=t.children,{patchFlag:p,shapeFlag:f}=t;if(p>0){if(128&p)return void X(c,d,n,r,i,l,s,o,a);else if(256&p)return void G(c,d,n,r,i,l,s,o,a)}8&f?(16&u&&el(c,i,l),d!==c&&h(n,d)):16&u?16&f?X(c,d,n,r,i,l,s,o,a):el(c,i,l,!0):(8&u&&h(n,""),16&f&&O(d,n,r,i,l,s,o,a))},G=(e,t,n,r,i,l,s,o,a)=>{let c;e=e||_,t=t||_;let u=e.length,d=t.length,p=Math.min(u,d);for(c=0;c<p;c++){let r=t[c]=a?ix(t[c]):iS(t[c]);x(e[c],r,n,null,i,l,s,o,a)}u>d?el(e,i,l,!0,!1,p):O(t,n,r,i,l,s,o,a,p)},X=(e,t,n,r,i,l,s,o,a)=>{let c=0,u=t.length,d=e.length-1,p=u-1;for(;c<=d&&c<=p;){let r=e[c],u=t[c]=a?ix(t[c]):iS(t[c]);if(ip(r,u))x(r,u,n,null,i,l,s,o,a);else break;c++}for(;c<=d&&c<=p;){let r=e[d],c=t[p]=a?ix(t[p]):iS(t[p]);if(ip(r,c))x(r,c,n,null,i,l,s,o,a);else break;d--,p--}if(c>d){if(c<=p){let e=p+1,d=e<u?t[e].el:r;for(;c<=p;)x(null,t[c]=a?ix(t[c]):iS(t[c]),n,d,i,l,s,o,a),c++}}else if(c>p)for(;c<=d;)ee(e[c],i,l,!0),c++;else{let h,f=c,m=c,g=new Map;for(c=m;c<=p;c++){let e=t[c]=a?ix(t[c]):iS(t[c]);null!=e.key&&g.set(e.key,c)}let y=0,b=p-m+1,S=!1,C=0,k=Array(b);for(c=0;c<b;c++)k[c]=0;for(c=f;c<=d;c++){let r,u=e[c];if(y>=b){ee(u,i,l,!0);continue}if(null!=u.key)r=g.get(u.key);else for(h=m;h<=p;h++)if(0===k[h-m]&&ip(u,t[h])){r=h;break}void 0===r?ee(u,i,l,!0):(k[r-m]=c+1,r>=C?C=r:S=!0,x(u,t[r],n,null,i,l,s,o,a),y++)}let T=S?function(e){let t,n,r,i,l,s=e.slice(),o=[0],a=e.length;for(t=0;t<a;t++){let a=e[t];if(0!==a){if(e[n=o[o.length-1]]<a){s[t]=n,o.push(t);continue}for(r=0,i=o.length-1;r<i;)e[o[l=r+i>>1]]<a?r=l+1:i=l;a<e[o[r]]&&(r>0&&(s[t]=o[r-1]),o[r]=t)}}for(r=o.length,i=o[r-1];r-- >0;)o[r]=i,i=s[i];return o}(k):_;for(h=T.length-1,c=b-1;c>=0;c--){let e=m+c,d=t[e],p=e+1<u?t[e+1].el:r;0===k[c]?x(null,d,n,p,i,l,s,o,a):S&&(h<0||c!==T[h]?Q(d,n,p,2):h--)}}},Q=(e,t,n,r,i=null)=>{let{el:o,type:a,transition:c,children:u,shapeFlag:d}=e;if(6&d)return void Q(e.component.subTree,t,n,r);if(128&d)return void e.suspense.move(t,n,r);if(64&d)return void a.move(e,t,n,ec);if(a===r9){l(o,t,n);for(let e=0;e<u.length;e++)Q(u[e],t,n,r);l(e.anchor,t,n);return}if(a===it)return void(({el:e,anchor:t},n,r)=>{let i;for(;e&&e!==t;)i=m(e),l(e,n,r),e=i;l(t,n,r)})(e,t,n);if(2!==r&&1&d&&c)if(0===r)c.beforeEnter(o),l(o,t,n),rM(()=>c.enter(o),i);else{let{leave:r,delayLeave:i,afterLeave:a}=c,u=()=>{e.ctx.isUnmounted?s(o):l(o,t,n)},d=()=>{r(o,()=>{u(),a&&a()})};i?i(o,u,d):d()}else l(o,t,n)},ee=(e,t,n,r=!1,i=!1)=>{let l,{type:s,props:o,ref:a,children:c,dynamicChildren:u,shapeFlag:d,patchFlag:p,dirs:h,cacheIndex:f}=e;if(-2===p&&(i=!1),null!=a&&(eM(),nw(a,null,n,e,!0),eL()),null!=f&&(t.renderCache[f]=void 0),256&d)return void t.ctx.deactivate(e);let m=1&d&&h,g=!nF(e);if(g&&(l=o&&o.onVnodeBeforeUnmount)&&iT(l,t,e),6&d)ei(e.component,n,r);else{if(128&d)return void e.suspense.unmount(n,r);m&&ne(e,null,t,"beforeUnmount"),64&d?e.type.remove(e,t,n,ec,r):u&&!u.hasOnce&&(s!==r9||p>0&&64&p)?el(u,t,n,!1,!0):(s===r9&&384&p||!i&&16&d)&&el(c,t,n),r&&et(e)}(g&&(l=o&&o.onVnodeUnmounted)||m)&&rM(()=>{l&&iT(l,t,e),m&&ne(e,null,t,"unmounted")},n)},et=e=>{let{type:t,el:n,anchor:r,transition:i}=e;if(t===r9)return void er(n,r);if(t===it)return void(({el:e,anchor:t})=>{let n;for(;e&&e!==t;)n=m(e),s(e),e=n;s(t)})(e);let l=()=>{s(n),i&&!i.persisted&&i.afterLeave&&i.afterLeave()};if(1&e.shapeFlag&&i&&!i.persisted){let{leave:t,delayLeave:r}=i,s=()=>t(n,l);r?r(e.el,l,s):s()}else l()},er=(e,t)=>{let n;for(;e!==t;)n=m(e),s(e),e=n;s(t)},ei=(e,t,n)=>{let{bum:r,scope:i,job:l,subTree:s,um:o,m:a,a:c,parent:u,slots:{__:d}}=e;rU(a),rU(c),r&&Z(r),u&&E(d)&&d.forEach(e=>{u.renderCache[e]=void 0}),i.stop(),l&&(l.flags|=8,ee(s,e,t,n)),o&&rM(o,t),rM(()=>{e.isUnmounted=!0},t),t&&t.pendingBranch&&!t.isUnmounted&&e.asyncDep&&!e.asyncResolved&&e.suspenseId===t.pendingId&&(t.deps--,0===t.deps&&t.resolve())},el=(e,t,n,r=!1,i=!1,l=0)=>{for(let s=l;s<e.length;s++)ee(e[s],t,n,r,i)},es=e=>{if(6&e.shapeFlag)return es(e.component.subTree);if(128&e.shapeFlag)return e.suspense.next();let t=m(e.anchor||e.el),n=t&&t[nt];return n?m(n):t},eo=!1,ea=(e,t,n)=>{null==e?t._vnode&&ee(t._vnode,null,null,!0):x(t._vnode||null,e,t,null,null,null,n),t._vnode=e,eo||(eo=!0,t3(),t6(),eo=!1)},ec={p:x,um:ee,m:Q,r:et,mt:U,mc:O,pc:z,pbc:L,n:es,o:e};return t&&([r,i]=t(ec)),{render:ea,hydrate:r,createApp:(n=r,function(e,t=null){P(e)||(e=T({},e)),null==t||$(t)||(t=null);let r=rg(),i=new WeakSet,l=[],s=!1,o=r.app={_uid:rv++,_component:e,_props:t,_container:null,_context:r,_instance:null,version:iq,get config(){return r.config},set config(v){},use:(e,...t)=>(i.has(e)||(e&&P(e.install)?(i.add(e),e.install(o,...t)):P(e)&&(i.add(e),e(o,...t))),o),mixin:e=>(r.mixins.includes(e)||r.mixins.push(e),o),component:(e,t)=>t?(r.components[e]=t,o):r.components[e],directive:(e,t)=>t?(r.directives[e]=t,o):r.directives[e],mount(i,l,a){if(!s){let c=o._ceVNode||iv(e,t);return c.appContext=r,!0===a?a="svg":!1===a&&(a=void 0),l&&n?n(c,i):ea(c,i,a),s=!0,o._container=i,i.__vue_app__=o,iV(c.component)}},onUnmount(e){l.push(e)},unmount(){s&&(tq(l,o._instance,16),ea(null,o._container),delete o._container.__vue_app__)},provide:(e,t)=>(r.provides[e]=t,o),runWithContext(e){let t=ry;ry=o;try{return e()}finally{ry=t}}};return o})}}function rD({type:e,props:t},n){return"svg"===n&&"foreignObject"===e||"mathml"===n&&"annotation-xml"===e&&t&&t.encoding&&t.encoding.includes("html")?void 0:n}function rF({effect:e,job:t},n){n?(e.flags|=32,t.flags|=4):(e.flags&=-33,t.flags&=-5)}function rV(e,t){return(!e||e&&!e.pendingBranch)&&t&&!t.persisted}function rB(e,t,n=!1){let r=e.children,i=t.children;if(E(r)&&E(i))for(let e=0;e<r.length;e++){let t=r[e],l=i[e];1&l.shapeFlag&&!l.dynamicChildren&&((l.patchFlag<=0||32===l.patchFlag)&&((l=i[e]=ix(i[e])).el=t.el),n||-2===l.patchFlag||rB(t,l)),l.type===r7&&(l.el=t.el),l.type!==ie||l.el||(l.el=t.el)}}function rU(e){if(e)for(let t=0;t<e.length;t++)e[t].flags|=8}let rj=Symbol.for("v-scx");function rH(e,t){return rq(e,null,{flush:"sync"})}function rq(e,t,n=b){let{immediate:r,deep:i,flush:s,once:o}=n,a=T({},n),c=iA;a.call=(e,t,n)=>tq(e,c,t,n);let u=!1;return"post"===s?a.scheduler=e=>{rM(e,c&&c.suspense)}:"sync"!==s&&(u=!0,a.scheduler=(e,t)=>{t?e():t0(e)}),a.augmentJob=e=>{t&&(e.flags|=4),u&&(e.flags|=2,c&&(e.id=c.uid,e.i=c))},function(e,t,n=b){let r,i,s,o,{immediate:a,deep:c,once:u,scheduler:d,augmentJob:p,call:h}=n,f=e=>c?e:tb(e)||!1===c||0===c?tj(e,1):tj(e),g=!1,y=!1;if(tT(e)?(i=()=>e.value,g=tb(e)):tv(e)?(i=()=>f(e),g=!0):E(e)?(y=!0,g=e.some(e=>tv(e)||tb(e)),i=()=>e.map(e=>tT(e)?e.value:tv(e)?f(e):P(e)?h?h(e,2):e():void 0)):i=P(e)?t?h?()=>h(e,2):e:()=>{if(s){eM();try{s()}finally{eL()}}let t=m;m=r;try{return h?h(e,3,[o]):e(o)}finally{m=t}}:S,t&&c){let e=i,t=!0===c?1/0:c;i=()=>tj(e(),t)}let _=l,x=()=>{r.stop(),_&&_.active&&N(_.effects,r)};if(u&&t){let e=t;t=(...t)=>{e(...t),x()}}let C=y?Array(e.length).fill(tV):tV,k=e=>{if(1&r.flags&&(r.dirty||e))if(t){let e=r.run();if(c||g||(y?e.some((e,t)=>Q(e,C[t])):Q(e,C))){s&&s();let n=m;m=r;try{let n=[e,C===tV?void 0:y&&C[0]===tV?[]:C,o];C=e,h?h(t,3,n):t(...n)}finally{m=n}}}else r.run()};return p&&p(k),(r=new eC(i)).scheduler=d?()=>d(k,!1):k,o=e=>tU(e,!1,r),s=r.onStop=()=>{let e=tB.get(r);if(e){if(h)h(e,4);else for(let t of e)t();tB.delete(r)}},t?a?k(!0):C=r.run():d?d(k.bind(null,!0),!0):r.run(),x.pause=r.pause.bind(r),x.resume=r.resume.bind(r),x.stop=x,x}(e,t,a)}function rW(e,t,n){let r,i=this.proxy,l=M(e)?e.includes(".")?rK(i,e):()=>i[e]:e.bind(i,i);P(t)?r=t:(r=t.handler,n=t);let s=iI(this),o=rq(l,r.bind(i),n);return s(),o}function rK(e,t){let n=t.split(".");return()=>{let t=e;for(let e=0;e<n.length&&t;e++)t=t[n[e]];return t}}let rz=(e,t)=>"modelValue"===t||"model-value"===t?e.modelModifiers:e[`${t}Modifiers`]||e[`${K(t)}Modifiers`]||e[`${J(t)}Modifiers`];function rJ(e,t,...n){let r;if(e.isUnmounted)return;let i=e.vnode.props||b,l=n,s=t.startsWith("update:"),o=s&&rz(i,t.slice(7));o&&(o.trim&&(l=n.map(e=>M(e)?e.trim():e)),o.number&&(l=n.map(ee)));let a=i[r=X(t)]||i[r=X(K(t))];!a&&s&&(a=i[r=X(J(t))]),a&&tq(a,e,6,l);let c=i[r+"Once"];if(c){if(e.emitted){if(e.emitted[r])return}else e.emitted={};e.emitted[r]=!0,tq(c,e,6,l)}}function rG(e,t){return!!e&&!!C(t)&&(A(e,(t=t.slice(2).replace(/Once$/,""))[0].toLowerCase()+t.slice(1))||A(e,J(t))||A(e,t))}function rX(e){let t,n,{type:r,vnode:i,proxy:l,withProxy:s,propsOptions:[o],slots:a,attrs:c,emit:u,render:d,renderCache:p,props:h,data:f,setupState:m,ctx:g,inheritAttrs:y}=e,b=t9(e);try{if(4&i.shapeFlag){let e=s||l;t=iS(d.call(e,e,p,h,m,f,g)),n=c}else t=iS(r.length>1?r(h,{attrs:c,slots:a,emit:u}):r(h,null)),n=r.props?c:rQ(c)}catch(n){ir.length=0,tW(n,e,1),t=iv(ie)}let _=t;if(n&&!1!==y){let e=Object.keys(n),{shapeFlag:t}=_;e.length&&7&t&&(o&&e.some(k)&&(n=rZ(n,o)),_=ib(_,n,!1,!0))}return i.dirs&&((_=ib(_,null,!1,!0)).dirs=_.dirs?_.dirs.concat(i.dirs):i.dirs),i.transition&&nC(_,i.transition),t=_,t9(b),t}let rQ=e=>{let t;for(let n in e)("class"===n||"style"===n||C(n))&&((t||(t={}))[n]=e[n]);return t},rZ=(e,t)=>{let n={};for(let r in e)k(r)&&r.slice(9)in t||(n[r]=e[r]);return n};function rY(e,t,n){let r=Object.keys(t);if(r.length!==Object.keys(e).length)return!0;for(let i=0;i<r.length;i++){let l=r[i];if(t[l]!==e[l]&&!rG(n,l))return!0}return!1}function r0({vnode:e,parent:t},n){for(;t;){let r=t.subTree;if(r.suspense&&r.suspense.activeBranch===e&&(r.el=e.el),r===e)(e=t.vnode).el=n,t=t.parent;else break}}let r1=e=>e.__isSuspense,r2=0;function r3(e,t){let n=e.props&&e.props[t];P(n)&&n()}function r6(e,t,n,r,i,l,s,o,a,c,u=!1){let d,{p:p,m:h,um:f,n:m,o:{parentNode:g,remove:y}}=c,b=function(e){let t=e.props&&e.props.suspensible;return null!=t&&!1!==t}(e);b&&t&&t.pendingBranch&&(d=t.pendingId,t.deps++);let _=e.props?et(e.props.timeout):void 0,S=l,x={vnode:e,parent:t,parentComponent:n,namespace:s,container:r,hiddenContainer:i,deps:0,pendingId:r2++,timeout:"number"==typeof _?_:-1,activeBranch:null,pendingBranch:null,isInFallback:!u,isHydrating:u,isUnmounted:!1,effects:[],resolve(e=!1,n=!1){let{vnode:r,activeBranch:i,pendingBranch:s,pendingId:o,effects:a,parentComponent:c,container:u}=x,p=!1;x.isHydrating?x.isHydrating=!1:!e&&((p=i&&s.transition&&"out-in"===s.transition.mode)&&(i.transition.afterLeave=()=>{o===x.pendingId&&(h(s,u,l===S?m(i):l,0),t2(a))}),i&&(g(i.el)===u&&(l=m(i)),f(i,c,x,!0)),p||h(s,u,l,0)),r5(x,s),x.pendingBranch=null,x.isInFallback=!1;let y=x.parent,_=!1;for(;y;){if(y.pendingBranch){y.effects.push(...a),_=!0;break}y=y.parent}_||p||t2(a),x.effects=[],b&&t&&t.pendingBranch&&d===t.pendingId&&(t.deps--,0!==t.deps||n||t.resolve()),r3(r,"onResolve")},fallback(e){if(!x.pendingBranch)return;let{vnode:t,activeBranch:n,parentComponent:r,container:i,namespace:l}=x;r3(t,"onFallback");let s=m(n),c=()=>{x.isInFallback&&(p(null,e,i,s,r,null,l,o,a),r5(x,e))},u=e.transition&&"out-in"===e.transition.mode;u&&(n.transition.afterLeave=c),x.isInFallback=!0,f(n,r,null,!0),u||c()},move(e,t,n){x.activeBranch&&h(x.activeBranch,e,t,n),x.container=e},next:()=>x.activeBranch&&m(x.activeBranch),registerDep(e,t,n){let r=!!x.pendingBranch;r&&x.deps++;let i=e.vnode.el;e.asyncDep.catch(t=>{tW(t,e,0)}).then(l=>{if(e.isUnmounted||x.isUnmounted||x.pendingId!==e.suspenseId)return;e.asyncResolved=!0;let{vnode:o}=e;iM(e,l,!1),i&&(o.el=i);let a=!i&&e.subTree.el;t(e,o,g(i||e.subTree.el),i?null:m(e.subTree),x,s,n),a&&y(a),r0(e,o.el),r&&0==--x.deps&&x.resolve()})},unmount(e,t){x.isUnmounted=!0,x.activeBranch&&f(x.activeBranch,n,e,t),x.pendingBranch&&f(x.pendingBranch,n,e,t)}};return x}function r4(e){let t;if(P(e)){let n=io&&e._c;n&&(e._d=!1,il()),e=e(),n&&(e._d=!0,t=ii,is())}return E(e)&&(e=function(e,t=!0){let n;for(let t=0;t<e.length;t++){let r=e[t];if(!id(r))return;if(r.type!==ie||"v-if"===r.children)if(n)return;else n=r}return n}(e)),e=iS(e),t&&!e.dynamicChildren&&(e.dynamicChildren=t.filter(t=>t!==e)),e}function r8(e,t){t&&t.pendingBranch?E(e)?t.effects.push(...e):t.effects.push(e):t2(e)}function r5(e,t){e.activeBranch=t;let{vnode:n,parentComponent:r}=e,i=t.el;for(;!i&&t.component;)i=(t=t.component.subTree).el;n.el=i,r&&r.subTree===n&&(r.vnode.el=i,r0(r,i))}let r9=Symbol.for("v-fgt"),r7=Symbol.for("v-txt"),ie=Symbol.for("v-cmt"),it=Symbol.for("v-stc"),ir=[],ii=null;function il(e=!1){ir.push(ii=e?null:[])}function is(){ir.pop(),ii=ir[ir.length-1]||null}let io=1;function ia(e,t=!1){io+=e,e<0&&ii&&t&&(ii.hasOnce=!0)}function ic(e){return e.dynamicChildren=io>0?ii||_:null,is(),io>0&&ii&&ii.push(e),e}function iu(e,t,n,r,i){return ic(iv(e,t,n,r,i,!0))}function id(e){return!!e&&!0===e.__v_isVNode}function ip(e,t){return e.type===t.type&&e.key===t.key}let ih=({key:e})=>null!=e?e:null,im=({ref:e,ref_key:t,ref_for:n})=>("number"==typeof e&&(e=""+e),null!=e?M(e)||tT(e)||P(e)?{i:t8,r:e,k:t,f:!!n}:e:null);function ig(e,t=null,n=null,r=0,i=null,l=+(e!==r9),s=!1,o=!1){let a={__v_isVNode:!0,__v_skip:!0,type:e,props:t,key:t&&ih(t),ref:t&&im(t),scopeId:t5,slotScopeIds:null,children:n,component:null,suspense:null,ssContent:null,ssFallback:null,dirs:null,transition:null,el:null,anchor:null,target:null,targetStart:null,targetAnchor:null,staticCount:0,shapeFlag:l,patchFlag:r,dynamicProps:i,dynamicChildren:null,appContext:null,ctx:t8};return o?(iC(a,n),128&l&&e.normalize(a)):n&&(a.shapeFlag|=M(n)?8:16),io>0&&!s&&ii&&(a.patchFlag>0||6&l)&&32!==a.patchFlag&&ii.push(a),a}let iv=function(e,t=null,n=null,r=0,i=null,l=!1){var s;if(e&&e!==n8||(e=ie),id(e)){let r=ib(e,t,!0);return n&&iC(r,n),io>0&&!l&&ii&&(6&r.shapeFlag?ii[ii.indexOf(e)]=r:ii.push(r)),r.patchFlag=-2,r}if(P(s=e)&&"__vccOpts"in s&&(e=e.__vccOpts),t){let{class:e,style:n}=t=iy(t);e&&!M(e)&&(t.class=ec(e)),$(n)&&(t_(n)&&!E(n)&&(n=T({},n)),t.style=ei(n))}let o=M(e)?1:r1(e)?128:e.__isTeleport?64:$(e)?4:2*!!P(e);return ig(e,t,n,r,i,o,l,!0)};function iy(e){return e?t_(e)||rC(e)?T({},e):e:null}function ib(e,t,n=!1,r=!1){let{props:i,ref:l,patchFlag:s,children:o,transition:a}=e,c=t?ik(i||{},t):i,u={__v_isVNode:!0,__v_skip:!0,type:e.type,props:c,key:c&&ih(c),ref:t&&t.ref?n&&l?E(l)?l.concat(im(t)):[l,im(t)]:im(t):l,scopeId:e.scopeId,slotScopeIds:e.slotScopeIds,children:o,target:e.target,targetStart:e.targetStart,targetAnchor:e.targetAnchor,staticCount:e.staticCount,shapeFlag:e.shapeFlag,patchFlag:t&&e.type!==r9?-1===s?16:16|s:s,dynamicProps:e.dynamicProps,dynamicChildren:e.dynamicChildren,appContext:e.appContext,dirs:e.dirs,transition:a,component:e.component,suspense:e.suspense,ssContent:e.ssContent&&ib(e.ssContent),ssFallback:e.ssFallback&&ib(e.ssFallback),el:e.el,anchor:e.anchor,ctx:e.ctx,ce:e.ce};return a&&r&&nC(u,a.clone(u)),u}function i_(e=" ",t=0){return iv(r7,null,e,t)}function iS(e){return null==e||"boolean"==typeof e?iv(ie):E(e)?iv(r9,null,e.slice()):id(e)?ix(e):iv(r7,null,String(e))}function ix(e){return null===e.el&&-1!==e.patchFlag||e.memo?e:ib(e)}function iC(e,t){let n=0,{shapeFlag:r}=e;if(null==t)t=null;else if(E(t))n=16;else if("object"==typeof t)if(65&r){let n=t.default;n&&(n._c&&(n._d=!1),iC(e,n()),n._c&&(n._d=!0));return}else{n=32;let r=t._;r||rC(t)?3===r&&t8&&(1===t8.slots._?t._=1:(t._=2,e.patchFlag|=1024)):t._ctx=t8}else P(t)?(t={default:t,_ctx:t8},n=32):(t=String(t),64&r?(n=16,t=[i_(t)]):n=8);e.children=t,e.shapeFlag|=n}function ik(...e){let t={};for(let n=0;n<e.length;n++){let r=e[n];for(let e in r)if("class"===e)t.class!==r.class&&(t.class=ec([t.class,r.class]));else if("style"===e)t.style=ei([t.style,r.style]);else if(C(e)){let n=t[e],i=r[e];i&&n!==i&&!(E(n)&&n.includes(i))&&(t[e]=n?[].concat(n,i):i)}else""!==e&&(t[e]=r[e])}return t}function iT(e,t,n,r=null){tq(e,t,7,[n,r])}let iN=rg(),iw=0,iA=null,iE=()=>iA||t8;c=e=>{iA=e},u=e=>{iP=e};let iI=e=>{let t=iA;return c(e),e.scope.on(),()=>{e.scope.off(),c(t)}},iR=()=>{iA&&iA.scope.off(),c(null)};function iO(e){return 4&e.vnode.shapeFlag}let iP=!1;function iM(e,t,n){P(t)?e.render=t:$(t)&&(e.setupState=tO(t)),i$(e,n)}function iL(e){d=e,p=e=>{e.render._rc&&(e.withProxy=new Proxy(e.ctx,rr))}}function i$(e,t,n){let r=e.type;if(!e.render){if(!t&&d&&!r.render){let t=r.template||ra(e).template;if(t){let{isCustomElement:n,compilerOptions:i}=e.appContext.config,{delimiters:l,compilerOptions:s}=r,o=T(T({isCustomElement:n,delimiters:l},i),s);r.render=d(t,o)}}e.render=r.render||S,p&&p(e)}{let t=iI(e);eM();try{!function(e){let t=ra(e),n=e.proxy,r=e.ctx;rs=!1,t.beforeCreate&&ro(t.beforeCreate,e,"bc");let{data:i,computed:l,methods:s,watch:o,provide:a,inject:c,created:u,beforeMount:d,mounted:p,beforeUpdate:h,updated:f,activated:m,deactivated:g,beforeDestroy:y,beforeUnmount:b,destroyed:_,unmounted:x,render:C,renderTracked:k,renderTriggered:T,errorCaptured:N,serverPrefetch:w,expose:A,inheritAttrs:I,components:R,directives:O,filters:L}=t;if(c&&function(e,t,n=S){for(let n in E(e)&&(e=rp(e)),e){let r,i=e[n];tT(r=$(i)?"default"in i?r_(i.from||n,i.default,!0):r_(i.from||n):r_(i))?Object.defineProperty(t,n,{enumerable:!0,configurable:!0,get:()=>r.value,set:e=>r.value=e}):t[n]=r}}(c,r,null),s)for(let e in s){let t=s[e];P(t)&&(r[e]=t.bind(n))}if(i){let t=i.call(n,n);$(t)&&(e.data=th(t))}if(rs=!0,l)for(let e in l){let t=l[e],i=P(t)?t.bind(n,n):P(t.get)?t.get.bind(n,n):S,s=iU({get:i,set:!P(t)&&P(t.set)?t.set.bind(n):S});Object.defineProperty(r,e,{enumerable:!0,configurable:!0,get:()=>s.value,set:e=>s.value=e})}if(o)for(let e in o)!function e(t,n,r,i){var l,s,o,a,c,u,d;let p=i.includes(".")?rK(r,i):()=>r[i];if(M(t)){let e=n[t];P(e)&&(l=p,s=e,rq(l,s,void 0))}else if(P(t)){o=p,a=t.bind(r),rq(o,a,void 0)}else if($(t))if(E(t))t.forEach(t=>e(t,n,r,i));else{let e=P(t.handler)?t.handler.bind(r):n[t.handler];P(e)&&(c=p,u=e,d=t,rq(c,u,d))}}(o[e],r,n,e);if(a){let e=P(a)?a.call(n):a;Reflect.ownKeys(e).forEach(t=>{rb(t,e[t])})}function D(e,t){E(t)?t.forEach(t=>e(t.bind(n))):t&&e(t.bind(n))}if(u&&ro(u,e,"c"),D(nG,d),D(nX,p),D(nQ,h),D(nZ,f),D(nj,m),D(nH,g),D(n6,N),D(n3,k),D(n2,T),D(nY,b),D(n0,x),D(n1,w),E(A))if(A.length){let t=e.exposed||(e.exposed={});A.forEach(e=>{Object.defineProperty(t,e,{get:()=>n[e],set:t=>n[e]=t})})}else e.exposed||(e.exposed={});C&&e.render===S&&(e.render=C),null!=I&&(e.inheritAttrs=I),R&&(e.components=R),O&&(e.directives=O)}(e)}finally{eL(),t()}}}let iD={get:(e,t)=>(eq(e,"get",""),e[t])};function iF(e){return{attrs:new Proxy(e.attrs,iD),slots:e.slots,emit:e.emit,expose:t=>{e.exposed=t||{}}}}function iV(e){return e.exposed?e.exposeProxy||(e.exposeProxy=new Proxy(tO(tx(e.exposed)),{get:(t,n)=>n in t?t[n]:n in re?re[n](e):void 0,has:(e,t)=>t in e||t in re})):e.proxy}function iB(e,t=!0){return P(e)?e.displayName||e.name:e.name||t&&e.__name}let iU=(e,t)=>(function(e,t,n=!1){let r,i;return P(e)?r=e:(r=e.get,i=e.set),new tF(r,i,n)})(e,0,iP);function ij(e,t,n){let r=arguments.length;return 2!==r?(r>3?n=Array.prototype.slice.call(arguments,2):3===r&&id(n)&&(n=[n]),iv(e,t,n)):!$(t)||E(t)?iv(e,null,t):id(t)?iv(e,null,[t]):iv(e,t)}function iH(e,t){let n=e.memo;if(n.length!=t.length)return!1;for(let e=0;e<n.length;e++)if(Q(n[e],t[e]))return!1;return io>0&&ii&&ii.push(e),!0}let iq="3.5.17",iW="undefined"!=typeof window&&window.trustedTypes;if(iW)try{g=iW.createPolicy("vue",{createHTML:e=>e})}catch(e){}let iK=g?e=>g.createHTML(e):e=>e,iz="undefined"!=typeof document?document:null,iJ=iz&&iz.createElement("template"),iG="transition",iX="animation",iQ=Symbol("_vtc"),iZ={name:String,type:String,css:{type:Boolean,default:!0},duration:[String,Number,Object],enterFromClass:String,enterActiveClass:String,enterToClass:String,appearFromClass:String,appearActiveClass:String,appearToClass:String,leaveFromClass:String,leaveActiveClass:String,leaveToClass:String},iY=T({},nm,iZ),i0=((t=(e,{slots:t})=>ij(ny,i3(e),t)).displayName="Transition",t.props=iY,t),i1=(e,t=[])=>{E(e)?e.forEach(e=>e(...t)):e&&e(...t)},i2=e=>!!e&&(E(e)?e.some(e=>e.length>1):e.length>1);function i3(e){let t={};for(let n in e)n in iZ||(t[n]=e[n]);if(!1===e.css)return t;let{name:n="v",type:r,duration:i,enterFromClass:l=`${n}-enter-from`,enterActiveClass:s=`${n}-enter-active`,enterToClass:o=`${n}-enter-to`,appearFromClass:a=l,appearActiveClass:c=s,appearToClass:u=o,leaveFromClass:d=`${n}-leave-from`,leaveActiveClass:p=`${n}-leave-active`,leaveToClass:h=`${n}-leave-to`}=e,f=function(e){if(null==e)return null;{if($(e))return[function(e){return et(e)}(e.enter),function(e){return et(e)}(e.leave)];let t=function(e){return et(e)}(e);return[t,t]}}(i),m=f&&f[0],g=f&&f[1],{onBeforeEnter:y,onEnter:b,onEnterCancelled:_,onLeave:S,onLeaveCancelled:x,onBeforeAppear:C=y,onAppear:k=b,onAppearCancelled:N=_}=t,w=(e,t,n,r)=>{e._enterCancelled=r,i4(e,t?u:o),i4(e,t?c:s),n&&n()},A=(e,t)=>{e._isLeaving=!1,i4(e,d),i4(e,h),i4(e,p),t&&t()},E=e=>(t,n)=>{let i=e?k:b,s=()=>w(t,e,n);i1(i,[t,s]),i8(()=>{i4(t,e?a:l),i6(t,e?u:o),i2(i)||i9(t,r,m,s)})};return T(t,{onBeforeEnter(e){i1(y,[e]),i6(e,l),i6(e,s)},onBeforeAppear(e){i1(C,[e]),i6(e,a),i6(e,c)},onEnter:E(!1),onAppear:E(!0),onLeave(e,t){e._isLeaving=!0;let n=()=>A(e,t);i6(e,d),e._enterCancelled?(i6(e,p),ln()):(ln(),i6(e,p)),i8(()=>{e._isLeaving&&(i4(e,d),i6(e,h),i2(S)||i9(e,r,g,n))}),i1(S,[e,n])},onEnterCancelled(e){w(e,!1,void 0,!0),i1(_,[e])},onAppearCancelled(e){w(e,!0,void 0,!0),i1(N,[e])},onLeaveCancelled(e){A(e),i1(x,[e])}})}function i6(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.add(t)),(e[iQ]||(e[iQ]=new Set)).add(t)}function i4(e,t){t.split(/\s+/).forEach(t=>t&&e.classList.remove(t));let n=e[iQ];n&&(n.delete(t),n.size||(e[iQ]=void 0))}function i8(e){requestAnimationFrame(()=>{requestAnimationFrame(e)})}let i5=0;function i9(e,t,n,r){let i=e._endId=++i5,l=()=>{i===e._endId&&r()};if(null!=n)return setTimeout(l,n);let{type:s,timeout:o,propCount:a}=i7(e,t);if(!s)return r();let c=s+"end",u=0,d=()=>{e.removeEventListener(c,p),l()},p=t=>{t.target===e&&++u>=a&&d()};setTimeout(()=>{u<a&&d()},o+1),e.addEventListener(c,p)}function i7(e,t){let n=window.getComputedStyle(e),r=e=>(n[e]||"").split(", "),i=r(`${iG}Delay`),l=r(`${iG}Duration`),s=le(i,l),o=r(`${iX}Delay`),a=r(`${iX}Duration`),c=le(o,a),u=null,d=0,p=0;t===iG?s>0&&(u=iG,d=s,p=l.length):t===iX?c>0&&(u=iX,d=c,p=a.length):p=(u=(d=Math.max(s,c))>0?s>c?iG:iX:null)?u===iG?l.length:a.length:0;let h=u===iG&&/\b(transform|all)(,|$)/.test(r(`${iG}Property`).toString());return{type:u,timeout:d,propCount:p,hasTransform:h}}function le(e,t){for(;e.length<t.length;)e=e.concat(e);return Math.max(...t.map((t,n)=>lt(t)+lt(e[n])))}function lt(e){return"auto"===e?0:1e3*Number(e.slice(0,-1).replace(",","."))}function ln(){return document.body.offsetHeight}let lr=Symbol("_vod"),li=Symbol("_vsh");function ll(e,t){e.style.display=t?e[lr]:"none",e[li]=!t}let ls=Symbol("");function lo(e,t){if(1===e.nodeType){let n=e.style,r="";for(let e in t)n.setProperty(`--${e}`,t[e]),r+=`--${e}: ${t[e]};`;n[ls]=r}}let la=/(^|;)\s*display\s*:/,lc=/\s*!important$/;function lu(e,t,n){if(E(n))n.forEach(n=>lu(e,t,n));else if(null==n&&(n=""),t.startsWith("--"))e.setProperty(t,n);else{let r=function(e,t){let n=lp[t];if(n)return n;let r=K(t);if("filter"!==r&&r in e)return lp[t]=r;r=G(r);for(let n=0;n<ld.length;n++){let i=ld[n]+r;if(i in e)return lp[t]=i}return t}(e,t);lc.test(n)?e.setProperty(J(r),n.replace(lc,""),"important"):e[r]=n}}let ld=["Webkit","Moz","ms"],lp={},lh="http://www.w3.org/1999/xlink";function lf(e,t,n,r,i,l=ef(t)){if(r&&t.startsWith("xlink:"))null==n?e.removeAttributeNS(lh,t.slice(6,t.length)):e.setAttributeNS(lh,t,n);else null==n||l&&!(n||""===n)?e.removeAttribute(t):e.setAttribute(t,l?"":L(n)?String(n):n)}function lm(e,t,n,r,i){if("innerHTML"===t||"textContent"===t){null!=n&&(e[t]="innerHTML"===t?iK(n):n);return}let l=e.tagName;if("value"===t&&"PROGRESS"!==l&&!l.includes("-")){let r="OPTION"===l?e.getAttribute("value")||"":e.value,i=null==n?"checkbox"===e.type?"on":"":String(n);r===i&&"_value"in e||(e.value=i),null==n&&e.removeAttribute(t),e._value=n;return}let s=!1;if(""===n||null==n){let r=typeof e[t];if("boolean"===r){var o;n=!!(o=n)||""===o}else null==n&&"string"===r?(n="",s=!0):"number"===r&&(n=0,s=!0)}try{e[t]=n}catch(e){}s&&e.removeAttribute(i||t)}function lg(e,t,n,r){e.addEventListener(t,n,r)}let lv=Symbol("_vei"),ly=/(?:Once|Passive|Capture)$/,lb=0,l_=Promise.resolve(),lS=e=>111===e.charCodeAt(0)&&110===e.charCodeAt(1)&&e.charCodeAt(2)>96&&123>e.charCodeAt(2),lx={};function lC(e,t,n){let r=nT(e,t);B(r)&&T(r,t);class i extends lT{constructor(e){super(r,e,n)}}return i.def=r,i}let lk="undefined"!=typeof HTMLElement?HTMLElement:class{};class lT extends lk{constructor(e,t={},n=l1){super(),this._def=e,this._props=t,this._createApp=n,this._isVueCE=!0,this._instance=null,this._app=null,this._nonce=this._def.nonce,this._connected=!1,this._resolved=!1,this._numberProps=null,this._styleChildren=new WeakSet,this._ob=null,this.shadowRoot&&n!==l1?this._root=this.shadowRoot:!1!==e.shadowRoot?(this.attachShadow({mode:"open"}),this._root=this.shadowRoot):this._root=this}connectedCallback(){if(!this.isConnected)return;this.shadowRoot||this._resolved||this._parseSlots(),this._connected=!0;let e=this;for(;e=e&&(e.parentNode||e.host);)if(e instanceof lT){this._parent=e;break}this._instance||(this._resolved?this._mount(this._def):e&&e._pendingResolve?this._pendingResolve=e._pendingResolve.then(()=>{this._pendingResolve=void 0,this._resolveDef()}):this._resolveDef())}_setParent(e=this._parent){e&&(this._instance.parent=e._instance,this._inheritParentContext(e))}_inheritParentContext(e=this._parent){e&&this._app&&Object.setPrototypeOf(this._app._context.provides,e._instance.provides)}disconnectedCallback(){this._connected=!1,tY(()=>{this._connected||(this._ob&&(this._ob.disconnect(),this._ob=null),this._app&&this._app.unmount(),this._instance&&(this._instance.ce=void 0),this._app=this._instance=null)})}_resolveDef(){if(this._pendingResolve)return;for(let e=0;e<this.attributes.length;e++)this._setAttr(this.attributes[e].name);this._ob=new MutationObserver(e=>{for(let t of e)this._setAttr(t.attributeName)}),this._ob.observe(this,{attributes:!0});let e=(e,t=!1)=>{let n;this._resolved=!0,this._pendingResolve=void 0;let{props:r,styles:i}=e;if(r&&!E(r))for(let e in r){let t=r[e];(t===Number||t&&t.type===Number)&&(e in this._props&&(this._props[e]=et(this._props[e])),(n||(n=Object.create(null)))[K(e)]=!0)}this._numberProps=n,this._resolveProps(e),this.shadowRoot&&this._applyStyles(i),this._mount(e)},t=this._def.__asyncLoader;t?this._pendingResolve=t().then(t=>{t.configureApp=this._def.configureApp,e(this._def=t,!0)}):e(this._def)}_mount(e){this._app=this._createApp(e),this._inheritParentContext(),e.configureApp&&e.configureApp(this._app),this._app._ceVNode=this._createVNode(),this._app.mount(this._root);let t=this._instance&&this._instance.exposed;if(t)for(let e in t)A(this,e)||Object.defineProperty(this,e,{get:()=>tI(t[e])})}_resolveProps(e){let{props:t}=e,n=E(t)?t:Object.keys(t||{});for(let e of Object.keys(this))"_"!==e[0]&&n.includes(e)&&this._setProp(e,this[e]);for(let e of n.map(K))Object.defineProperty(this,e,{get(){return this._getProp(e)},set(t){this._setProp(e,t,!0,!0)}})}_setAttr(e){if(e.startsWith("data-v-"))return;let t=this.hasAttribute(e),n=t?this.getAttribute(e):lx,r=K(e);t&&this._numberProps&&this._numberProps[r]&&(n=et(n)),this._setProp(r,n,!1,!0)}_getProp(e){return this._props[e]}_setProp(e,t,n=!0,r=!1){if(t!==this._props[e]&&(t===lx?delete this._props[e]:(this._props[e]=t,"key"===e&&this._app&&(this._app._ceVNode.key=t)),r&&this._instance&&this._update(),n)){let n=this._ob;n&&n.disconnect(),!0===t?this.setAttribute(J(e),""):"string"==typeof t||"number"==typeof t?this.setAttribute(J(e),t+""):t||this.removeAttribute(J(e)),n&&n.observe(this,{attributes:!0})}}_update(){let e=this._createVNode();this._app&&(e.appContext=this._app._context),l0(e,this._root)}_createVNode(){let e={};this.shadowRoot||(e.onVnodeMounted=e.onVnodeUpdated=this._renderSlots.bind(this));let t=iv(this._def,T(e,this._props));return this._instance||(t.ce=e=>{this._instance=e,e.ce=this,e.isCE=!0;let t=(e,t)=>{this.dispatchEvent(new CustomEvent(e,B(t[0])?T({detail:t},t[0]):{detail:t}))};e.emit=(e,...n)=>{t(e,n),J(e)!==e&&t(J(e),n)},this._setParent()}),t}_applyStyles(e,t){if(!e)return;if(t){if(t===this._def||this._styleChildren.has(t))return;this._styleChildren.add(t)}let n=this._nonce;for(let t=e.length-1;t>=0;t--){let r=document.createElement("style");n&&r.setAttribute("nonce",n),r.textContent=e[t],this.shadowRoot.prepend(r)}}_parseSlots(){let e,t=this._slots={};for(;e=this.firstChild;){let n=1===e.nodeType&&e.getAttribute("slot")||"default";(t[n]||(t[n]=[])).push(e),this.removeChild(e)}}_renderSlots(){let e=(this._teleportTarget||this).querySelectorAll("slot"),t=this._instance.type.__scopeId;for(let n=0;n<e.length;n++){let r=e[n],i=r.getAttribute("name")||"default",l=this._slots[i],s=r.parentNode;if(l)for(let e of l){if(t&&1===e.nodeType){let n,r=t+"-s",i=document.createTreeWalker(e,1);for(e.setAttribute(r,"");n=i.nextNode();)n.setAttribute(r,"")}s.insertBefore(e,r)}else for(;r.firstChild;)s.insertBefore(r.firstChild,r);s.removeChild(r)}}_injectChildStyle(e){this._applyStyles(e.styles,e)}_removeChildStyle(e){}}function lN(e){let t=iE(),n=t&&t.ce;return n||null}let lw=new WeakMap,lA=new WeakMap,lE=Symbol("_moveCb"),lI=Symbol("_enterCb"),lR=(n={name:"TransitionGroup",props:T({},iY,{tag:String,moveClass:String}),setup(e,{slots:t}){let n,r,i=iE(),l=nh();return nZ(()=>{if(!n.length)return;let t=e.moveClass||`${e.name||"v"}-move`;if(!function(e,t,n){let r=e.cloneNode(),i=e[iQ];i&&i.forEach(e=>{e.split(/\s+/).forEach(e=>e&&r.classList.remove(e))}),n.split(/\s+/).forEach(e=>e&&r.classList.add(e)),r.style.display="none";let l=1===t.nodeType?t:t.parentNode;l.appendChild(r);let{hasTransform:s}=i7(r);return l.removeChild(r),s}(n[0].el,i.vnode.el,t)){n=[];return}n.forEach(lO),n.forEach(lP);let r=n.filter(lM);ln(),r.forEach(e=>{let n=e.el,r=n.style;i6(n,t),r.transform=r.webkitTransform=r.transitionDuration="";let i=n[lE]=e=>{(!e||e.target===n)&&(!e||/transform$/.test(e.propertyName))&&(n.removeEventListener("transitionend",i),n[lE]=null,i4(n,t))};n.addEventListener("transitionend",i)}),n=[]}),()=>{let s=tS(e),o=i3(s),a=s.tag||r9;if(n=[],r)for(let e=0;e<r.length;e++){let t=r[e];t.el&&t.el instanceof Element&&(n.push(t),nC(t,n_(t,o,l,i)),lw.set(t,t.el.getBoundingClientRect()))}r=t.default?nk(t.default()):[];for(let e=0;e<r.length;e++){let t=r[e];null!=t.key&&nC(t,n_(t,o,l,i))}return iv(a,null,r)}}},delete n.props.mode,n);function lO(e){let t=e.el;t[lE]&&t[lE](),t[lI]&&t[lI]()}function lP(e){lA.set(e,e.el.getBoundingClientRect())}function lM(e){let t=lw.get(e),n=lA.get(e),r=t.left-n.left,i=t.top-n.top;if(r||i){let t=e.el.style;return t.transform=t.webkitTransform=`translate(${r}px,${i}px)`,t.transitionDuration="0s",e}}let lL=e=>{let t=e.props["onUpdate:modelValue"]||!1;return E(t)?e=>Z(t,e):t};function l$(e){e.target.composing=!0}function lD(e){let t=e.target;t.composing&&(t.composing=!1,t.dispatchEvent(new Event("input")))}let lF=Symbol("_assign"),lV={created(e,{modifiers:{lazy:t,trim:n,number:r}},i){e[lF]=lL(i);let l=r||i.props&&"number"===i.props.type;lg(e,t?"change":"input",t=>{if(t.target.composing)return;let r=e.value;n&&(r=r.trim()),l&&(r=ee(r)),e[lF](r)}),n&&lg(e,"change",()=>{e.value=e.value.trim()}),t||(lg(e,"compositionstart",l$),lg(e,"compositionend",lD),lg(e,"change",lD))},mounted(e,{value:t}){e.value=null==t?"":t},beforeUpdate(e,{value:t,oldValue:n,modifiers:{lazy:r,trim:i,number:l}},s){if(e[lF]=lL(s),e.composing)return;let o=(l||"number"===e.type)&&!/^0\d/.test(e.value)?ee(e.value):e.value,a=null==t?"":t;if(o!==a){if(document.activeElement===e&&"range"!==e.type&&(r&&t===n||i&&e.value.trim()===a))return;e.value=a}}},lB={deep:!0,created(e,t,n){e[lF]=lL(n),lg(e,"change",()=>{let t=e._modelValue,n=lW(e),r=e.checked,i=e[lF];if(E(t)){let e=eg(t,n),l=-1!==e;if(r&&!l)i(t.concat(n));else if(!r&&l){let n=[...t];n.splice(e,1),i(n)}}else if(R(t)){let e=new Set(t);r?e.add(n):e.delete(n),i(e)}else i(lK(e,r))})},mounted:lU,beforeUpdate(e,t,n){e[lF]=lL(n),lU(e,t,n)}};function lU(e,{value:t,oldValue:n},r){let i;if(e._modelValue=t,E(t))i=eg(t,r.props.value)>-1;else if(R(t))i=t.has(r.props.value);else{if(t===n)return;i=em(t,lK(e,!0))}e.checked!==i&&(e.checked=i)}let lj={created(e,{value:t},n){e.checked=em(t,n.props.value),e[lF]=lL(n),lg(e,"change",()=>{e[lF](lW(e))})},beforeUpdate(e,{value:t,oldValue:n},r){e[lF]=lL(r),t!==n&&(e.checked=em(t,r.props.value))}},lH={deep:!0,created(e,{value:t,modifiers:{number:n}},r){let i=R(t);lg(e,"change",()=>{let t=Array.prototype.filter.call(e.options,e=>e.selected).map(e=>n?ee(lW(e)):lW(e));e[lF](e.multiple?i?new Set(t):t:t[0]),e._assigning=!0,tY(()=>{e._assigning=!1})}),e[lF]=lL(r)},mounted(e,{value:t}){lq(e,t)},beforeUpdate(e,t,n){e[lF]=lL(n)},updated(e,{value:t}){e._assigning||lq(e,t)}};function lq(e,t){let n=e.multiple,r=E(t);if(!n||r||R(t)){for(let i=0,l=e.options.length;i<l;i++){let l=e.options[i],s=lW(l);if(n)if(r){let e=typeof s;"string"===e||"number"===e?l.selected=t.some(e=>String(e)===String(s)):l.selected=eg(t,s)>-1}else l.selected=t.has(s);else if(em(lW(l),t)){e.selectedIndex!==i&&(e.selectedIndex=i);return}}n||-1===e.selectedIndex||(e.selectedIndex=-1)}}function lW(e){return"_value"in e?e._value:e.value}function lK(e,t){let n=t?"_trueValue":"_falseValue";return n in e?e[n]:t}function lz(e,t,n,r,i){let l=function(e,t){switch(e){case"SELECT":return lH;case"TEXTAREA":return lV;default:switch(t){case"checkbox":return lB;case"radio":return lj;default:return lV}}}(e.tagName,n.props&&n.props.type)[i];l&&l(e,t,n,r)}let lJ=["ctrl","shift","alt","meta"],lG={stop:e=>e.stopPropagation(),prevent:e=>e.preventDefault(),self:e=>e.target!==e.currentTarget,ctrl:e=>!e.ctrlKey,shift:e=>!e.shiftKey,alt:e=>!e.altKey,meta:e=>!e.metaKey,left:e=>"button"in e&&0!==e.button,middle:e=>"button"in e&&1!==e.button,right:e=>"button"in e&&2!==e.button,exact:(e,t)=>lJ.some(n=>e[`${n}Key`]&&!t.includes(n))},lX={esc:"escape",space:" ",up:"arrow-up",left:"arrow-left",right:"arrow-right",down:"arrow-down",delete:"backspace"},lQ=T({patchProp:(e,t,n,r,i,l)=>{let s="svg"===i;if("class"===t){var o=r;let t=e[iQ];t&&(o=(o?[o,...t]:[...t]).join(" ")),null==o?e.removeAttribute("class"):s?e.setAttribute("class",o):e.className=o}else"style"===t?function(e,t,n){let r=e.style,i=M(n),l=!1;if(n&&!i){if(t)if(M(t))for(let e of t.split(";")){let t=e.slice(0,e.indexOf(":")).trim();null==n[t]&&lu(r,t,"")}else for(let e in t)null==n[e]&&lu(r,e,"");for(let e in n)"display"===e&&(l=!0),lu(r,e,n[e])}else if(i){if(t!==n){let e=r[ls];e&&(n+=";"+e),r.cssText=n,l=la.test(n)}}else t&&e.removeAttribute("style");lr in e&&(e[lr]=l?r.display:"",e[li]&&(r.display="none"))}(e,n,r):C(t)?k(t)||function(e,t,n,r,i=null){let l=e[lv]||(e[lv]={}),s=l[t];if(r&&s)s.value=r;else{let[n,o]=function(e){let t;if(ly.test(e)){let n;for(t={};n=e.match(ly);)e=e.slice(0,e.length-n[0].length),t[n[0].toLowerCase()]=!0}return[":"===e[2]?e.slice(3):J(e.slice(2)),t]}(t);if(r)lg(e,n,l[t]=function(e,t){let n=e=>{if(e._vts){if(e._vts<=n.attached)return}else e._vts=Date.now();tq(function(e,t){if(!E(t))return t;{let n=e.stopImmediatePropagation;return e.stopImmediatePropagation=()=>{n.call(e),e._stopped=!0},t.map(e=>t=>!t._stopped&&e&&e(t))}}(e,n.value),t,5,[e])};return n.value=e,n.attached=lb||(l_.then(()=>lb=0),lb=Date.now()),n}(r,i),o);else s&&(e.removeEventListener(n,s,o),l[t]=void 0)}}(e,t,0,r,l):("."===t[0]?(t=t.slice(1),0):"^"===t[0]?(t=t.slice(1),1):!function(e,t,n,r){if(r)return!!("innerHTML"===t||"textContent"===t||t in e&&lS(t)&&P(n));if("spellcheck"===t||"draggable"===t||"translate"===t||"autocorrect"===t||"form"===t||"list"===t&&"INPUT"===e.tagName||"type"===t&&"TEXTAREA"===e.tagName)return!1;if("width"===t||"height"===t){let t=e.tagName;if("IMG"===t||"VIDEO"===t||"CANVAS"===t||"SOURCE"===t)return!1}return!(lS(t)&&M(n))&&t in e}(e,t,r,s))?e._isVueCE&&(/[A-Z]/.test(t)||!M(r))?lm(e,K(t),r,l,t):("true-value"===t?e._trueValue=r:"false-value"===t&&(e._falseValue=r),lf(e,t,r,s)):(lm(e,t,r),e.tagName.includes("-")||"value"!==t&&"checked"!==t&&"selected"!==t||lf(e,t,r,s,l,"value"!==t))}},{insert:(e,t,n)=>{t.insertBefore(e,n||null)},remove:e=>{let t=e.parentNode;t&&t.removeChild(e)},createElement:(e,t,n,r)=>{let i="svg"===t?iz.createElementNS("http://www.w3.org/2000/svg",e):"mathml"===t?iz.createElementNS("http://www.w3.org/1998/Math/MathML",e):n?iz.createElement(e,{is:n}):iz.createElement(e);return"select"===e&&r&&null!=r.multiple&&i.setAttribute("multiple",r.multiple),i},createText:e=>iz.createTextNode(e),createComment:e=>iz.createComment(e),setText:(e,t)=>{e.nodeValue=t},setElementText:(e,t)=>{e.textContent=t},parentNode:e=>e.parentNode,nextSibling:e=>e.nextSibling,querySelector:e=>iz.querySelector(e),setScopeId(e,t){e.setAttribute(t,"")},insertStaticContent(e,t,n,r,i,l){let s=n?n.previousSibling:t.lastChild;if(i&&(i===l||i.nextSibling))for(;t.insertBefore(i.cloneNode(!0),n),i!==l&&(i=i.nextSibling););else{iJ.innerHTML=iK("svg"===r?`<svg>${e}</svg>`:"mathml"===r?`<math>${e}</math>`:e);let i=iJ.content;if("svg"===r||"mathml"===r){let e=i.firstChild;for(;e.firstChild;)i.appendChild(e.firstChild);i.removeChild(e)}t.insertBefore(i,n)}return[s?s.nextSibling:t.firstChild,n?n.previousSibling:t.lastChild]}}),lZ=!1;function lY(){return h=lZ?h:rL(lQ),lZ=!0,h}let l0=(...e)=>{(h||(h=r$(lQ))).render(...e)},l1=(...e)=>{let t=(h||(h=r$(lQ))).createApp(...e),{mount:n}=t;return t.mount=e=>{let r=l6(e);if(!r)return;let i=t._component;P(i)||i.render||i.template||(i.template=r.innerHTML),1===r.nodeType&&(r.textContent="");let l=n(r,!1,l3(r));return r instanceof Element&&(r.removeAttribute("v-cloak"),r.setAttribute("data-v-app","")),l},t},l2=(...e)=>{let t=lY().createApp(...e),{mount:n}=t;return t.mount=e=>{let t=l6(e);if(t)return n(t,!0,l3(t))},t};function l3(e){return e instanceof SVGElement?"svg":"function"==typeof MathMLElement&&e instanceof MathMLElement?"mathml":void 0}function l6(e){return M(e)?document.querySelector(e):e}let l4=Symbol(""),l8=Symbol(""),l5=Symbol(""),l9=Symbol(""),l7=Symbol(""),se=Symbol(""),st=Symbol(""),sn=Symbol(""),sr=Symbol(""),si=Symbol(""),sl=Symbol(""),ss=Symbol(""),so=Symbol(""),sa=Symbol(""),sc=Symbol(""),su=Symbol(""),sd=Symbol(""),sp=Symbol(""),sh=Symbol(""),sf=Symbol(""),sm=Symbol(""),sg=Symbol(""),sv=Symbol(""),sy=Symbol(""),sb=Symbol(""),s_=Symbol(""),sS=Symbol(""),sx=Symbol(""),sC=Symbol(""),sk=Symbol(""),sT=Symbol(""),sN=Symbol(""),sw=Symbol(""),sA=Symbol(""),sE=Symbol(""),sI=Symbol(""),sR=Symbol(""),sO=Symbol(""),sP=Symbol(""),sM={[l4]:"Fragment",[l8]:"Teleport",[l5]:"Suspense",[l9]:"KeepAlive",[l7]:"BaseTransition",[se]:"openBlock",[st]:"createBlock",[sn]:"createElementBlock",[sr]:"createVNode",[si]:"createElementVNode",[sl]:"createCommentVNode",[ss]:"createTextVNode",[so]:"createStaticVNode",[sa]:"resolveComponent",[sc]:"resolveDynamicComponent",[su]:"resolveDirective",[sd]:"resolveFilter",[sp]:"withDirectives",[sh]:"renderList",[sf]:"renderSlot",[sm]:"createSlots",[sg]:"toDisplayString",[sv]:"mergeProps",[sy]:"normalizeClass",[sb]:"normalizeStyle",[s_]:"normalizeProps",[sS]:"guardReactiveProps",[sx]:"toHandlers",[sC]:"camelize",[sk]:"capitalize",[sT]:"toHandlerKey",[sN]:"setBlockTracking",[sw]:"pushScopeId",[sA]:"popScopeId",[sE]:"withCtx",[sI]:"unref",[sR]:"isRef",[sO]:"withMemo",[sP]:"isMemoSame"},sL={start:{line:1,column:1,offset:0},end:{line:1,column:1,offset:0},source:""};function s$(e,t,n,r,i,l,s,o=!1,a=!1,c=!1,u=sL){var d,p,h,f;return e&&(o?(e.helper(se),e.helper((d=e.inSSR,p=c,d||p?st:sn))):e.helper((h=e.inSSR,f=c,h||f?sr:si)),s&&e.helper(sp)),{type:13,tag:t,props:n,children:r,patchFlag:i,dynamicProps:l,directives:s,isBlock:o,disableTracking:a,isComponent:c,loc:u}}function sD(e,t=sL){return{type:17,loc:t,elements:e}}function sF(e,t=sL){return{type:15,loc:t,properties:e}}function sV(e,t){return{type:16,loc:sL,key:M(e)?sB(e,!0):e,value:t}}function sB(e,t=!1,n=sL,r=0){return{type:4,loc:n,content:e,isStatic:t,constType:t?3:r}}function sU(e,t=sL){return{type:8,loc:t,children:e}}function sj(e,t=[],n=sL){return{type:14,loc:n,callee:e,arguments:t}}function sH(e,t,n=!1,r=!1,i=sL){return{type:18,params:e,returns:t,newline:n,isSlot:r,loc:i}}function sq(e,t,n,r=!0){return{type:19,test:e,consequent:t,alternate:n,newline:r,loc:sL}}function sW(e,{helper:t,removeHelper:n,inSSR:r}){if(!e.isBlock){var i,l;e.isBlock=!0,n((i=e.isComponent,r||i?sr:si)),t(se),t((l=e.isComponent,r||l?st:sn))}}let sK=new Uint8Array([123,123]),sz=new Uint8Array([125,125]);function sJ(e){return e>=97&&e<=122||e>=65&&e<=90}function sG(e){return 32===e||10===e||9===e||12===e||13===e}function sX(e){return 47===e||62===e||sG(e)}function sQ(e){let t=new Uint8Array(e.length);for(let n=0;n<e.length;n++)t[n]=e.charCodeAt(n);return t}let sZ={Cdata:new Uint8Array([67,68,65,84,65,91]),CdataEnd:new Uint8Array([93,93,62]),CommentEnd:new Uint8Array([45,45,62]),ScriptEnd:new Uint8Array([60,47,115,99,114,105,112,116]),StyleEnd:new Uint8Array([60,47,115,116,121,108,101]),TitleEnd:new Uint8Array([60,47,116,105,116,108,101]),TextareaEnd:new Uint8Array([60,47,116,101,120,116,97,114,101,97])};function sY(e){throw e}function s0(e){}function s1(e,t,n,r){let i=SyntaxError(String(`https://vuejs.org/error-reference/#compiler-${e}`));return i.code=e,i.loc=t,i}let s2=e=>4===e.type&&e.isStatic;function s3(e){switch(e){case"Teleport":case"teleport":return l8;case"Suspense":case"suspense":return l5;case"KeepAlive":case"keep-alive":return l9;case"BaseTransition":case"base-transition":return l7}}let s6=/^\d|[^\$\w\xA0-\uFFFF]/,s4=e=>!s6.test(e),s8=/[A-Za-z_$\xA0-\uFFFF]/,s5=/[\.\?\w$\xA0-\uFFFF]/,s9=/\s+[.[]\s*|\s*[.[]\s+/g,s7=e=>4===e.type?e.content:e.loc.source,oe=e=>{let t=s7(e).trim().replace(s9,e=>e.trim()),n=0,r=[],i=0,l=0,s=null;for(let e=0;e<t.length;e++){let o=t.charAt(e);switch(n){case 0:if("["===o)r.push(n),n=1,i++;else if("("===o)r.push(n),n=2,l++;else if(!(0===e?s8:s5).test(o))return!1;break;case 1:"'"===o||'"'===o||"`"===o?(r.push(n),n=3,s=o):"["===o?i++:"]"!==o||--i||(n=r.pop());break;case 2:if("'"===o||'"'===o||"`"===o)r.push(n),n=3,s=o;else if("("===o)l++;else if(")"===o){if(e===t.length-1)return!1;--l||(n=r.pop())}break;case 3:o===s&&(n=r.pop(),s=null)}}return!i&&!l},ot=/^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;function on(e,t,n=!1){for(let r=0;r<e.props.length;r++){let i=e.props[r];if(7===i.type&&(n||i.exp)&&(M(t)?i.name===t:t.test(i.name)))return i}}function or(e,t,n=!1,r=!1){for(let i=0;i<e.props.length;i++){let l=e.props[i];if(6===l.type){if(n)continue;if(l.name===t&&(l.value||r))return l}else if("bind"===l.name&&(l.exp||r)&&oi(l.arg,t))return l}}function oi(e,t){return!!(e&&s2(e)&&e.content===t)}function ol(e){return 5===e.type||2===e.type}function os(e){return 7===e.type&&"slot"===e.name}function oo(e){return 1===e.type&&3===e.tagType}function oa(e){return 1===e.type&&2===e.tagType}let oc=new Set([s_,sS]);function ou(e,t,n){let r,i,l=13===e.type?e.props:e.arguments[2],s=[];if(l&&!M(l)&&14===l.type){let e=function e(t,n=[]){if(t&&!M(t)&&14===t.type){let r=t.callee;if(!M(r)&&oc.has(r))return e(t.arguments[0],n.concat(t))}return[t,n]}(l);l=e[0],i=(s=e[1])[s.length-1]}if(null==l||M(l))r=sF([t]);else if(14===l.type){let e=l.arguments[0];M(e)||15!==e.type?l.callee===sx?r=sj(n.helper(sv),[sF([t]),l]):l.arguments.unshift(sF([t])):od(t,e)||e.properties.unshift(t),r||(r=l)}else 15===l.type?(od(t,l)||l.properties.unshift(t),r=l):(r=sj(n.helper(sv),[sF([t]),l]),i&&i.callee===sS&&(i=s[s.length-2]));13===e.type?i?i.arguments[0]=r:e.props=r:i?i.arguments[0]=r:e.arguments[2]=r}function od(e,t){let n=!1;if(4===e.key.type){let r=e.key.content;n=t.properties.some(e=>4===e.key.type&&e.key.content===r)}return n}function op(e,t){return`_${t}_${e.replace(/[^\w]/g,(t,n)=>"-"===t?"_":e.charCodeAt(n).toString())}`}let oh=/([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/,of={parseMode:"base",ns:0,delimiters:["{{","}}"],getNamespace:()=>0,isVoidTag:x,isPreTag:x,isIgnoreNewlineTag:x,isCustomElement:x,onError:sY,onWarn:s0,comments:!1,prefixIdentifiers:!1},om=of,og=null,ov="",oy=null,ob=null,o_="",oS=-1,ox=-1,oC=0,ok=!1,oT=null,oN=[],ow=new class{constructor(e,t){this.stack=e,this.cbs=t,this.state=1,this.buffer="",this.sectionStart=0,this.index=0,this.entityStart=0,this.baseState=1,this.inRCDATA=!1,this.inXML=!1,this.inVPre=!1,this.newlines=[],this.mode=0,this.delimiterOpen=sK,this.delimiterClose=sz,this.delimiterIndex=-1,this.currentSequence=void 0,this.sequenceIndex=0}get inSFCRoot(){return 2===this.mode&&0===this.stack.length}reset(){this.state=1,this.mode=0,this.buffer="",this.sectionStart=0,this.index=0,this.baseState=1,this.inRCDATA=!1,this.currentSequence=void 0,this.newlines.length=0,this.delimiterOpen=sK,this.delimiterClose=sz}getPos(e){let t=1,n=e+1;for(let r=this.newlines.length-1;r>=0;r--){let i=this.newlines[r];if(e>i){t=r+2,n=e-i;break}}return{column:n,line:t,offset:e}}peek(){return this.buffer.charCodeAt(this.index+1)}stateText(e){60===e?(this.index>this.sectionStart&&this.cbs.ontext(this.sectionStart,this.index),this.state=5,this.sectionStart=this.index):this.inVPre||e!==this.delimiterOpen[0]||(this.state=2,this.delimiterIndex=0,this.stateInterpolationOpen(e))}stateInterpolationOpen(e){if(e===this.delimiterOpen[this.delimiterIndex])if(this.delimiterIndex===this.delimiterOpen.length-1){let e=this.index+1-this.delimiterOpen.length;e>this.sectionStart&&this.cbs.ontext(this.sectionStart,e),this.state=3,this.sectionStart=e}else this.delimiterIndex++;else this.inRCDATA?(this.state=32,this.stateInRCDATA(e)):(this.state=1,this.stateText(e))}stateInterpolation(e){e===this.delimiterClose[0]&&(this.state=4,this.delimiterIndex=0,this.stateInterpolationClose(e))}stateInterpolationClose(e){e===this.delimiterClose[this.delimiterIndex]?this.delimiterIndex===this.delimiterClose.length-1?(this.cbs.oninterpolation(this.sectionStart,this.index+1),this.inRCDATA?this.state=32:this.state=1,this.sectionStart=this.index+1):this.delimiterIndex++:(this.state=3,this.stateInterpolation(e))}stateSpecialStartSequence(e){let t=this.sequenceIndex===this.currentSequence.length;if(t?sX(e):(32|e)===this.currentSequence[this.sequenceIndex]){if(!t)return void this.sequenceIndex++}else this.inRCDATA=!1;this.sequenceIndex=0,this.state=6,this.stateInTagName(e)}stateInRCDATA(e){if(this.sequenceIndex===this.currentSequence.length){if(62===e||sG(e)){let t=this.index-this.currentSequence.length;if(this.sectionStart<t){let e=this.index;this.index=t,this.cbs.ontext(this.sectionStart,t),this.index=e}this.sectionStart=t+2,this.stateInClosingTagName(e),this.inRCDATA=!1;return}this.sequenceIndex=0}(32|e)===this.currentSequence[this.sequenceIndex]?this.sequenceIndex+=1:0===this.sequenceIndex?this.currentSequence!==sZ.TitleEnd&&(this.currentSequence!==sZ.TextareaEnd||this.inSFCRoot)?this.fastForwardTo(60)&&(this.sequenceIndex=1):this.inVPre||e!==this.delimiterOpen[0]||(this.state=2,this.delimiterIndex=0,this.stateInterpolationOpen(e)):this.sequenceIndex=Number(60===e)}stateCDATASequence(e){e===sZ.Cdata[this.sequenceIndex]?++this.sequenceIndex===sZ.Cdata.length&&(this.state=28,this.currentSequence=sZ.CdataEnd,this.sequenceIndex=0,this.sectionStart=this.index+1):(this.sequenceIndex=0,this.state=23,this.stateInDeclaration(e))}fastForwardTo(e){for(;++this.index<this.buffer.length;){let t=this.buffer.charCodeAt(this.index);if(10===t&&this.newlines.push(this.index),t===e)return!0}return this.index=this.buffer.length-1,!1}stateInCommentLike(e){e===this.currentSequence[this.sequenceIndex]?++this.sequenceIndex===this.currentSequence.length&&(this.currentSequence===sZ.CdataEnd?this.cbs.oncdata(this.sectionStart,this.index-2):this.cbs.oncomment(this.sectionStart,this.index-2),this.sequenceIndex=0,this.sectionStart=this.index+1,this.state=1):0===this.sequenceIndex?this.fastForwardTo(this.currentSequence[0])&&(this.sequenceIndex=1):e!==this.currentSequence[this.sequenceIndex-1]&&(this.sequenceIndex=0)}startSpecial(e,t){this.enterRCDATA(e,t),this.state=31}enterRCDATA(e,t){this.inRCDATA=!0,this.currentSequence=e,this.sequenceIndex=t}stateBeforeTagName(e){33===e?(this.state=22,this.sectionStart=this.index+1):63===e?(this.state=24,this.sectionStart=this.index+1):sJ(e)?(this.sectionStart=this.index,0===this.mode?this.state=6:this.inSFCRoot?this.state=34:this.inXML?this.state=6:116===e?this.state=30:this.state=115===e?29:6):47===e?this.state=8:(this.state=1,this.stateText(e))}stateInTagName(e){sX(e)&&this.handleTagName(e)}stateInSFCRootTagName(e){if(sX(e)){let t=this.buffer.slice(this.sectionStart,this.index);"template"!==t&&this.enterRCDATA(sQ("</"+t),0),this.handleTagName(e)}}handleTagName(e){this.cbs.onopentagname(this.sectionStart,this.index),this.sectionStart=-1,this.state=11,this.stateBeforeAttrName(e)}stateBeforeClosingTagName(e){sG(e)||(62===e?(this.state=1,this.sectionStart=this.index+1):(this.state=sJ(e)?9:27,this.sectionStart=this.index))}stateInClosingTagName(e){(62===e||sG(e))&&(this.cbs.onclosetag(this.sectionStart,this.index),this.sectionStart=-1,this.state=10,this.stateAfterClosingTagName(e))}stateAfterClosingTagName(e){62===e&&(this.state=1,this.sectionStart=this.index+1)}stateBeforeAttrName(e){62===e?(this.cbs.onopentagend(this.index),this.inRCDATA?this.state=32:this.state=1,this.sectionStart=this.index+1):47===e?this.state=7:60===e&&47===this.peek()?(this.cbs.onopentagend(this.index),this.state=5,this.sectionStart=this.index):sG(e)||this.handleAttrStart(e)}handleAttrStart(e){118===e&&45===this.peek()?(this.state=13,this.sectionStart=this.index):46===e||58===e||64===e||35===e?(this.cbs.ondirname(this.index,this.index+1),this.state=14,this.sectionStart=this.index+1):(this.state=12,this.sectionStart=this.index)}stateInSelfClosingTag(e){62===e?(this.cbs.onselfclosingtag(this.index),this.state=1,this.sectionStart=this.index+1,this.inRCDATA=!1):sG(e)||(this.state=11,this.stateBeforeAttrName(e))}stateInAttrName(e){(61===e||sX(e))&&(this.cbs.onattribname(this.sectionStart,this.index),this.handleAttrNameEnd(e))}stateInDirName(e){61===e||sX(e)?(this.cbs.ondirname(this.sectionStart,this.index),this.handleAttrNameEnd(e)):58===e?(this.cbs.ondirname(this.sectionStart,this.index),this.state=14,this.sectionStart=this.index+1):46===e&&(this.cbs.ondirname(this.sectionStart,this.index),this.state=16,this.sectionStart=this.index+1)}stateInDirArg(e){61===e||sX(e)?(this.cbs.ondirarg(this.sectionStart,this.index),this.handleAttrNameEnd(e)):91===e?this.state=15:46===e&&(this.cbs.ondirarg(this.sectionStart,this.index),this.state=16,this.sectionStart=this.index+1)}stateInDynamicDirArg(e){93===e?this.state=14:(61===e||sX(e))&&(this.cbs.ondirarg(this.sectionStart,this.index+1),this.handleAttrNameEnd(e))}stateInDirModifier(e){61===e||sX(e)?(this.cbs.ondirmodifier(this.sectionStart,this.index),this.handleAttrNameEnd(e)):46===e&&(this.cbs.ondirmodifier(this.sectionStart,this.index),this.sectionStart=this.index+1)}handleAttrNameEnd(e){this.sectionStart=this.index,this.state=17,this.cbs.onattribnameend(this.index),this.stateAfterAttrName(e)}stateAfterAttrName(e){61===e?this.state=18:47===e||62===e?(this.cbs.onattribend(0,this.sectionStart),this.sectionStart=-1,this.state=11,this.stateBeforeAttrName(e)):sG(e)||(this.cbs.onattribend(0,this.sectionStart),this.handleAttrStart(e))}stateBeforeAttrValue(e){34===e?(this.state=19,this.sectionStart=this.index+1):39===e?(this.state=20,this.sectionStart=this.index+1):sG(e)||(this.sectionStart=this.index,this.state=21,this.stateInAttrValueNoQuotes(e))}handleInAttrValue(e,t){(e===t||this.fastForwardTo(t))&&(this.cbs.onattribdata(this.sectionStart,this.index),this.sectionStart=-1,this.cbs.onattribend(34===t?3:2,this.index+1),this.state=11)}stateInAttrValueDoubleQuotes(e){this.handleInAttrValue(e,34)}stateInAttrValueSingleQuotes(e){this.handleInAttrValue(e,39)}stateInAttrValueNoQuotes(e){sG(e)||62===e?(this.cbs.onattribdata(this.sectionStart,this.index),this.sectionStart=-1,this.cbs.onattribend(1,this.index),this.state=11,this.stateBeforeAttrName(e)):(39===e||60===e||61===e||96===e)&&this.cbs.onerr(18,this.index)}stateBeforeDeclaration(e){91===e?(this.state=26,this.sequenceIndex=0):this.state=45===e?25:23}stateInDeclaration(e){(62===e||this.fastForwardTo(62))&&(this.state=1,this.sectionStart=this.index+1)}stateInProcessingInstruction(e){(62===e||this.fastForwardTo(62))&&(this.cbs.onprocessinginstruction(this.sectionStart,this.index),this.state=1,this.sectionStart=this.index+1)}stateBeforeComment(e){45===e?(this.state=28,this.currentSequence=sZ.CommentEnd,this.sequenceIndex=2,this.sectionStart=this.index+1):this.state=23}stateInSpecialComment(e){(62===e||this.fastForwardTo(62))&&(this.cbs.oncomment(this.sectionStart,this.index),this.state=1,this.sectionStart=this.index+1)}stateBeforeSpecialS(e){e===sZ.ScriptEnd[3]?this.startSpecial(sZ.ScriptEnd,4):e===sZ.StyleEnd[3]?this.startSpecial(sZ.StyleEnd,4):(this.state=6,this.stateInTagName(e))}stateBeforeSpecialT(e){e===sZ.TitleEnd[3]?this.startSpecial(sZ.TitleEnd,4):e===sZ.TextareaEnd[3]?this.startSpecial(sZ.TextareaEnd,4):(this.state=6,this.stateInTagName(e))}startEntity(){}stateInEntity(){}parse(e){for(this.buffer=e;this.index<this.buffer.length;){let e=this.buffer.charCodeAt(this.index);switch(10===e&&33!==this.state&&this.newlines.push(this.index),this.state){case 1:this.stateText(e);break;case 2:this.stateInterpolationOpen(e);break;case 3:this.stateInterpolation(e);break;case 4:this.stateInterpolationClose(e);break;case 31:this.stateSpecialStartSequence(e);break;case 32:this.stateInRCDATA(e);break;case 26:this.stateCDATASequence(e);break;case 19:this.stateInAttrValueDoubleQuotes(e);break;case 12:this.stateInAttrName(e);break;case 13:this.stateInDirName(e);break;case 14:this.stateInDirArg(e);break;case 15:this.stateInDynamicDirArg(e);break;case 16:this.stateInDirModifier(e);break;case 28:this.stateInCommentLike(e);break;case 27:this.stateInSpecialComment(e);break;case 11:this.stateBeforeAttrName(e);break;case 6:this.stateInTagName(e);break;case 34:this.stateInSFCRootTagName(e);break;case 9:this.stateInClosingTagName(e);break;case 5:this.stateBeforeTagName(e);break;case 17:this.stateAfterAttrName(e);break;case 20:this.stateInAttrValueSingleQuotes(e);break;case 18:this.stateBeforeAttrValue(e);break;case 8:this.stateBeforeClosingTagName(e);break;case 10:this.stateAfterClosingTagName(e);break;case 29:this.stateBeforeSpecialS(e);break;case 30:this.stateBeforeSpecialT(e);break;case 21:this.stateInAttrValueNoQuotes(e);break;case 7:this.stateInSelfClosingTag(e);break;case 23:this.stateInDeclaration(e);break;case 22:this.stateBeforeDeclaration(e);break;case 25:this.stateBeforeComment(e);break;case 24:this.stateInProcessingInstruction(e);break;case 33:this.stateInEntity()}this.index++}this.cleanup(),this.finish()}cleanup(){this.sectionStart!==this.index&&(1===this.state||32===this.state&&0===this.sequenceIndex?(this.cbs.ontext(this.sectionStart,this.index),this.sectionStart=this.index):(19===this.state||20===this.state||21===this.state)&&(this.cbs.onattribdata(this.sectionStart,this.index),this.sectionStart=this.index))}finish(){this.handleTrailingData(),this.cbs.onend()}handleTrailingData(){let e=this.buffer.length;this.sectionStart>=e||(28===this.state?this.currentSequence===sZ.CdataEnd?this.cbs.oncdata(this.sectionStart,e):this.cbs.oncomment(this.sectionStart,e):6===this.state||11===this.state||18===this.state||17===this.state||12===this.state||13===this.state||14===this.state||15===this.state||16===this.state||20===this.state||19===this.state||21===this.state||9===this.state||this.cbs.ontext(this.sectionStart,e))}emitCodePoint(e,t){}}(oN,{onerr:oH,ontext(e,t){oO(oI(e,t),e,t)},ontextentity(e,t,n){oO(e,t,n)},oninterpolation(e,t){if(ok)return oO(oI(e,t),e,t);let n=e+ow.delimiterOpen.length,r=t-ow.delimiterClose.length;for(;sG(ov.charCodeAt(n));)n++;for(;sG(ov.charCodeAt(r-1));)r--;let i=oI(n,r);i.includes("&")&&(i=om.decodeEntities(i,!1)),oV({type:5,content:oj(i,!1,oB(n,r)),loc:oB(e,t)})},onopentagname(e,t){let n=oI(e,t);oy={type:1,tag:n,ns:om.getNamespace(n,oN[0],om.ns),tagType:0,props:[],children:[],loc:oB(e-1,t),codegenNode:void 0}},onopentagend(e){oR(e)},onclosetag(e,t){let n=oI(e,t);if(!om.isVoidTag(n)){let r=!1;for(let e=0;e<oN.length;e++)if(oN[e].tag.toLowerCase()===n.toLowerCase()){r=!0,e>0&&oN[0].loc.start.offset;for(let n=0;n<=e;n++)oP(oN.shift(),t,n<e);break}r||oM(e,60)}},onselfclosingtag(e){let t=oy.tag;oy.isSelfClosing=!0,oR(e),oN[0]&&oN[0].tag===t&&oP(oN.shift(),e)},onattribname(e,t){ob={type:6,name:oI(e,t),nameLoc:oB(e,t),value:void 0,loc:oB(e)}},ondirname(e,t){let n=oI(e,t),r="."===n||":"===n?"bind":"@"===n?"on":"#"===n?"slot":n.slice(2);if(ok||""===r)ob={type:6,name:n,nameLoc:oB(e,t),value:void 0,loc:oB(e)};else if(ob={type:7,name:r,rawName:n,exp:void 0,arg:void 0,modifiers:"."===n?[sB("prop")]:[],loc:oB(e)},"pre"===r){ok=ow.inVPre=!0,oT=oy;let e=oy.props;for(let t=0;t<e.length;t++)7===e[t].type&&(e[t]=function(e){let t={type:6,name:e.rawName,nameLoc:oB(e.loc.start.offset,e.loc.start.offset+e.rawName.length),value:void 0,loc:e.loc};if(e.exp){let n=e.exp.loc;n.end.offset<e.loc.end.offset&&(n.start.offset--,n.start.column--,n.end.offset++,n.end.column++),t.value={type:2,content:e.exp.content,loc:n}}return t}(e[t]))}},ondirarg(e,t){if(e===t)return;let n=oI(e,t);if(ok)ob.name+=n,oU(ob.nameLoc,t);else{let r="["!==n[0];ob.arg=oj(r?n:n.slice(1,-1),r,oB(e,t),3*!!r)}},ondirmodifier(e,t){let n=oI(e,t);if(ok)ob.name+="."+n,oU(ob.nameLoc,t);else if("slot"===ob.name){let e=ob.arg;e&&(e.content+="."+n,oU(e.loc,t))}else{let r=sB(n,!0,oB(e,t));ob.modifiers.push(r)}},onattribdata(e,t){o_+=oI(e,t),oS<0&&(oS=e),ox=t},onattribentity(e,t,n){o_+=e,oS<0&&(oS=t),ox=n},onattribnameend(e){let t=oI(ob.loc.start.offset,e);7===ob.type&&(ob.rawName=t),oy.props.some(e=>(7===e.type?e.rawName:e.name)===t)},onattribend(e,t){oy&&ob&&(oU(ob.loc,t),0!==e&&(o_.includes("&")&&(o_=om.decodeEntities(o_,!0)),6===ob.type?("class"===ob.name&&(o_=oF(o_).trim()),ob.value={type:2,content:o_,loc:1===e?oB(oS,ox):oB(oS-1,ox+1)},ow.inSFCRoot&&"template"===oy.tag&&"lang"===ob.name&&o_&&"html"!==o_&&ow.enterRCDATA(sQ("</template"),0)):(ob.exp=oj(o_,!1,oB(oS,ox),0,0),"for"===ob.name&&(ob.forParseResult=function(e){let t=e.loc,n=e.content,r=n.match(oh);if(!r)return;let[,i,l]=r,s=(e,n,r=!1)=>{let i=t.start.offset+n,l=i+e.length;return oj(e,!1,oB(i,l),0,+!!r)},o={source:s(l.trim(),n.indexOf(l,i.length)),value:void 0,key:void 0,index:void 0,finalized:!1},a=i.trim().replace(oE,"").trim(),c=i.indexOf(a),u=a.match(oA);if(u){let e;a=a.replace(oA,"").trim();let t=u[1].trim();if(t&&(e=n.indexOf(t,c+a.length),o.key=s(t,e,!0)),u[2]){let r=u[2].trim();r&&(o.index=s(r,n.indexOf(r,o.key?e+t.length:c+a.length),!0))}}return a&&(o.value=s(a,c,!0)),o}(ob.exp)))),(7!==ob.type||"pre"!==ob.name)&&oy.props.push(ob)),o_="",oS=ox=-1},oncomment(e,t){om.comments&&oV({type:3,content:oI(e,t),loc:oB(e-4,t+3)})},onend(){let e=ov.length;for(let t=0;t<oN.length;t++)oP(oN[t],e-1),oN[t].loc.start.offset},oncdata(e,t){0!==oN[0].ns&&oO(oI(e,t),e,t)},onprocessinginstruction(e){(oN[0]?oN[0].ns:om.ns)===0&&oH(21,e-1)}}),oA=/,([^,\}\]]*)(?:,([^,\}\]]*))?$/,oE=/^\(|\)$/g;function oI(e,t){return ov.slice(e,t)}function oR(e){ow.inSFCRoot&&(oy.innerLoc=oB(e+1,e+1)),oV(oy);let{tag:t,ns:n}=oy;0===n&&om.isPreTag(t)&&oC++,om.isVoidTag(t)?oP(oy,e):(oN.unshift(oy),(1===n||2===n)&&(ow.inXML=!0)),oy=null}function oO(e,t,n){{let t=oN[0]&&oN[0].tag;"script"!==t&&"style"!==t&&e.includes("&")&&(e=om.decodeEntities(e,!1))}let r=oN[0]||og,i=r.children[r.children.length-1];i&&2===i.type?(i.content+=e,oU(i.loc,n)):r.children.push({type:2,content:e,loc:oB(t,n)})}function oP(e,t,n=!1){n?oU(e.loc,oM(t,60)):oU(e.loc,function(e,t){let n=e;for(;62!==ov.charCodeAt(n)&&n<ov.length-1;)n++;return n}(t,62)+1),ow.inSFCRoot&&(e.children.length?e.innerLoc.end=T({},e.children[e.children.length-1].loc.end):e.innerLoc.end=T({},e.innerLoc.start),e.innerLoc.source=oI(e.innerLoc.start.offset,e.innerLoc.end.offset));let{tag:r,ns:i,children:l}=e;if(!ok&&("slot"===r?e.tagType=2:!function({tag:e,props:t}){if("template"===e){for(let e=0;e<t.length;e++)if(7===t[e].type&&oL.has(t[e].name))return!0}return!1}(e)?function({tag:e,props:t}){var n;if(om.isCustomElement(e))return!1;if("component"===e||(n=e.charCodeAt(0))>64&&n<91||s3(e)||om.isBuiltInComponent&&om.isBuiltInComponent(e)||om.isNativeTag&&!om.isNativeTag(e))return!0;for(let e=0;e<t.length;e++){let n=t[e];if(6===n.type&&"is"===n.name&&n.value&&n.value.content.startsWith("vue:"))return!0}return!1}(e)&&(e.tagType=1):e.tagType=3),ow.inRCDATA||(e.children=oD(l)),0===i&&om.isIgnoreNewlineTag(r)){let e=l[0];e&&2===e.type&&(e.content=e.content.replace(/^\r?\n/,""))}0===i&&om.isPreTag(r)&&oC--,oT===e&&(ok=ow.inVPre=!1,oT=null),ow.inXML&&(oN[0]?oN[0].ns:om.ns)===0&&(ow.inXML=!1)}function oM(e,t){let n=e;for(;ov.charCodeAt(n)!==t&&n>=0;)n--;return n}let oL=new Set(["if","else","else-if","for","slot"]),o$=/\r\n/g;function oD(e){let t="preserve"!==om.whitespace,n=!1;for(let r=0;r<e.length;r++){let i=e[r];if(2===i.type)if(oC)i.content=i.content.replace(o$,`
+`);else if(function(e){for(let t=0;t<e.length;t++)if(!sG(e.charCodeAt(t)))return!1;return!0}(i.content)){let l=e[r-1]&&e[r-1].type,s=e[r+1]&&e[r+1].type;!l||!s||t&&(3===l&&(3===s||1===s)||1===l&&(3===s||1===s&&function(e){for(let t=0;t<e.length;t++){let n=e.charCodeAt(t);if(10===n||13===n)return!0}return!1}(i.content)))?(n=!0,e[r]=null):i.content=" "}else t&&(i.content=oF(i.content))}return n?e.filter(Boolean):e}function oF(e){let t="",n=!1;for(let r=0;r<e.length;r++)sG(e.charCodeAt(r))?n||(t+=" ",n=!0):(t+=e[r],n=!1);return t}function oV(e){(oN[0]||og).children.push(e)}function oB(e,t){return{start:ow.getPos(e),end:null==t?t:ow.getPos(t),source:null==t?t:oI(e,t)}}function oU(e,t){e.end=ow.getPos(t),e.source=oI(e.start.offset,t)}function oj(e,t=!1,n,r=0,i=0){return sB(e,t,n,r)}function oH(e,t,n){om.onError(s1(e,oB(t,t)))}function oq(e){let t=e.children.filter(e=>3!==e.type);return 1!==t.length||1!==t[0].type||oa(t[0])?null:t[0]}function oW(e,t){let{constantCache:n}=t;switch(e.type){case 1:if(0!==e.tagType)return 0;let r=n.get(e);if(void 0!==r)return r;let i=e.codegenNode;if(13!==i.type||i.isBlock&&"svg"!==e.tag&&"foreignObject"!==e.tag&&"math"!==e.tag)return 0;if(void 0!==i.patchFlag)return n.set(e,0),0;{let r=3,c=oz(e,t);if(0===c)return n.set(e,0),0;c<r&&(r=c);for(let i=0;i<e.children.length;i++){let l=oW(e.children[i],t);if(0===l)return n.set(e,0),0;l<r&&(r=l)}if(r>1)for(let i=0;i<e.props.length;i++){let l=e.props[i];if(7===l.type&&"bind"===l.name&&l.exp){let i=oW(l.exp,t);if(0===i)return n.set(e,0),0;i<r&&(r=i)}}if(i.isBlock){var l,s,o,a;for(let t=0;t<e.props.length;t++)if(7===e.props[t].type)return n.set(e,0),0;t.removeHelper(se),t.removeHelper((l=t.inSSR,s=i.isComponent,l||s?st:sn)),i.isBlock=!1,t.helper((o=t.inSSR,a=i.isComponent,o||a?sr:si))}return n.set(e,r),r}case 2:case 3:return 3;case 9:case 11:case 10:default:return 0;case 5:case 12:return oW(e.content,t);case 4:return e.constType;case 8:let c=3;for(let n=0;n<e.children.length;n++){let r=e.children[n];if(M(r)||L(r))continue;let i=oW(r,t);if(0===i)return 0;i<c&&(c=i)}return c;case 20:return 2}}let oK=new Set([sy,sb,s_,sS]);function oz(e,t){let n=3,r=oJ(e);if(r&&15===r.type){let{properties:e}=r;for(let r=0;r<e.length;r++){let i,{key:l,value:s}=e[r],o=oW(l,t);if(0===o)return o;if(o<n&&(n=o),0===(i=4===s.type?oW(s,t):14===s.type?function e(t,n){if(14===t.type&&!M(t.callee)&&oK.has(t.callee)){let r=t.arguments[0];if(4===r.type)return oW(r,n);if(14===r.type)return e(r,n)}return 0}(s,t):0))return i;i<n&&(n=i)}}return n}function oJ(e){let t=e.codegenNode;if(13===t.type)return t.props}function oG(e,t){t.currentNode=e;let{nodeTransforms:n}=t,r=[];for(let i=0;i<n.length;i++){let l=n[i](e,t);if(l&&(E(l)?r.push(...l):r.push(l)),!t.currentNode)return;e=t.currentNode}switch(e.type){case 3:t.ssr||t.helper(sl);break;case 5:t.ssr||t.helper(sg);break;case 9:for(let n=0;n<e.branches.length;n++)oG(e.branches[n],t);break;case 10:case 11:case 1:case 0:var i=e;let l=0,s=()=>{l--};for(;l<i.children.length;l++){let e=i.children[l];M(e)||(t.grandParent=t.parent,t.parent=i,t.childIndex=l,t.onNodeRemoved=s,oG(e,t))}}t.currentNode=e;let o=r.length;for(;o--;)r[o]()}function oX(e,t){let n=M(e)?t=>t===e:t=>e.test(t);return(e,r)=>{if(1===e.type){let{props:i}=e;if(3===e.tagType&&i.some(os))return;let l=[];for(let s=0;s<i.length;s++){let o=i[s];if(7===o.type&&n(o.name)){i.splice(s,1),s--;let n=t(e,o,r);n&&l.push(n)}}return l}}}let oQ="/*@__PURE__*/",oZ=e=>`${sM[e]}: _${sM[e]}`;function oY(e,t,{helper:n,push:r,newline:i,isTS:l}){let s=n("component"===t?sa:su);for(let n=0;n<e.length;n++){let o=e[n],a=o.endsWith("__self");a&&(o=o.slice(0,-6)),r(`const ${op(o,t)} = ${s}(${JSON.stringify(o)}${a?", true":""})${l?"!":""}`),n<e.length-1&&i()}}function o0(e,t){let n=e.length>3;t.push("["),n&&t.indent(),o1(e,t,n),n&&t.deindent(),t.push("]")}function o1(e,t,n=!1,r=!0){let{push:i,newline:l}=t;for(let s=0;s<e.length;s++){let o=e[s];M(o)?i(o,-3):E(o)?o0(o,t):o2(o,t),s<e.length-1&&(n?(r&&i(","),l()):r&&i(", "))}}function o2(e,t){if(M(e))return void t.push(e,-3);if(L(e))return void t.push(t.helper(e));switch(e.type){case 1:case 9:case 11:case 12:o2(e.codegenNode,t);break;case 2:n=e,t.push(JSON.stringify(n.content),-3,n);break;case 4:o3(e,t);break;case 5:var n,r,i,l=e,s=t;let{push:o,helper:a,pure:c}=s;c&&o(oQ),o(`${a(sg)}(`),o2(l.content,s),o(")");break;case 8:o6(e,t);break;case 3:var u=e,d=t;let{push:p,helper:h,pure:f}=d;f&&p(oQ),p(`${h(sl)}(${JSON.stringify(u.content)})`,-3,u);break;case 13:!function(e,t){var n,r;let i,{push:l,helper:s,pure:o}=t,{tag:a,props:c,children:u,patchFlag:d,dynamicProps:p,directives:h,isBlock:f,disableTracking:m,isComponent:g}=e;d&&(i=String(d)),h&&l(s(sp)+"("),f&&l(`(${s(se)}(${m?"true":""}), `),o&&l(oQ),l(s(f?(n=t.inSSR,n||g?st:sn):(r=t.inSSR,r||g?sr:si))+"(",-2,e),o1(function(e){let t=e.length;for(;t--&&null==e[t];);return e.slice(0,t+1).map(e=>e||"null")}([a,c,u,i,p]),t),l(")"),f&&l(")"),h&&(l(", "),o2(h,t),l(")"))}(e,t);break;case 14:var m=e,g=t;let{push:y,helper:b,pure:_}=g,S=M(m.callee)?m.callee:b(m.callee);_&&y(oQ),y(S+"(",-2,m),o1(m.arguments,g),y(")");break;case 15:!function(e,t){let{push:n,indent:r,deindent:i,newline:l}=t,{properties:s}=e;if(!s.length)return n("{}",-2,e);let o=s.length>1;n(o?"{":"{ "),o&&r();for(let e=0;e<s.length;e++){let{key:r,value:i}=s[e],{push:o}=t;8===r.type?(o("["),o6(r,t),o("]")):r.isStatic?o(s4(r.content)?r.content:JSON.stringify(r.content),-2,r):o(`[${r.content}]`,-3,r),n(": "),o2(i,t),e<s.length-1&&(n(","),l())}o&&i(),n(o?"}":" }")}(e,t);break;case 17:r=e,i=t,o0(r.elements,i);break;case 18:var x=e,C=t;let{push:k,indent:T,deindent:N}=C,{params:w,returns:A,body:I,newline:R,isSlot:O}=x;O&&k(`_${sM[sE]}(`),k("(",-2,x),E(w)?o1(w,C):w&&o2(w,C),k(") => "),(R||I)&&(k("{"),T()),A?(R&&k("return "),E(A)?o0(A,C):o2(A,C)):I&&o2(I,C),(R||I)&&(N(),k("}")),O&&k(")");break;case 19:var P=e,$=t;let{test:D,consequent:F,alternate:V,newline:B}=P,{push:U,indent:j,deindent:H,newline:q}=$;if(4===D.type){let e=!s4(D.content);e&&U("("),o3(D,$),e&&U(")")}else U("("),o2(D,$),U(")");B&&j(),$.indentLevel++,B||U(" "),U("? "),o2(F,$),$.indentLevel--,B&&q(),B||U(" "),U(": ");let W=19===V.type;!W&&$.indentLevel++,o2(V,$),!W&&$.indentLevel--,B&&H(!0);break;case 20:var K=e,z=t;let{push:J,helper:G,indent:X,deindent:Q,newline:Z}=z,{needPauseTracking:Y,needArraySpread:ee}=K;ee&&J("[...("),J(`_cache[${K.index}] || (`),Y&&(X(),J(`${G(sN)}(-1`),K.inVOnce&&J(", true"),J("),"),Z(),J("(")),J(`_cache[${K.index}] = `),o2(K.value,z),Y&&(J(`).cacheIndex = ${K.index},`),Z(),J(`${G(sN)}(1),`),Z(),J(`_cache[${K.index}]`),Q()),J(")"),ee&&J(")]");break;case 21:o1(e.body,t,!0,!1)}}function o3(e,t){let{content:n,isStatic:r}=e;t.push(r?JSON.stringify(n):n,-3,e)}function o6(e,t){for(let n=0;n<e.children.length;n++){let r=e.children[n];M(r)?t.push(r,-3):o2(r,t)}}let o4=oX(/^(if|else|else-if)$/,(e,t,n)=>(function(e,t,n,r){if("else"!==t.name&&(!t.exp||!t.exp.content.trim())){let r=t.exp?t.exp.loc:e.loc;n.onError(s1(28,t.loc)),t.exp=sB("true",!1,r)}if("if"===t.name){var i;let l=o8(e,t),s={type:9,loc:oB((i=e.loc).start.offset,i.end.offset),branches:[l]};if(n.replaceNode(s),r)return r(s,l,!0)}else{let i=n.parent.children,l=i.indexOf(e);for(;l-- >=-1;){let s=i[l];if(s&&3===s.type||s&&2===s.type&&!s.content.trim().length){n.removeNode(s);continue}if(s&&9===s.type){"else-if"===t.name&&void 0===s.branches[s.branches.length-1].condition&&n.onError(s1(30,e.loc)),n.removeNode();let i=o8(e,t);s.branches.push(i);let l=r&&r(s,i,!1);oG(i,n),l&&l(),n.currentNode=null}else n.onError(s1(30,e.loc));break}}})(e,t,n,(e,t,r)=>{let i=n.parent.children,l=i.indexOf(e),s=0;for(;l-- >=0;){let e=i[l];e&&9===e.type&&(s+=e.branches.length)}return()=>{r?e.codegenNode=o5(t,s,n):function(e){for(;;)if(19===e.type)if(19!==e.alternate.type)return e;else e=e.alternate;else 20===e.type&&(e=e.value)}(e.codegenNode).alternate=o5(t,s+e.branches.length-1,n)}}));function o8(e,t){let n=3===e.tagType;return{type:10,loc:e.loc,condition:"else"===t.name?void 0:t.exp,children:n&&!on(e,"for")?e.children:[e],userKey:or(e,"key"),isTemplateIf:n}}function o5(e,t,n){return e.condition?sq(e.condition,o9(e,t,n),sj(n.helper(sl),['""',"true"])):o9(e,t,n)}function o9(e,t,n){let{helper:r}=n,i=sV("key",sB(`${t}`,!1,sL,2)),{children:l}=e,s=l[0];if(1!==l.length||1!==s.type)if(1!==l.length||11!==s.type)return s$(n,r(l4),sF([i]),l,64,void 0,void 0,!0,!1,!1,e.loc);else{let e=s.codegenNode;return ou(e,i,n),e}{let e=s.codegenNode,t=14===e.type&&e.callee===sO?e.arguments[1].returns:e;return 13===t.type&&sW(t,n),ou(t,i,n),e}}let o7=(e,t,n)=>{let{modifiers:r,loc:i}=e,l=e.arg,{exp:s}=e;if(s&&4===s.type&&!s.content.trim()&&(s=void 0),!s){if(4!==l.type||!l.isStatic)return n.onError(s1(52,l.loc)),{props:[sV(l,sB("",!0,i))]};ae(e),s=e.exp}return 4!==l.type?(l.children.unshift("("),l.children.push(') || ""')):l.isStatic||(l.content=`${l.content} || ""`),r.some(e=>"camel"===e.content)&&(4===l.type?l.isStatic?l.content=K(l.content):l.content=`${n.helperString(sC)}(${l.content})`:(l.children.unshift(`${n.helperString(sC)}(`),l.children.push(")"))),!n.inSSR&&(r.some(e=>"prop"===e.content)&&at(l,"."),r.some(e=>"attr"===e.content)&&at(l,"^")),{props:[sV(l,s)]}},ae=(e,t)=>{let n=e.arg;e.exp=sB(K(n.content),!1,n.loc)},at=(e,t)=>{4===e.type?e.isStatic?e.content=t+e.content:e.content=`\`${t}\${${e.content}}\``:(e.children.unshift(`'${t}' + (`),e.children.push(")"))},an=oX("for",(e,t,n)=>{let{helper:r,removeHelper:i}=n;return function(e,t,n,r){if(!t.exp)return void n.onError(s1(31,t.loc));let i=t.forParseResult;if(!i)return void n.onError(s1(32,t.loc));ar(i);let{addIdentifiers:l,removeIdentifiers:s,scopes:o}=n,{source:a,value:c,key:u,index:d}=i,p={type:11,loc:t.loc,source:a,valueAlias:c,keyAlias:u,objectIndexAlias:d,parseResult:i,children:oo(e)?e.children:[e]};n.replaceNode(p),o.vFor++;let h=r&&r(p);return()=>{o.vFor--,h&&h()}}(e,t,n,t=>{let l=sj(r(sh),[t.source]),s=oo(e),o=on(e,"memo"),a=or(e,"key",!1,!0);a&&7===a.type&&!a.exp&&ae(a);let c=a&&(6===a.type?a.value?sB(a.value.content,!0):void 0:a.exp),u=a&&c?sV("key",c):null,d=4===t.source.type&&t.source.constType>0,p=d?64:a?128:256;return t.codegenNode=s$(n,r(l4),void 0,l,p,void 0,void 0,!0,!d,!1,e.loc),()=>{let a,{children:p}=t,h=1!==p.length||1!==p[0].type,f=oa(e)?e:s&&1===e.children.length&&oa(e.children[0])?e.children[0]:null;if(f)a=f.codegenNode,s&&u&&ou(a,u,n);else if(h)a=s$(n,r(l4),u?sF([u]):void 0,e.children,64,void 0,void 0,!0,void 0,!1);else{var m,g,y,b,_,S,x,C;a=p[0].codegenNode,s&&u&&ou(a,u,n),!d!==a.isBlock&&(a.isBlock?(i(se),i((m=n.inSSR,g=a.isComponent,m||g?st:sn))):i((y=n.inSSR,b=a.isComponent,y||b?sr:si))),(a.isBlock=!d,a.isBlock)?(r(se),r((_=n.inSSR,S=a.isComponent,_||S?st:sn))):r((x=n.inSSR,C=a.isComponent,x||C?sr:si))}if(o){let e=sH(ai(t.parseResult,[sB("_cached")]));e.body={type:21,body:[sU(["const _memo = (",o.exp,")"]),sU(["if (_cached",...c?[" && _cached.key === ",c]:[],` && ${n.helperString(sP)}(_cached, _memo)) return _cached`]),sU(["const _item = ",a]),sB("_item.memo = _memo"),sB("return _item")],loc:sL},l.arguments.push(e,sB("_cache"),sB(String(n.cached.length))),n.cached.push(null)}else l.arguments.push(sH(ai(t.parseResult),a,!0))}})});function ar(e,t){e.finalized||(e.finalized=!0)}function ai({value:e,key:t,index:n},r=[]){var i=[e,t,n,...r];let l=i.length;for(;l--&&!i[l];);return i.slice(0,l+1).map((e,t)=>e||sB("_".repeat(t+1),!1))}let al=sB("undefined",!1),as=(e,t)=>{if(1===e.type&&(1===e.tagType||3===e.tagType)){let n=on(e,"slot");if(n)return n.exp,t.scopes.vSlot++,()=>{t.scopes.vSlot--}}};function ao(e,t,n){let r=[sV("name",e),sV("fn",t)];return null!=n&&r.push(sV("key",sB(String(n),!0))),sF(r)}function aa(e){return 2!==e.type&&12!==e.type||(2===e.type?!!e.content.trim():aa(e.content))}let ac=new WeakMap,au=(e,t)=>function(){let n,r,i,l,s;if(1!==(e=t.currentNode).type||0!==e.tagType&&1!==e.tagType)return;let{tag:o,props:a}=e,c=1===e.tagType,u=c?function(e,t,n=!1){let{tag:r}=e,i=ah(r),l=or(e,"is",!1,!0);if(l)if(i){let e;if(6===l.type?e=l.value&&sB(l.value.content,!0):(e=l.exp)||(e=sB("is",!1,l.arg.loc)),e)return sj(t.helper(sc),[e])}else 6===l.type&&l.value.content.startsWith("vue:")&&(r=l.value.content.slice(4));let s=s3(r)||t.isBuiltInComponent(r);return s?(n||t.helper(s),s):(t.helper(sa),t.components.add(r),op(r,"component"))}(e,t):`"${o}"`,d=$(u)&&u.callee===sc,p=0,h=d||u===l8||u===l5||!c&&("svg"===o||"foreignObject"===o||"math"===o);if(a.length>0){let r=ad(e,t,void 0,c,d);n=r.props,p=r.patchFlag,l=r.dynamicPropNames;let i=r.directives;s=i&&i.length?sD(i.map(e=>(function(e,t){let n=[],r=ac.get(e);r?n.push(t.helperString(r)):(t.helper(su),t.directives.add(e.name),n.push(op(e.name,"directive")));let{loc:i}=e;if(e.exp&&n.push(e.exp),e.arg&&(e.exp||n.push("void 0"),n.push(e.arg)),Object.keys(e.modifiers).length){e.arg||(e.exp||n.push("void 0"),n.push("void 0"));let t=sB("true",!1,i);n.push(sF(e.modifiers.map(e=>sV(e,t)),i))}return sD(n,e.loc)})(e,t))):void 0,r.shouldUseBlock&&(h=!0)}if(e.children.length>0)if(u===l9&&(h=!0,p|=1024),c&&u!==l8&&u!==l9){let{slots:n,hasDynamicSlots:i}=function(e,t,n=(e,t,n,r)=>sH(e,n,!1,!0,n.length?n[0].loc:r)){t.helper(sE);let{children:r,loc:i}=e,l=[],s=[],o=t.scopes.vSlot>0||t.scopes.vFor>0,a=on(e,"slot",!0);if(a){let{arg:e,exp:t}=a;e&&!s2(e)&&(o=!0),l.push(sV(e||sB("default",!0),n(t,void 0,r,i)))}let c=!1,u=!1,d=[],p=new Set,h=0;for(let e=0;e<r.length;e++){let i,f,m,g,y=r[e];if(!oo(y)||!(i=on(y,"slot",!0))){3!==y.type&&d.push(y);continue}if(a){t.onError(s1(37,i.loc));break}c=!0;let{children:b,loc:_}=y,{arg:S=sB("default",!0),exp:x,loc:C}=i;s2(S)?f=S?S.content:"default":o=!0;let k=on(y,"for"),T=n(x,k,b,_);if(m=on(y,"if"))o=!0,s.push(sq(m.exp,ao(S,T,h++),al));else if(g=on(y,/^else(-if)?$/,!0)){let n,i=e;for(;i--&&!(3!==(n=r[i]).type&&aa(n)););if(n&&oo(n)&&on(n,/^(else-)?if$/)){let e=s[s.length-1];for(;19===e.alternate.type;)e=e.alternate;e.alternate=g.exp?sq(g.exp,ao(S,T,h++),al):ao(S,T,h++)}else t.onError(s1(30,g.loc))}else if(k){o=!0;let e=k.forParseResult;e?(ar(e),s.push(sj(t.helper(sh),[e.source,sH(ai(e),ao(S,T),!0)]))):t.onError(s1(32,k.loc))}else{if(f){if(p.has(f)){t.onError(s1(38,C));continue}p.add(f),"default"===f&&(u=!0)}l.push(sV(S,T))}}if(!a){let e=(e,t)=>sV("default",n(e,void 0,t,i));c?d.length&&d.some(e=>aa(e))&&(u?t.onError(s1(39,d[0].loc)):l.push(e(void 0,d))):l.push(e(void 0,r))}let f=o?2:!function e(t){for(let n=0;n<t.length;n++){let r=t[n];switch(r.type){case 1:if(2===r.tagType||e(r.children))return!0;break;case 9:if(e(r.branches))return!0;break;case 10:case 11:if(e(r.children))return!0}}return!1}(e.children)?1:3,m=sF(l.concat(sV("_",sB(f+"",!1))),i);return s.length&&(m=sj(t.helper(sm),[m,sD(s)])),{slots:m,hasDynamicSlots:o}}(e,t);r=n,i&&(p|=1024)}else if(1===e.children.length&&u!==l8){let n=e.children[0],i=n.type,l=5===i||8===i;l&&0===oW(n,t)&&(p|=1),r=l||2===i?n:e.children}else r=e.children;l&&l.length&&(i=function(e){let t="[";for(let n=0,r=e.length;n<r;n++)t+=JSON.stringify(e[n]),n<r-1&&(t+=", ");return t+"]"}(l)),e.codegenNode=s$(t,u,n,r,0===p?void 0:p,i,s,!!h,!1,c,e.loc)};function ad(e,t,n=e.props,r,i,l=!1){let s,{tag:o,loc:a,children:c}=e,u=[],d=[],p=[],h=c.length>0,f=!1,m=0,g=!1,y=!1,b=!1,_=!1,S=!1,x=!1,k=[],T=e=>{u.length&&(d.push(sF(ap(u),a)),u=[]),e&&d.push(e)},N=()=>{t.scopes.vFor>0&&u.push(sV(sB("ref_for",!0),sB("true")))},w=({key:e,value:n})=>{if(s2(e)){let l=e.content,s=C(l);s&&(!r||i)&&"onclick"!==l.toLowerCase()&&"onUpdate:modelValue"!==l&&!j(l)&&(_=!0),s&&j(l)&&(x=!0),s&&14===n.type&&(n=n.arguments[0]),20===n.type||(4===n.type||8===n.type)&&oW(n,t)>0||("ref"===l?g=!0:"class"===l?y=!0:"style"===l?b=!0:"key"===l||k.includes(l)||k.push(l),r&&("class"===l||"style"===l)&&!k.includes(l)&&k.push(l))}else S=!0};for(let i=0;i<n.length;i++){let s=n[i];if(6===s.type){let{loc:e,name:t,nameLoc:n,value:r}=s;if("ref"===t&&(g=!0,N()),"is"===t&&(ah(o)||r&&r.content.startsWith("vue:")))continue;u.push(sV(sB(t,!0,n),sB(r?r.content:"",!0,r?r.loc:e)))}else{let{name:n,arg:i,exp:c,loc:g,modifiers:y}=s,b="bind"===n,_="on"===n;if("slot"===n){r||t.onError(s1(40,g));continue}if("once"===n||"memo"===n||"is"===n||b&&oi(i,"is")&&ah(o)||_&&l)continue;if((b&&oi(i,"key")||_&&h&&oi(i,"vue:before-update"))&&(f=!0),b&&oi(i,"ref")&&N(),!i&&(b||_)){S=!0,c?b?(N(),T(),d.push(c)):T({type:14,loc:g,callee:t.helper(sx),arguments:r?[c]:[c,"true"]}):t.onError(s1(b?34:35,g));continue}b&&y.some(e=>"prop"===e.content)&&(m|=32);let x=t.directiveTransforms[n];if(x){let{props:n,needRuntime:r}=x(s,e,t);l||n.forEach(w),_&&i&&!s2(i)?T(sF(n,a)):u.push(...n),r&&(p.push(s),L(r)&&ac.set(s,r))}else!H(n)&&(p.push(s),h&&(f=!0))}}if(d.length?(T(),s=d.length>1?sj(t.helper(sv),d,a):d[0]):u.length&&(s=sF(ap(u),a)),S?m|=16:(y&&!r&&(m|=2),b&&!r&&(m|=4),k.length&&(m|=8),_&&(m|=32)),!f&&(0===m||32===m)&&(g||x||p.length>0)&&(m|=512),!t.inSSR&&s)switch(s.type){case 15:let A=-1,E=-1,I=!1;for(let e=0;e<s.properties.length;e++){let t=s.properties[e].key;s2(t)?"class"===t.content?A=e:"style"===t.content&&(E=e):t.isHandlerKey||(I=!0)}let R=s.properties[A],O=s.properties[E];I?s=sj(t.helper(s_),[s]):(R&&!s2(R.value)&&(R.value=sj(t.helper(sy),[R.value])),O&&(b||4===O.value.type&&"["===O.value.content.trim()[0]||17===O.value.type)&&(O.value=sj(t.helper(sb),[O.value])));break;case 14:break;default:s=sj(t.helper(s_),[sj(t.helper(sS),[s])])}return{props:s,directives:p,patchFlag:m,dynamicPropNames:k,shouldUseBlock:f}}function ap(e){let t=new Map,n=[];for(let l=0;l<e.length;l++){var r,i;let s=e[l];if(8===s.key.type||!s.key.isStatic){n.push(s);continue}let o=s.key.content,a=t.get(o);a?("style"===o||"class"===o||C(o))&&(r=a,i=s,17===r.value.type?r.value.elements.push(i.value):r.value=sD([r.value,i.value],r.loc)):(t.set(o,s),n.push(s))}return n}function ah(e){return"component"===e||"Component"===e}let af=(e,t)=>{if(oa(e)){let{children:n,loc:r}=e,{slotName:i,slotProps:l}=function(e,t){let n,r='"default"',i=[];for(let t=0;t<e.props.length;t++){let n=e.props[t];if(6===n.type)n.value&&("name"===n.name?r=JSON.stringify(n.value.content):(n.name=K(n.name),i.push(n)));else if("bind"===n.name&&oi(n.arg,"name")){if(n.exp)r=n.exp;else if(n.arg&&4===n.arg.type){let e=K(n.arg.content);r=n.exp=sB(e,!1,n.arg.loc)}}else"bind"===n.name&&n.arg&&s2(n.arg)&&(n.arg.content=K(n.arg.content)),i.push(n)}if(i.length>0){let{props:r,directives:l}=ad(e,t,i,!1,!1);n=r,l.length&&t.onError(s1(36,l[0].loc))}return{slotName:r,slotProps:n}}(e,t),s=[t.prefixIdentifiers?"_ctx.$slots":"$slots",i,"{}","undefined","true"],o=2;l&&(s[2]=l,o=3),n.length&&(s[3]=sH([],n,!1,!1,r),o=4),t.scopeId&&!t.slotted&&(o=5),s.splice(o),e.codegenNode=sj(t.helper(sf),s,r)}},am=(e,t,n,r)=>{let i,{loc:l,modifiers:s,arg:o}=e;if(!e.exp&&!s.length,4===o.type)if(o.isStatic){let e=o.content;e.startsWith("vue:")&&(e=`vnode-${e.slice(4)}`),i=sB(0!==t.tagType||e.startsWith("vnode")||!/[A-Z]/.test(e)?X(K(e)):`on:${e}`,!0,o.loc)}else i=sU([`${n.helperString(sT)}(`,o,")"]);else(i=o).children.unshift(`${n.helperString(sT)}(`),i.children.push(")");let a=e.exp;a&&!a.content.trim()&&(a=void 0);let c=n.cacheHandlers&&!a&&!n.inVOnce;if(a){let e,t=oe(a),n=!(t||(e=a,ot.test(s7(e)))),r=a.content.includes(";");(n||c&&t)&&(a=sU([`${n?"$event":"(...args)"} => ${r?"{":"("}`,a,r?"}":")"]))}let u={props:[sV(i,a||sB("() => {}",!1,l))]};return r&&(u=r(u)),c&&(u.props[0].value=n.cache(u.props[0].value)),u.props.forEach(e=>e.key.isHandlerKey=!0),u},ag=(e,t)=>{if(0===e.type||1===e.type||11===e.type||10===e.type)return()=>{let n,r=e.children,i=!1;for(let e=0;e<r.length;e++){let t=r[e];if(ol(t)){i=!0;for(let i=e+1;i<r.length;i++){let l=r[i];if(ol(l))n||(n=r[e]=sU([t],t.loc)),n.children.push(" + ",l),r.splice(i,1),i--;else{n=void 0;break}}}}if(i&&(1!==r.length||0!==e.type&&(1!==e.type||0!==e.tagType||e.props.find(e=>7===e.type&&!t.directiveTransforms[e.name]))))for(let e=0;e<r.length;e++){let n=r[e];if(ol(n)||8===n.type){let i=[];(2!==n.type||" "!==n.content)&&i.push(n),t.ssr||0!==oW(n,t)||i.push("1"),r[e]={type:12,content:n,loc:n.loc,codegenNode:sj(t.helper(ss),i)}}}}},av=new WeakSet,ay=(e,t)=>{if(1===e.type&&on(e,"once",!0)&&!av.has(e)&&!t.inVOnce&&!t.inSSR)return av.add(e),t.inVOnce=!0,t.helper(sN),()=>{t.inVOnce=!1;let e=t.currentNode;e.codegenNode&&(e.codegenNode=t.cache(e.codegenNode,!0,!0))}},ab=(e,t,n)=>{let r,{exp:i,arg:l}=e;if(!i)return n.onError(s1(41,e.loc)),a_();let s=i.loc.source.trim(),o=4===i.type?i.content:s,a=n.bindingMetadata[s];if("props"===a||"props-aliased"===a)return i.loc,a_();if(!o.trim()||!oe(i))return n.onError(s1(42,i.loc)),a_();let c=l||sB("modelValue",!0),u=l?s2(l)?`onUpdate:${K(l.content)}`:sU(['"onUpdate:" + ',l]):"onUpdate:modelValue",d=n.isTS?"($event: any)":"$event";r=sU([`${d} => ((`,i,") = $event)"]);let p=[sV(c,e.exp),sV(u,r)];if(e.modifiers.length&&1===t.tagType){let t=e.modifiers.map(e=>e.content).map(e=>(s4(e)?e:JSON.stringify(e))+": true").join(", "),n=l?s2(l)?`${l.content}Modifiers`:sU([l,' + "Modifiers"']):"modelModifiers";p.push(sV(n,sB(`{ ${t} }`,!1,e.loc,2)))}return a_(p)};function a_(e=[]){return{props:e}}let aS=new WeakSet,ax=(e,t)=>{if(1===e.type){let n=on(e,"memo");if(!(!n||aS.has(e)))return aS.add(e),()=>{let r=e.codegenNode||t.currentNode.codegenNode;r&&13===r.type&&(1!==e.tagType&&sW(r,t),e.codegenNode=sj(t.helper(sO),[n.exp,sH(void 0,r),"_cache",String(t.cached.length)]),t.cached.push(null))}}},aC=Symbol(""),ak=Symbol(""),aT=Symbol(""),aN=Symbol(""),aw=Symbol(""),aA=Symbol(""),aE=Symbol(""),aI=Symbol(""),aR=Symbol(""),aO=Symbol("");Object.getOwnPropertySymbols(r={[aC]:"vModelRadio",[ak]:"vModelCheckbox",[aT]:"vModelText",[aN]:"vModelSelect",[aw]:"vModelDynamic",[aA]:"withModifiers",[aE]:"withKeys",[aI]:"vShow",[aR]:"Transition",[aO]:"TransitionGroup"}).forEach(e=>{sM[e]=r[e]});let aP={parseMode:"html",isVoidTag:eh,isNativeTag:e=>eu(e)||ed(e)||ep(e),isPreTag:e=>"pre"===e,isIgnoreNewlineTag:e=>"pre"===e||"textarea"===e,decodeEntities:function(e,t=!1){return(f||(f=document.createElement("div")),t)?(f.innerHTML=`<div foo="${e.replace(/"/g,"&quot;")}">`,f.children[0].getAttribute("foo")):(f.innerHTML=e,f.textContent)},isBuiltInComponent:e=>"Transition"===e||"transition"===e?aR:"TransitionGroup"===e||"transition-group"===e?aO:void 0,getNamespace(e,t,n){let r=t?t.ns:n;if(t&&2===r)if("annotation-xml"===t.tag){if("svg"===e)return 1;t.props.some(e=>6===e.type&&"encoding"===e.name&&null!=e.value&&("text/html"===e.value.content||"application/xhtml+xml"===e.value.content))&&(r=0)}else/^m(?:[ions]|text)$/.test(t.tag)&&"mglyph"!==e&&"malignmark"!==e&&(r=0);else t&&1===r&&("foreignObject"===t.tag||"desc"===t.tag||"title"===t.tag)&&(r=0);if(0===r){if("svg"===e)return 1;if("math"===e)return 2}return r}},aM=y("passive,once,capture"),aL=y("stop,prevent,self,ctrl,shift,alt,meta,exact,middle"),a$=y("left,right"),aD=y("onkeyup,onkeydown,onkeypress"),aF=(e,t)=>s2(e)&&"onclick"===e.content.toLowerCase()?sB(t,!0):4!==e.type?sU(["(",e,`) === "onClick" ? "${t}" : (`,e,")"]):e,aV=(e,t)=>{1===e.type&&0===e.tagType&&("script"===e.tag||"style"===e.tag)&&t.removeNode()},aB=[e=>{1===e.type&&e.props.forEach((t,n)=>{let r,i;6===t.type&&"style"===t.name&&t.value&&(e.props[n]={type:7,name:"bind",arg:sB("style",!0,t.loc),exp:(r=t.value.content,i=t.loc,sB(JSON.stringify(ea(r)),!1,i,3)),modifiers:[],loc:t.loc})})}],aU={cloak:()=>({props:[]}),html:(e,t,n)=>{let{exp:r,loc:i}=e;return r||n.onError(s1(53,i)),t.children.length&&(n.onError(s1(54,i)),t.children.length=0),{props:[sV(sB("innerHTML",!0,i),r||sB("",!0))]}},text:(e,t,n)=>{let{exp:r,loc:i}=e;return r||n.onError(s1(55,i)),t.children.length&&(n.onError(s1(56,i)),t.children.length=0),{props:[sV(sB("textContent",!0),r?oW(r,n)>0?r:sj(n.helperString(sg),[r],i):sB("",!0))]}},model:(e,t,n)=>{let r=ab(e,t,n);if(!r.props.length||1===t.tagType)return r;e.arg&&n.onError(s1(58,e.arg.loc));let{tag:i}=t,l=n.isCustomElement(i);if("input"===i||"textarea"===i||"select"===i||l){let s=aT,o=!1;if("input"===i||l){let r=or(t,"type");if(r){if(7===r.type)s=aw;else if(r.value)switch(r.value.content){case"radio":s=aC;break;case"checkbox":s=ak;break;case"file":o=!0,n.onError(s1(59,e.loc))}}else t.props.some(e=>7===e.type&&"bind"===e.name&&(!e.arg||4!==e.arg.type||!e.arg.isStatic))&&(s=aw)}else"select"===i&&(s=aN);o||(r.needRuntime=n.helper(s))}else n.onError(s1(57,e.loc));return r.props=r.props.filter(e=>4!==e.key.type||"modelValue"!==e.key.content),r},on:(e,t,n)=>am(e,t,n,t=>{let{modifiers:r}=e;if(!r.length)return t;let{key:i,value:l}=t.props[0],{keyModifiers:s,nonKeyModifiers:o,eventOptionModifiers:a}=((e,t,n,r)=>{let i=[],l=[],s=[];for(let n=0;n<t.length;n++){let r=t[n].content;aM(r)?s.push(r):a$(r)?s2(e)?aD(e.content.toLowerCase())?i.push(r):l.push(r):(i.push(r),l.push(r)):aL(r)?l.push(r):i.push(r)}return{keyModifiers:i,nonKeyModifiers:l,eventOptionModifiers:s}})(i,r,0,e.loc);if(o.includes("right")&&(i=aF(i,"onContextmenu")),o.includes("middle")&&(i=aF(i,"onMouseup")),o.length&&(l=sj(n.helper(aA),[l,JSON.stringify(o)])),s.length&&(!s2(i)||aD(i.content.toLowerCase()))&&(l=sj(n.helper(aE),[l,JSON.stringify(s)])),a.length){let e=a.map(G).join("");i=s2(i)?sB(`${i.content}${e}`,!0):sU(["(",i,`) + "${e}"`])}return{props:[sV(i,l)]}}),show:(e,t,n)=>{let{exp:r,loc:i}=e;return r||n.onError(s1(61,i)),{props:[],needRuntime:n.helper(aI)}}},aj=Object.create(null);function aH(e,t){if(!M(e))if(!e.nodeType)return S;else e=e.innerHTML;let n=e+JSON.stringify(t,(e,t)=>"function"==typeof t?t.toString():t),r=aj[n];if(r)return r;if("#"===e[0]){let t=document.querySelector(e);e=t?t.innerHTML:""}let i=T({hoistStatic:!0,onError:void 0,onWarn:S},t);i.isCustomElement||"undefined"==typeof customElements||(i.isCustomElement=e=>!!customElements.get(e));let{code:l}=function(e,t={}){return function(e,t={}){let n=t.onError||sY,r="module"===t.mode;!0===t.prefixIdentifiers?n(s1(47)):r&&n(s1(48)),t.cacheHandlers&&n(s1(49)),t.scopeId&&!r&&n(s1(50));let i=T({},t,{prefixIdentifiers:!1}),l=M(e)?function(e,t){if(ow.reset(),oy=null,ob=null,o_="",oS=-1,ox=-1,oN.length=0,ov=e,om=T({},of),t){let e;for(e in t)null!=t[e]&&(om[e]=t[e])}ow.mode="html"===om.parseMode?1:2*("sfc"===om.parseMode),ow.inXML=1===om.ns||2===om.ns;let n=t&&t.delimiters;n&&(ow.delimiterOpen=sQ(n[0]),ow.delimiterClose=sQ(n[1]));let r=og=function(e,t=""){return{type:0,source:t,children:e,helpers:new Set,components:[],directives:[],hoists:[],imports:[],cached:[],temps:0,codegenNode:void 0,loc:sL}}([],e);return ow.parse(ov),r.loc=oB(0,e.length),r.children=oD(r.children),og=null,r}(e,i):e,[s,o]=[[ay,o4,ax,an,af,au,as,ag],{on:am,bind:o7,model:ab}];var a=T({},i,{nodeTransforms:[...s,...t.nodeTransforms||[]],directiveTransforms:T({},o,t.directiveTransforms||{})});let c=function(e,{filename:t="",prefixIdentifiers:n=!1,hoistStatic:r=!1,hmr:i=!1,cacheHandlers:l=!1,nodeTransforms:s=[],directiveTransforms:o={},transformHoist:a=null,isBuiltInComponent:c=S,isCustomElement:u=S,expressionPlugins:d=[],scopeId:p=null,slotted:h=!0,ssr:f=!1,inSSR:m=!1,ssrCssVars:g="",bindingMetadata:y=b,inline:_=!1,isTS:x=!1,onError:C=sY,onWarn:k=s0,compatConfig:T}){let N=t.replace(/\?.*$/,"").match(/([^/\\]+)\.\w+$/),w={filename:t,selfName:N&&G(K(N[1])),prefixIdentifiers:n,hoistStatic:r,hmr:i,cacheHandlers:l,nodeTransforms:s,directiveTransforms:o,transformHoist:a,isBuiltInComponent:c,isCustomElement:u,expressionPlugins:d,scopeId:p,slotted:h,ssr:f,inSSR:m,ssrCssVars:g,bindingMetadata:y,inline:_,isTS:x,onError:C,onWarn:k,compatConfig:T,root:e,helpers:new Map,components:new Set,directives:new Set,hoists:[],imports:[],cached:[],constantCache:new WeakMap,temps:0,identifiers:Object.create(null),scopes:{vFor:0,vSlot:0,vPre:0,vOnce:0},parent:null,grandParent:null,currentNode:e,childIndex:0,inVOnce:!1,helper(e){let t=w.helpers.get(e)||0;return w.helpers.set(e,t+1),e},removeHelper(e){let t=w.helpers.get(e);if(t){let n=t-1;n?w.helpers.set(e,n):w.helpers.delete(e)}},helperString:e=>`_${sM[w.helper(e)]}`,replaceNode(e){w.parent.children[w.childIndex]=w.currentNode=e},removeNode(e){let t=w.parent.children,n=e?t.indexOf(e):w.currentNode?w.childIndex:-1;e&&e!==w.currentNode?w.childIndex>n&&(w.childIndex--,w.onNodeRemoved()):(w.currentNode=null,w.onNodeRemoved()),w.parent.children.splice(n,1)},onNodeRemoved:S,addIdentifiers(e){},removeIdentifiers(e){},hoist(e){M(e)&&(e=sB(e)),w.hoists.push(e);let t=sB(`_hoisted_${w.hoists.length}`,!1,e.loc,2);return t.hoisted=e,t},cache(e,t=!1,n=!1){let r=function(e,t,n=!1,r=!1){return{type:20,index:e,value:t,needPauseTracking:n,inVOnce:r,needArraySpread:!1,loc:sL}}(w.cached.length,e,t,n);return w.cached.push(r),r}};return w}(l,a);return oG(l,c),a.hoistStatic&&function e(t,n,r,i=!1,l=!1){let{children:s}=t,o=[];for(let n=0;n<s.length;n++){let a=s[n];if(1===a.type&&0===a.tagType){let e=i?0:oW(a,r);if(e>0){if(e>=2){a.codegenNode.patchFlag=-1,o.push(a);continue}}else{let e=a.codegenNode;if(13===e.type){let t=e.patchFlag;if((void 0===t||512===t||1===t)&&oz(a,r)>=2){let t=oJ(a);t&&(e.props=r.hoist(t))}e.dynamicProps&&(e.dynamicProps=r.hoist(e.dynamicProps))}}}else if(12===a.type&&(i?0:oW(a,r))>=2){o.push(a);continue}if(1===a.type){let n=1===a.tagType;n&&r.scopes.vSlot++,e(a,t,r,!1,l),n&&r.scopes.vSlot--}else if(11===a.type)e(a,t,r,1===a.children.length,!0);else if(9===a.type)for(let n=0;n<a.branches.length;n++)e(a.branches[n],t,r,1===a.branches[n].children.length,l)}let a=!1,c=[];if(o.length===s.length&&1===t.type){if(0===t.tagType&&t.codegenNode&&13===t.codegenNode.type&&E(t.codegenNode.children))t.codegenNode.children=u(sD(t.codegenNode.children)),a=!0;else if(1===t.tagType&&t.codegenNode&&13===t.codegenNode.type&&t.codegenNode.children&&!E(t.codegenNode.children)&&15===t.codegenNode.children.type){let e=d(t.codegenNode,"default");e&&(c.push(r.cached.length),e.returns=u(sD(e.returns)),a=!0)}else if(3===t.tagType&&n&&1===n.type&&1===n.tagType&&n.codegenNode&&13===n.codegenNode.type&&n.codegenNode.children&&!E(n.codegenNode.children)&&15===n.codegenNode.children.type){let e=on(t,"slot",!0),i=e&&e.arg&&d(n.codegenNode,e.arg);i&&(c.push(r.cached.length),i.returns=u(sD(i.returns)),a=!0)}}if(!a)for(let e of o)c.push(r.cached.length),e.codegenNode=r.cache(e.codegenNode);function u(e){let t=r.cache(e);return l&&r.hmr&&(t.needArraySpread=!0),t}function d(e,t){if(e.children&&!E(e.children)&&15===e.children.type){let n=e.children.properties.find(e=>e.key===t||e.key.content===t);return n&&n.value}}c.length&&1===t.type&&1===t.tagType&&t.codegenNode&&13===t.codegenNode.type&&t.codegenNode.children&&!E(t.codegenNode.children)&&15===t.codegenNode.children.type&&t.codegenNode.children.properties.push(sV("__",sB(JSON.stringify(c),!1))),o.length&&r.transformHoist&&r.transformHoist(s,r,t)}(l,void 0,c,!!oq(l)),a.ssr||function(e,t){let{helper:n}=t,{children:r}=e;if(1===r.length){let n=oq(e);if(n&&n.codegenNode){let r=n.codegenNode;13===r.type&&sW(r,t),e.codegenNode=r}else e.codegenNode=r[0]}else r.length>1&&(e.codegenNode=s$(t,n(l4),void 0,e.children,64,void 0,void 0,!0,void 0,!1))}(l,c),l.helpers=new Set([...c.helpers.keys()]),l.components=[...c.components],l.directives=[...c.directives],l.imports=c.imports,l.hoists=c.hoists,l.temps=c.temps,l.cached=c.cached,l.transformed=!0,function(e,t={}){let n=function(e,{mode:t="function",prefixIdentifiers:n="module"===t,sourceMap:r=!1,filename:i="template.vue.html",scopeId:l=null,optimizeImports:s=!1,runtimeGlobalName:o="Vue",runtimeModuleName:a="vue",ssrRuntimeModuleName:c="vue/server-renderer",ssr:u=!1,isTS:d=!1,inSSR:p=!1}){let h={mode:t,prefixIdentifiers:n,sourceMap:r,filename:i,scopeId:l,optimizeImports:s,runtimeGlobalName:o,runtimeModuleName:a,ssrRuntimeModuleName:c,ssr:u,isTS:d,inSSR:p,source:e.source,code:"",column:1,line:1,offset:0,indentLevel:0,pure:!1,map:void 0,helper:e=>`_${sM[e]}`,push(e,t=-2,n){h.code+=e},indent(){f(++h.indentLevel)},deindent(e=!1){e?--h.indentLevel:f(--h.indentLevel)},newline(){f(h.indentLevel)}};function f(e){h.push(`
+`+"  ".repeat(e),0)}return h}(e,t);t.onContextCreated&&t.onContextCreated(n);let{mode:r,push:i,prefixIdentifiers:l,indent:s,deindent:o,newline:a,scopeId:c,ssr:u}=n,d=Array.from(e.helpers),p=d.length>0,h=!l&&"module"!==r;var f=e,m=n;let{ssr:g,prefixIdentifiers:y,push:b,newline:_,runtimeModuleName:S,runtimeGlobalName:x,ssrRuntimeModuleName:C}=m,k=Array.from(f.helpers);if(k.length>0&&(b(`const _Vue = ${x}
+`,-1),f.hoists.length)){let e=[sr,si,sl,ss,so].filter(e=>k.includes(e)).map(oZ).join(", ");b(`const { ${e} } = _Vue
+`,-1)}(function(e,t){if(!e.length)return;t.pure=!0;let{push:n,newline:r}=t;r();for(let i=0;i<e.length;i++){let l=e[i];l&&(n(`const _hoisted_${i+1} = `),o2(l,t),r())}t.pure=!1})(f.hoists,m),_(),b("return ");let T=(u?["_ctx","_push","_parent","_attrs"]:["_ctx","_cache"]).join(", ");if(i(`function ${u?"ssrRender":"render"}(${T}) {`),s(),h&&(i("with (_ctx) {"),s(),p&&(i(`const { ${d.map(oZ).join(", ")} } = _Vue
+`,-1),a())),e.components.length&&(oY(e.components,"component",n),(e.directives.length||e.temps>0)&&a()),e.directives.length&&(oY(e.directives,"directive",n),e.temps>0&&a()),e.temps>0){i("let ");for(let t=0;t<e.temps;t++)i(`${t>0?", ":""}_temp${t}`)}return(e.components.length||e.directives.length||e.temps)&&(i(`
+`,0),a()),u||i("return "),e.codegenNode?o2(e.codegenNode,n):i("null"),h&&(o(),i("}")),o(),i("}"),{ast:e,code:n.code,preamble:"",map:n.map?n.map.toJSON():void 0}}(l,i)}(e,T({},aP,t,{nodeTransforms:[aV,...aB,...t.nodeTransforms||[]],directiveTransforms:T({},aU,t.directiveTransforms||{}),transformHoist:null}))}(e,i),s=Function(l)();return s._rc=!0,aj[n]=s}return iL(aH),e.BaseTransition=ny,e.BaseTransitionPropsValidators=nm,e.Comment=ie,e.DeprecationTypes=null,e.EffectScope=eS,e.ErrorCodes={SETUP_FUNCTION:0,0:"SETUP_FUNCTION",RENDER_FUNCTION:1,1:"RENDER_FUNCTION",NATIVE_EVENT_HANDLER:5,5:"NATIVE_EVENT_HANDLER",COMPONENT_EVENT_HANDLER:6,6:"COMPONENT_EVENT_HANDLER",VNODE_HOOK:7,7:"VNODE_HOOK",DIRECTIVE_HOOK:8,8:"DIRECTIVE_HOOK",TRANSITION_HOOK:9,9:"TRANSITION_HOOK",APP_ERROR_HANDLER:10,10:"APP_ERROR_HANDLER",APP_WARN_HANDLER:11,11:"APP_WARN_HANDLER",FUNCTION_REF:12,12:"FUNCTION_REF",ASYNC_COMPONENT_LOADER:13,13:"ASYNC_COMPONENT_LOADER",SCHEDULER:14,14:"SCHEDULER",COMPONENT_UPDATE:15,15:"COMPONENT_UPDATE",APP_UNMOUNT_CLEANUP:16,16:"APP_UNMOUNT_CLEANUP"},e.ErrorTypeStrings=null,e.Fragment=r9,e.KeepAlive={name:"KeepAlive",__isKeepAlive:!0,props:{include:[String,RegExp,Array],exclude:[String,RegExp,Array],max:[String,Number]},setup(e,{slots:t}){let n=iE(),r=n.ctx,i=new Map,l=new Set,s=null,o=n.suspense,{renderer:{p:a,m:c,um:u,o:{createElement:d}}}=r,p=d("div");function h(e){nW(e),u(e,n,o,!0)}function f(e){i.forEach((t,n)=>{let r=iB(t.type);r&&!e(r)&&m(n)})}function m(e){let t=i.get(e);!t||s&&ip(t,s)?s&&nW(s):h(t),i.delete(e),l.delete(e)}r.activate=(e,t,n,r,i)=>{let l=e.component;c(e,t,n,0,o),a(l.vnode,e,t,n,l,o,r,e.slotScopeIds,i),rM(()=>{l.isDeactivated=!1,l.a&&Z(l.a);let t=e.props&&e.props.onVnodeMounted;t&&iT(t,l.parent,e)},o)},r.deactivate=e=>{let t=e.component;rU(t.m),rU(t.a),c(e,p,null,1,o),rM(()=>{t.da&&Z(t.da);let n=e.props&&e.props.onVnodeUnmounted;n&&iT(n,t.parent,e),t.isDeactivated=!0},o)},rq(()=>[e.include,e.exclude],([e,t])=>{e&&f(t=>nU(e,t)),t&&f(e=>!nU(t,e))},{flush:"post",deep:!0});let g=null,y=()=>{null!=g&&(r1(n.subTree.type)?rM(()=>{i.set(g,nK(n.subTree))},n.subTree.suspense):i.set(g,nK(n.subTree)))};return nX(y),nZ(y),nY(()=>{i.forEach(e=>{let{subTree:t,suspense:r}=n,i=nK(t);if(e.type===i.type&&e.key===i.key){nW(i);let e=i.component.da;e&&rM(e,r);return}h(e)})}),()=>{if(g=null,!t.default)return s=null;let n=t.default(),r=n[0];if(n.length>1)return s=null,n;if(!id(r)||!(4&r.shapeFlag)&&!(128&r.shapeFlag))return s=null,r;let o=nK(r);if(o.type===ie)return s=null,o;let a=o.type,c=iB(nF(o)?o.type.__asyncResolved||{}:a),{include:u,exclude:d,max:p}=e;if(u&&(!c||!nU(u,c))||d&&c&&nU(d,c))return o.shapeFlag&=-257,s=o,r;let h=null==o.key?a:o.key,f=i.get(h);return o.el&&(o=ib(o),128&r.shapeFlag&&(r.ssContent=o)),g=h,f?(o.el=f.el,o.component=f.component,o.transition&&nC(o,o.transition),o.shapeFlag|=512,l.delete(h),l.add(h)):(l.add(h),p&&l.size>parseInt(p,10)&&m(l.values().next().value)),o.shapeFlag|=256,s=o,r1(r.type)?r:o}}},e.ReactiveEffect=eC,e.Static=it,e.Suspense={name:"Suspense",__isSuspense:!0,process(e,t,n,r,i,l,s,o,a,c){if(null==e){var u=t,d=n,p=r,h=i,f=l,m=s,g=o,y=a,b=c;let{p:e,o:{createElement:_}}=b,S=_("div"),x=u.suspense=r6(u,f,h,d,S,p,m,g,y,b);e(null,x.pendingBranch=u.ssContent,S,null,h,x,m,g),x.deps>0?(r3(u,"onPending"),r3(u,"onFallback"),e(null,u.ssFallback,d,p,h,null,m,g),r5(x,u.ssFallback)):x.resolve(!1,!0)}else{if(l&&l.deps>0&&!e.suspense.isInFallback){t.suspense=e.suspense,t.suspense.vnode=t,t.el=e.el;return}!function(e,t,n,r,i,l,s,o,{p:a,um:c,o:{createElement:u}}){let d=t.suspense=e.suspense;d.vnode=t,t.el=e.el;let p=t.ssContent,h=t.ssFallback,{activeBranch:f,pendingBranch:m,isInFallback:g,isHydrating:y}=d;if(m)d.pendingBranch=p,ip(p,m)?(a(m,p,d.hiddenContainer,null,i,d,l,s,o),d.deps<=0?d.resolve():g&&!y&&(a(f,h,n,r,i,null,l,s,o),r5(d,h))):(d.pendingId=r2++,y?(d.isHydrating=!1,d.activeBranch=m):c(m,i,d),d.deps=0,d.effects.length=0,d.hiddenContainer=u("div"),g?(a(null,p,d.hiddenContainer,null,i,d,l,s,o),d.deps<=0?d.resolve():(a(f,h,n,r,i,null,l,s,o),r5(d,h))):f&&ip(p,f)?(a(f,p,n,r,i,d,l,s,o),d.resolve(!0)):(a(null,p,d.hiddenContainer,null,i,d,l,s,o),d.deps<=0&&d.resolve()));else if(f&&ip(p,f))a(f,p,n,r,i,d,l,s,o),r5(d,p);else if(r3(t,"onPending"),d.pendingBranch=p,512&p.shapeFlag?d.pendingId=p.component.suspenseId:d.pendingId=r2++,a(null,p,d.hiddenContainer,null,i,d,l,s,o),d.deps<=0)d.resolve();else{let{timeout:e,pendingId:t}=d;e>0?setTimeout(()=>{d.pendingId===t&&d.fallback(h)},e):0===e&&d.fallback(h)}}(e,t,n,r,i,s,o,a,c)}},hydrate:function(e,t,n,r,i,l,s,o,a){let c=t.suspense=r6(t,r,n,e.parentNode,document.createElement("div"),null,i,l,s,o,!0),u=a(e,c.pendingBranch=t.ssContent,n,c,l,s);return 0===c.deps&&c.resolve(!1,!0),u},normalize:function(e){let{shapeFlag:t,children:n}=e,r=32&t;e.ssContent=r4(r?n.default:n),e.ssFallback=r?r4(n.fallback):iv(ie)}},e.Teleport=no,e.Text=r7,e.TrackOpTypes={GET:"get",HAS:"has",ITERATE:"iterate"},e.Transition=i0,e.TransitionGroup=lR,e.TriggerOpTypes={SET:"set",ADD:"add",DELETE:"delete",CLEAR:"clear"},e.VueElement=lT,e.assertNumber=function(e,t){},e.callWithAsyncErrorHandling=tq,e.callWithErrorHandling=tH,e.camelize=K,e.capitalize=G,e.cloneVNode=ib,e.compatUtils=null,e.compile=aH,e.computed=iU,e.createApp=l1,e.createBlock=iu,e.createCommentVNode=function(e="",t=!1){return t?(il(),iu(ie,null,e)):iv(ie,null,e)},e.createElementBlock=function(e,t,n,r,i,l){return ic(ig(e,t,n,r,i,l,!0))},e.createElementVNode=ig,e.createHydrationRenderer=rL,e.createPropsRestProxy=function(e,t){let n={};for(let r in e)t.includes(r)||Object.defineProperty(n,r,{enumerable:!0,get:()=>e[r]});return n},e.createRenderer=function(e){return r$(e)},e.createSSRApp=l2,e.createSlots=function(e,t){for(let n=0;n<t.length;n++){let r=t[n];if(E(r))for(let t=0;t<r.length;t++)e[r[t].name]=r[t].fn;else r&&(e[r.name]=r.key?(...e)=>{let t=r.fn(...e);return t&&(t.key=r.key),t}:r.fn)}return e},e.createStaticVNode=function(e,t){let n=iv(it,null,e);return n.staticCount=t,n},e.createTextVNode=i_,e.createVNode=iv,e.customRef=tM,e.defineAsyncComponent=function(e){let t;P(e)&&(e={loader:e});let{loader:n,loadingComponent:r,errorComponent:i,delay:l=200,hydrate:s,timeout:o,suspensible:a=!0,onError:c}=e,u=null,d=0,p=()=>{let e;return u||(e=u=n().catch(e=>{if(e=e instanceof Error?e:Error(String(e)),c)return new Promise((t,n)=>{c(e,()=>t((d++,u=null,p())),()=>n(e),d+1)});throw e}).then(n=>e!==u&&u?u:(n&&(n.__esModule||"Module"===n[Symbol.toStringTag])&&(n=n.default),t=n,n)))};return nT({name:"AsyncComponentWrapper",__asyncLoader:p,__asyncHydrate(e,n,r){let i=s?()=>{let t=s(()=>{r()},t=>(function(e,t){if(nR(e)&&"["===e.data){let n=1,r=e.nextSibling;for(;r;){if(1===r.nodeType){if(!1===t(r))break}else if(nR(r))if("]"===r.data){if(0==--n)break}else"["===r.data&&n++;r=r.nextSibling}}else t(e)})(e,t));t&&(n.bum||(n.bum=[])).push(t),(n.u||(n.u=[])).push(()=>!0)}:r;t?i():p().then(()=>!n.isUnmounted&&i())},get __asyncResolved(){return t},setup(){let e=iA;if(nN(e),t)return()=>nV(t,e);let n=t=>{u=null,tW(t,e,13,!i)};if(a&&e.suspense)return p().then(t=>()=>nV(t,e)).catch(e=>(n(e),()=>i?iv(i,{error:e}):null));let s=tN(!1),c=tN(),d=tN(!!l);return l&&setTimeout(()=>{d.value=!1},l),null!=o&&setTimeout(()=>{if(!s.value&&!c.value){let e=Error(`Async component timed out after ${o}ms.`);n(e),c.value=e}},o),p().then(()=>{s.value=!0,e.parent&&nB(e.parent.vnode)&&e.parent.update()}).catch(e=>{n(e),c.value=e}),()=>s.value&&t?nV(t,e):c.value&&i?iv(i,{error:c.value}):r&&!d.value?iv(r):void 0}})},e.defineComponent=nT,e.defineCustomElement=lC,e.defineEmits=function(){return null},e.defineExpose=function(e){},e.defineModel=function(){},e.defineOptions=function(e){},e.defineProps=function(){return null},e.defineSSRCustomElement=(e,t)=>lC(e,t,l2),e.defineSlots=function(){return null},e.devtools=void 0,e.effect=function(e,t){e.effect instanceof eC&&(e=e.effect.fn);let n=new eC(e);t&&T(n,t);try{n.run()}catch(e){throw n.stop(),e}let r=n.run.bind(n);return r.effect=n,r},e.effectScope=function(e){return new eS(e)},e.getCurrentInstance=iE,e.getCurrentScope=function(){return l},e.getCurrentWatcher=function(){return m},e.getTransitionRawChildren=nk,e.guardReactiveProps=iy,e.h=ij,e.handleError=tW,e.hasInjectionContext=function(){return!!(iA||t8||ry)},e.hydrate=(...e)=>{lY().hydrate(...e)},e.hydrateOnIdle=(e=1e4)=>t=>{let n=n$(t,{timeout:e});return()=>nD(n)},e.hydrateOnInteraction=(e=[])=>(t,n)=>{M(e)&&(e=[e]);let r=!1,i=e=>{r||(r=!0,l(),t(),e.target.dispatchEvent(new e.constructor(e.type,e)))},l=()=>{n(t=>{for(let n of e)t.removeEventListener(n,i)})};return n(t=>{for(let n of e)t.addEventListener(n,i,{once:!0})}),l},e.hydrateOnMediaQuery=e=>t=>{if(e){let n=matchMedia(e);if(!n.matches)return n.addEventListener("change",t,{once:!0}),()=>n.removeEventListener("change",t);t()}},e.hydrateOnVisible=e=>(t,n)=>{let r=new IntersectionObserver(e=>{for(let n of e)if(n.isIntersecting){r.disconnect(),t();break}},e);return n(e=>{if(e instanceof Element){if(function(e){let{top:t,left:n,bottom:r,right:i}=e.getBoundingClientRect(),{innerHeight:l,innerWidth:s}=window;return(t>0&&t<l||r>0&&r<l)&&(n>0&&n<s||i>0&&i<s)}(e))return t(),r.disconnect(),!1;r.observe(e)}}),()=>r.disconnect()},e.initCustomFormatter=function(){},e.initDirectivesForSSR=S,e.inject=r_,e.isMemoSame=iH,e.isProxy=t_,e.isReactive=tv,e.isReadonly=ty,e.isRef=tT,e.isRuntimeOnly=()=>!d,e.isShallow=tb,e.isVNode=id,e.markRaw=tx,e.mergeDefaults=function(e,t){let n=rl(e);for(let e in t){if(e.startsWith("__skip"))continue;let r=n[e];r?E(r)||P(r)?r=n[e]={type:r,default:t[e]}:r.default=t[e]:null===r&&(r=n[e]={default:t[e]}),r&&t[`__skip_${e}`]&&(r.skipFactory=!0)}return n},e.mergeModels=function(e,t){return e&&t?E(e)&&E(t)?e.concat(t):T({},rl(e),rl(t)):e||t},e.mergeProps=ik,e.nextTick=tY,e.normalizeClass=ec,e.normalizeProps=function(e){if(!e)return null;let{class:t,style:n}=e;return t&&!M(t)&&(e.class=ec(t)),n&&(e.style=ei(n)),e},e.normalizeStyle=ei,e.onActivated=nj,e.onBeforeMount=nG,e.onBeforeUnmount=nY,e.onBeforeUpdate=nQ,e.onDeactivated=nH,e.onErrorCaptured=n6,e.onMounted=nX,e.onRenderTracked=n3,e.onRenderTriggered=n2,e.onScopeDispose=function(e,t=!1){l&&l.cleanups.push(e)},e.onServerPrefetch=n1,e.onUnmounted=n0,e.onUpdated=nZ,e.onWatcherCleanup=tU,e.openBlock=il,e.popScopeId=function(){t5=null},e.provide=rb,e.proxyRefs=tO,e.pushScopeId=function(e){t5=e},e.queuePostFlushCb=t2,e.reactive=th,e.readonly=tm,e.ref=tN,e.registerRuntimeCompiler=iL,e.render=l0,e.renderList=function(e,t,n,r){let i,l=n&&n[r],s=E(e);if(s||M(e)){let n=s&&tv(e),r=!1,o=!1;n&&(r=!tb(e),o=ty(e),e=ez(e)),i=Array(e.length);for(let n=0,s=e.length;n<s;n++)i[n]=t(r?o?tk(tC(e[n])):tC(e[n]):e[n],n,void 0,l&&l[n])}else if("number"==typeof e){i=Array(e);for(let n=0;n<e;n++)i[n]=t(n+1,n,void 0,l&&l[n])}else if($(e))if(e[Symbol.iterator])i=Array.from(e,(e,n)=>t(e,n,void 0,l&&l[n]));else{let n=Object.keys(e);i=Array(n.length);for(let r=0,s=n.length;r<s;r++){let s=n[r];i[r]=t(e[s],s,r,l&&l[r])}}else i=[];return n&&(n[r]=i),i},e.renderSlot=function(e,t,n={},r,i){if(t8.ce||t8.parent&&nF(t8.parent)&&t8.parent.ce)return"default"!==t&&(n.name=t),il(),iu(r9,null,[iv("slot",n,r&&r())],64);let l=e[t];l&&l._c&&(l._d=!1),il();let s=l&&function e(t){return t.some(t=>!id(t)||t.type!==ie&&(t.type!==r9||!!e(t.children)))?t:null}(l(n)),o=n.key||s&&s.key,a=iu(r9,{key:(o&&!L(o)?o:`_${t}`)+(!s&&r?"_fb":"")},s||(r?r():[]),s&&1===e._?64:-2);return!i&&a.scopeId&&(a.slotScopeIds=[a.scopeId+"-s"]),l&&l._c&&(l._d=!0),a},e.resolveComponent=function(e,t){return n5(n4,e,!0,t)||e},e.resolveDirective=function(e){return n5("directives",e)},e.resolveDynamicComponent=function(e){return M(e)?n5(n4,e,!1)||e:e||n8},e.resolveFilter=null,e.resolveTransitionHooks=n_,e.setBlockTracking=ia,e.setDevtoolsHook=S,e.setTransitionHooks=nC,e.shallowReactive=tf,e.shallowReadonly=function(e){return tg(e,!0,te,ta,tp)},e.shallowRef=tw,e.ssrContextKey=rj,e.ssrUtils=null,e.stop=function(e){e.effect.stop()},e.toDisplayString=ey,e.toHandlerKey=X,e.toHandlers=function(e,t){let n={};for(let r in e)n[t&&/[A-Z]/.test(r)?`on:${r}`:X(r)]=e[r];return n},e.toRaw=tS,e.toRef=function(e,t,n){return tT(e)?e:P(e)?new t$(e):$(e)&&arguments.length>1?tD(e,t,n):tN(e)},e.toRefs=function(e){let t=E(e)?Array(e.length):{};for(let n in e)t[n]=tD(e,n);return t},e.toValue=function(e){return P(e)?e():tI(e)},e.transformVNodeArgs=function(e){},e.triggerRef=function(e){e.dep&&e.dep.trigger()},e.unref=tI,e.useAttrs=function(){return ri().attrs},e.useCssModule=function(e="$style"){return b},e.useCssVars=function(e){let t=iE();if(!t)return;let n=t.ut=(n=e(t.proxy))=>{Array.from(document.querySelectorAll(`[data-v-owner="${t.uid}"]`)).forEach(e=>lo(e,n))},r=()=>{let r=e(t.proxy);t.ce?lo(t.ce,r):function e(t,n){if(128&t.shapeFlag){let r=t.suspense;t=r.activeBranch,r.pendingBranch&&!r.isHydrating&&r.effects.push(()=>{e(r.activeBranch,n)})}for(;t.component;)t=t.component.subTree;if(1&t.shapeFlag&&t.el)lo(t.el,n);else if(t.type===r9)t.children.forEach(t=>e(t,n));else if(t.type===it){let{el:e,anchor:r}=t;for(;e&&(lo(e,n),e!==r);)e=e.nextSibling}}(t.subTree,r),n(r)};nQ(()=>{t2(r)}),nX(()=>{rq(r,S,{flush:"post"});let e=new MutationObserver(r);e.observe(t.subTree.el.parentNode,{childList:!0}),n0(()=>e.disconnect())})},e.useHost=lN,e.useId=function(){let e=iE();return e?(e.appContext.config.idPrefix||"v")+"-"+e.ids[0]+e.ids[1]++:""},e.useModel=function(e,t,n=b){let r=iE(),i=K(t),l=J(t),s=rz(e,i),o=tM((s,o)=>{let a,c,u=b;return rH(()=>{let t=e[i];Q(a,t)&&(a=t,o())}),{get:()=>(s(),n.get?n.get(a):a),set(e){let s=n.set?n.set(e):e;if(!Q(s,a)&&!(u!==b&&Q(e,u)))return;let d=r.vnode.props;d&&(t in d||i in d||l in d)&&(`onUpdate:${t}`in d||`onUpdate:${i}`in d||`onUpdate:${l}`in d)||(a=e,o()),r.emit(`update:${t}`,s),Q(e,s)&&Q(e,u)&&!Q(s,c)&&o(),u=e,c=s}}});return o[Symbol.iterator]=()=>{let e=0;return{next:()=>e<2?{value:e++?s||b:o,done:!1}:{done:!0}}},o},e.useSSRContext=()=>{},e.useShadowRoot=function(){let e=lN();return e&&e.shadowRoot},e.useSlots=function(){return ri().slots},e.useTemplateRef=function(e){let t=iE(),n=tw(null);return t&&Object.defineProperty(t.refs===b?t.refs={}:t.refs,e,{enumerable:!0,get:()=>n.value,set:e=>n.value=e}),n},e.useTransitionState=nh,e.vModelCheckbox=lB,e.vModelDynamic={created(e,t,n){lz(e,t,n,null,"created")},mounted(e,t,n){lz(e,t,n,null,"mounted")},beforeUpdate(e,t,n,r){lz(e,t,n,r,"beforeUpdate")},updated(e,t,n,r){lz(e,t,n,r,"updated")}},e.vModelRadio=lj,e.vModelSelect=lH,e.vModelText=lV,e.vShow={beforeMount(e,{value:t},{transition:n}){e[lr]="none"===e.style.display?"":e.style.display,n&&t?n.beforeEnter(e):ll(e,t)},mounted(e,{value:t},{transition:n}){n&&t&&n.enter(e)},updated(e,{value:t,oldValue:n},{transition:r}){!t!=!n&&(r?t?(r.beforeEnter(e),ll(e,!0),r.enter(e)):r.leave(e,()=>{ll(e,!1)}):ll(e,t))},beforeUnmount(e,{value:t}){ll(e,t)}},e.version=iq,e.warn=S,e.watch=function(e,t,n){return rq(e,t,n)},e.watchEffect=function(e,t){return rq(e,null,t)},e.watchPostEffect=function(e,t){return rq(e,null,{flush:"post"})},e.watchSyncEffect=rH,e.withAsyncContext=function(e){let t=iE(),n=e();return iR(),D(n)&&(n=n.catch(e=>{throw iI(t),e})),[n,()=>iI(t)]},e.withCtx=t7,e.withDefaults=function(e,t){return null},e.withDirectives=function(e,t){if(null===t8)return e;let n=iV(t8),r=e.dirs||(e.dirs=[]);for(let e=0;e<t.length;e++){let[i,l,s,o=b]=t[e];i&&(P(i)&&(i={mounted:i,updated:i}),i.deep&&tj(l),r.push({dir:i,instance:n,value:l,oldValue:void 0,arg:s,modifiers:o}))}return e},e.withKeys=(e,t)=>{let n=e._withKeys||(e._withKeys={}),r=t.join(".");return n[r]||(n[r]=n=>{if(!("key"in n))return;let r=J(n.key);if(t.some(e=>e===r||lX[e]===r))return e(n)})},e.withMemo=function(e,t,n,r){let i=n[r];if(i&&iH(i,e))return i;let l=t();return l.memo=e.slice(),l.cacheIndex=r,n[r]=l},e.withModifiers=(e,t)=>{let n=e._withMods||(e._withMods={}),r=t.join(".");return n[r]||(n[r]=(n,...r)=>{for(let e=0;e<t.length;e++){let r=lG[t[e]];if(r&&r(n,t))return}return e(n,...r)})},e.withScopeId=e=>t7,e}({});