vue 3.2.33 → 3.2.35

package/dist/vue.global.js

@@ -242,6 +242,11 @@ var Vue = (function (exports) {
       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) {
@@ -337,7 +342,7 @@ var Vue = (function (exports) {
   const isArray = Array.isArray;
   const isMap = (val) => toTypeString(val) === '[object Map]';
   const isSet = (val) => toTypeString(val) === '[object Set]';
-  const isDate = (val) => val instanceof Date;
+  const isDate = (val) => toTypeString(val) === '[object Date]';
   const isFunction = (val) => typeof val === 'function';
   const isString = (val) => typeof val === 'string';
   const isSymbol = (val) => typeof val === 'symbol';
@@ -784,17 +789,28 @@ var Vue = (function (exports) {
   }
   function triggerEffects(dep, debuggerEventExtraInfo) {
       // spread into array for stabilization
-      for (const effect of isArray(dep) ? dep : [...dep]) {
-          if (effect !== activeEffect || effect.allowRecurse) {
-              if (effect.onTrigger) {
-                  effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
-              }
-              if (effect.scheduler) {
-                  effect.scheduler();
-              }
-              else {
-                  effect.run();
-              }
+      const effects = isArray(dep) ? dep : [...dep];
+      for (const effect of effects) {
+          if (effect.computed) {
+              triggerEffect(effect, debuggerEventExtraInfo);
+          }
+      }
+      for (const effect of effects) {
+          if (!effect.computed) {
+              triggerEffect(effect, debuggerEventExtraInfo);
+          }
+      }
+  }
+  function triggerEffect(effect, debuggerEventExtraInfo) {
+      if (effect !== activeEffect || effect.allowRecurse) {
+          if (effect.onTrigger) {
+              effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
+          }
+          if (effect.scheduler) {
+              effect.scheduler();
+          }
+          else {
+              effect.run();
           }
       }
   }
@@ -803,6 +819,10 @@ var Vue = (function (exports) {
   const builtInSymbols = new Set(
   /*#__PURE__*/
   Object.getOwnPropertyNames(Symbol)
+      // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
+      // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
+      // function
+      .filter(key => key !== 'arguments' && key !== 'caller')
       .map(key => Symbol[key])
       .filter(isSymbol));
   const get = /*#__PURE__*/ createGetter();
@@ -876,9 +896,8 @@ var Vue = (function (exports) {
               return res;
           }
           if (isRef(res)) {
-              // ref unwrapping - does not apply for Array + integer key.
-              const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
-              return shouldUnwrap ? res.value : res;
+              // ref unwrapping - skip unwrap for Array + integer key.
+              return targetIsArray && isIntegerKey(key) ? res : res.value;
           }
           if (isObject(res)) {
               // Convert returned value into a proxy as well. we do the isObject check
@@ -984,10 +1003,12 @@ var Vue = (function (exports) {
       target = target["__v_raw" /* RAW */];
       const rawTarget = toRaw(target);
       const rawKey = toRaw(key);
-      if (key !== rawKey) {
-          !isReadonly && track(rawTarget, "get" /* GET */, key);
+      if (!isReadonly) {
+          if (key !== rawKey) {
+              track(rawTarget, "get" /* GET */, key);
+          }
+          track(rawTarget, "get" /* GET */, rawKey);
       }
-      !isReadonly && track(rawTarget, "get" /* GET */, rawKey);
       const { has } = getProto(rawTarget);
       const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
       if (has.call(rawTarget, key)) {
@@ -1006,10 +1027,12 @@ var Vue = (function (exports) {
       const target = this["__v_raw" /* RAW */];
       const rawTarget = toRaw(target);
       const rawKey = toRaw(key);
-      if (key !== rawKey) {
-          !isReadonly && track(rawTarget, "has" /* HAS */, key);
+      if (!isReadonly) {
+          if (key !== rawKey) {
+              track(rawTarget, "has" /* HAS */, key);
+          }
+          track(rawTarget, "has" /* HAS */, rawKey);
       }
-      !isReadonly && track(rawTarget, "has" /* HAS */, rawKey);
       return key === rawKey
           ? target.has(key)
           : target.has(key) || target.has(rawKey);
@@ -1335,7 +1358,7 @@ var Vue = (function (exports) {
       if (existingProxy) {
           return existingProxy;
       }
-      // only a whitelist of value types can be observed.
+      // only specific value types can be observed.
       const targetType = getTargetType(target);
       if (targetType === 0 /* INVALID */) {
           return target;
@@ -1885,6 +1908,8 @@ var Vue = (function (exports) {
       }
   }
   function flushPostFlushCbs(seen) {
+      // flush any pre cbs queued during the flush (e.g. pre watchers)
+      flushPreFlushCbs();
       if (pendingPostFlushCbs.length) {
           const deduped = [...new Set(pendingPostFlushCbs)];
           pendingPostFlushCbs.length = 0;
@@ -2143,7 +2168,6 @@ var Vue = (function (exports) {
       // 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)
-      // eslint-disable-next-line no-restricted-globals
       typeof window !== 'undefined' &&
           // some envs mock window but not fully
           window.HTMLElement &&
@@ -2237,7 +2261,7 @@ var Vue = (function (exports) {
           if (trim) {
               args = rawArgs.map(a => a.trim());
           }
-          else if (number) {
+          if (number) {
               args = rawArgs.map(toNumber);
           }
       }
@@ -2535,6 +2559,8 @@ var Vue = (function (exports) {
               warn$1(`Runtime directive used on component with non-element root node. ` +
                   `The directives will not function as intended.`);
           }
+          // clone before mutating since the root may be a hoisted vnode
+          root = cloneVNode(root);
           root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
       }
       // inherit transition data
@@ -3237,7 +3263,7 @@ var Vue = (function (exports) {
       }
       else if (isArray(source)) {
           isMultiSource = true;
-          forceTrigger = source.some(isReactive);
+          forceTrigger = source.some(s => isReactive(s) || isShallow(s));
           getter = () => source.map(s => {
               if (isRef(s)) {
                   return s.value;
@@ -3329,16 +3355,7 @@ var Vue = (function (exports) {
       }
       else {
           // default: 'pre'
-          scheduler = () => {
-              if (!instance || instance.isMounted) {
-                  queuePreFlushCb(job);
-              }
-              else {
-                  // with 'pre' option, the first call must happen before
-                  // the component is mounted so it is called synchronously.
-                  job();
-              }
-          };
+          scheduler = () => queuePreFlushCb(job);
       }
       const effect = new ReactiveEffect(getter, scheduler);
       {
@@ -3591,6 +3608,17 @@ var Vue = (function (exports) {
           hook &&
               callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);
       };
+      const callAsyncHook = (hook, args) => {
+          const done = args[1];
+          callHook(hook, args);
+          if (isArray(hook)) {
+              if (hook.every(hook => hook.length <= 1))
+                  done();
+          }
+          else if (hook.length <= 1) {
+              done();
+          }
+      };
       const hooks = {
           mode,
           persisted,
@@ -3649,10 +3677,7 @@ var Vue = (function (exports) {
                   el._enterCb = undefined;
               });
               if (hook) {
-                  hook(el, done);
-                  if (hook.length <= 1) {
-                      done();
-                  }
+                  callAsyncHook(hook, [el, done]);
               }
               else {
                   done();
@@ -3686,10 +3711,7 @@ var Vue = (function (exports) {
               });
               leavingVNodesCache[key] = vnode;
               if (onLeave) {
-                  onLeave(el, done);
-                  if (onLeave.length <= 1) {
-                      done();
-                  }
+                  callAsyncHook(onLeave, [el, done]);
               }
               else {
                   done();
@@ -3899,7 +3921,7 @@ var Vue = (function (exports) {
           }
       });
   }
-  function createInnerComp(comp, { vnode: { ref, props, children } }) {
+  function createInnerComp(comp, { vnode: { ref, props, children, shapeFlag }, parent }) {
       const vnode = createVNode(comp, props, children);
       // ensure inner component inherits the async wrapper's ref owner
       vnode.ref = ref;
@@ -3926,11 +3948,6 @@ var Vue = (function (exports) {
           // The whole point of this is to avoid importing KeepAlive directly in the
           // renderer to facilitate tree-shaking.
           const sharedContext = instance.ctx;
-          // if the internal renderer is not registered, it indicates that this is server-side rendering,
-          // for KeepAlive, we just need to render its children
-          if (!sharedContext.renderer) {
-              return slots.default;
-          }
           const cache = new Map();
           const keys = new Set();
           let current = null;
@@ -4108,7 +4125,7 @@ var Vue = (function (exports) {
               // avoid vnode being unmounted
               vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
               current = vnode;
-              return rawVNode;
+              return isSuspense(rawVNode.type) ? rawVNode : vnode;
           };
       }
   };
@@ -4246,1110 +4263,1597 @@ var Vue = (function (exports) {
       injectHook("ec" /* ERROR_CAPTURED */, hook, target);
   }
 
-  function createDuplicateChecker() {
-      const cache = Object.create(null);
-      return (type, key) => {
-          if (cache[key]) {
-              warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
+  /**
+  Runtime helper for applying directives to a vnode. Example usage:
+
+  const comp = resolveComponent('comp')
+  const foo = resolveDirective('foo')
+  const bar = resolveDirective('bar')
+
+  return withDirectives(h(comp), [
+    [foo, this.x],
+    [bar, this.y]
+  ])
+  */
+  function validateDirectiveName(name) {
+      if (isBuiltInDirective(name)) {
+          warn$1('Do not use built-in directive ids as custom directive id: ' + name);
+      }
+  }
+  /**
+   * Adds directives to a VNode.
+   */
+  function withDirectives(vnode, directives) {
+      const internalInstance = currentRenderingInstance;
+      if (internalInstance === null) {
+          warn$1(`withDirectives can only be used inside render functions.`);
+          return vnode;
+      }
+      const instance = getExposeProxy(internalInstance) ||
+          internalInstance.proxy;
+      const bindings = vnode.dirs || (vnode.dirs = []);
+      for (let i = 0; i < directives.length; i++) {
+          let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
+          if (isFunction(dir)) {
+              dir = {
+                  mounted: dir,
+                  updated: dir
+              };
           }
-          else {
-              cache[key] = type;
+          if (dir.deep) {
+              traverse(value);
           }
-      };
-  }
-  let shouldCacheAccess = true;
-  function applyOptions(instance) {
-      const options = resolveMergedOptions(instance);
-      const publicThis = instance.proxy;
-      const ctx = instance.ctx;
-      // do not cache property access on public proxy during state initialization
-      shouldCacheAccess = false;
-      // call beforeCreate first before accessing other options since
-      // the hook may mutate resolved options (#2791)
-      if (options.beforeCreate) {
-          callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */);
+          bindings.push({
+              dir,
+              instance,
+              value,
+              oldValue: void 0,
+              arg,
+              modifiers
+          });
       }
-      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);
-              }
+      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) {
+              // disable tracking inside all lifecycle hooks
+              // since they can potentially be called inside effects.
+              pauseTracking();
+              callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [
+                  vnode.el,
+                  binding,
+                  vnode,
+                  prevVNode
+              ]);
+              resetTracking();
           }
       }
-      // options initialization order (to be consistent with Vue 2):
-      // - props (already done outside of this function)
-      // - inject
-      // - methods
-      // - data (deferred since it relies on `this` access)
-      // - computed
-      // - watch (deferred since it relies on `this` access)
-      if (injectOptions) {
-          resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef);
+  }
+
+  const COMPONENTS = 'components';
+  const DIRECTIVES = 'directives';
+  /**
+   * @private
+   */
+  function resolveComponent(name, maybeSelfReference) {
+      return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
+  }
+  const NULL_DYNAMIC_COMPONENT = Symbol();
+  /**
+   * @private
+   */
+  function resolveDynamicComponent(component) {
+      if (isString(component)) {
+          return resolveAsset(COMPONENTS, component, false) || component;
       }
-      if (methods) {
-          for (const key in methods) {
-              const methodHandler = methods[key];
-              if (isFunction(methodHandler)) {
-                  // In dev mode, we use the `createRenderContext` function to define
-                  // methods to the proxy target, and those are read-only but
-                  // reconfigurable, so it needs to be redefined here
-                  {
-                      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?`);
-              }
-          }
+      else {
+          // invalid types will fallthrough to createVNode and raise warning
+          return (component || NULL_DYNAMIC_COMPONENT);
       }
-      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>.`);
+  }
+  /**
+   * @private
+   */
+  function resolveDirective(name) {
+      return resolveAsset(DIRECTIVES, name);
+  }
+  // implementation
+  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
+      const instance = currentRenderingInstance || currentInstance;
+      if (instance) {
+          const Component = instance.type;
+          // explicit self name has highest priority
+          if (type === COMPONENTS) {
+              const selfName = getComponentName(Component);
+              if (selfName &&
+                  (selfName === name ||
+                      selfName === camelize(name) ||
+                      selfName === capitalize(camelize(name)))) {
+                  return Component;
+              }
           }
-          if (!isObject(data)) {
-              warn$1(`data() should return an object.`);
+          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) {
+              // fallback to implicit self-reference
+              return Component;
           }
-          else {
-              instance.data = reactive(data);
-              {
-                  for (const key in data) {
-                      checkDuplicateProperties("Data" /* DATA */, key);
-                      // expose data on ctx during dev
-                      if (key[0] !== '$' && key[0] !== '_') {
-                          Object.defineProperty(ctx, key, {
-                              configurable: true,
-                              enumerable: true,
-                              get: () => data[key],
-                              set: NOOP
-                          });
-                      }
-                  }
-              }
+          if (warnMissing && !res) {
+              const extra = type === COMPONENTS
+                  ? `\nIf 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;
       }
-      // state initialization complete at this point - start caching access
-      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$1({
-                  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(created, instance, "c" /* CREATED */);
+      else {
+          warn$1(`resolve${capitalize(type.slice(0, -1))} ` +
+              `can only be used in render() or setup().`);
       }
-      function registerLifecycleHook(register, hook) {
-          if (isArray(hook)) {
-              hook.forEach(_hook => register(_hook.bind(publicThis)));
-          }
-          else if (hook) {
-              register(hook.bind(publicThis));
+  }
+  function resolve(registry, name) {
+      return (registry &&
+          (registry[name] ||
+              registry[camelize(name)] ||
+              registry[capitalize(camelize(name))]));
+  }
+
+  /**
+   * Actual implementation
+   */
+  function renderList(source, renderItem, cache, index) {
+      let ret;
+      const cached = (cache && cache[index]);
+      if (isArray(source) || isString(source)) {
+          ret = new Array(source.length);
+          for (let i = 0, l = source.length; i < l; i++) {
+              ret[i] = renderItem(source[i], i, undefined, cached && cached[i]);
           }
       }
-      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 (typeof source === 'number') {
+          if (!Number.isInteger(source)) {
+              warn$1(`The v-for range expect an integer value but got ${source}.`);
           }
-          else if (!instance.exposed) {
-              instance.exposed = {};
+          ret = new Array(source);
+          for (let i = 0; i < source; i++) {
+              ret[i] = renderItem(i + 1, i, undefined, cached && cached[i]);
           }
       }
-      // options that are handled when creating the instance but also need to be
-      // applied from mixins
-      if (render && instance.render === NOOP) {
-          instance.render = render;
-      }
-      if (inheritAttrs != null) {
-          instance.inheritAttrs = inheritAttrs;
-      }
-      // asset options.
-      if (components)
-          instance.components = components;
-      if (directives)
-          instance.directives = directives;
-  }
-  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
-      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 /* treat default function as factory */);
-              }
-              else {
-                  injected = inject(opt.from || key);
-              }
+      else if (isObject(source)) {
+          if (source[Symbol.iterator]) {
+              ret = Array.from(source, (item, i) => renderItem(item, i, undefined, cached && cached[i]));
           }
           else {
-              injected = inject(opt);
-          }
-          if (isRef(injected)) {
-              // TODO remove the check in 3.3
-              if (unwrapRef) {
-                  Object.defineProperty(ctx, key, {
-                      enumerable: true,
-                      configurable: true,
-                      get: () => injected.value,
-                      set: v => (injected.value = v)
-                  });
-              }
-              else {
-                  {
-                      warn$1(`injected property "${key}" is a ref and will be auto-unwrapped ` +
-                          `and no longer needs \`.value\` in the next minor release. ` +
-                          `To opt-in to the new behavior now, ` +
-                          `set \`app.config.unwrapInjectedRef = true\` (this config is ` +
-                          `temporary and will not be needed in the future.)`);
-                  }
-                  ctx[key] = injected;
+              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 {
-              ctx[key] = injected;
-          }
-          {
-              checkDuplicateProperties("Inject" /* INJECT */, key);
-          }
       }
-  }
-  function callHook(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) {
-      const 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 {
+          ret = [];
       }
-      else if (isFunction(raw)) {
-          watch(getter, raw.bind(publicThis));
+      if (cache) {
+          cache[index] = ret;
       }
-      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);
+      return ret;
+  }
+
+  /**
+   * Compiler runtime helper for creating dynamic slots object
+   * @private
+   */
+  function createSlots(slots, dynamicSlots) {
+      for (let i = 0; i < dynamicSlots.length; i++) {
+          const slot = dynamicSlots[i];
+          // array of dynamic slot generated by <template v-for="..." #[...]>
+          if (isArray(slot)) {
+              for (let j = 0; j < slot.length; j++) {
+                  slots[slot[j].name] = slot[j].fn;
               }
           }
+          else if (slot) {
+              // conditional single slot generated by <template v-if="..." #foo>
+              slots[slot.name] = slot.fn;
+          }
       }
-      else {
-          warn$1(`Invalid watch option: "${key}"`, raw);
-      }
-  }
+      return slots;
+  }
+
   /**
-   * Resolve merged options and cache it on the component.
-   * This is done only once per-component since the merging does not involve
-   * instances.
+   * Compiler runtime helper for rendering `<slot/>`
+   * @private
    */
-  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;
+  function renderSlot(slots, name, props = {}, 
+  // this is not a user-facing function, so the fallback is always generated by
+  // the compiler and guaranteed to be a function returning an array
+  fallback, noSlotted) {
+      if (currentRenderingInstance.isCE ||
+          (currentRenderingInstance.parent &&
+              isAsyncWrapper(currentRenderingInstance.parent) &&
+              currentRenderingInstance.parent.isCE)) {
+          return createVNode('slot', name === 'default' ? null : { name }, fallback && fallback());
       }
-      else if (!globalMixins.length && !mixins && !extendsOptions) {
-          {
-              resolved = base;
-          }
+      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 = () => [];
       }
-      else {
-          resolved = {};
-          if (globalMixins.length) {
-              globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true));
-          }
-          mergeOptions(resolved, base, optionMergeStrategies);
-      }
-      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: mergeObjectOptions,
-      emits: mergeObjectOptions,
-      // objects
-      methods: mergeObjectOptions,
-      computed: mergeObjectOptions,
-      // lifecycle
-      beforeCreate: mergeAsArray,
-      created: mergeAsArray,
-      beforeMount: mergeAsArray,
-      mounted: mergeAsArray,
-      beforeUpdate: mergeAsArray,
-      updated: mergeAsArray,
-      beforeDestroy: mergeAsArray,
-      beforeUnmount: mergeAsArray,
-      destroyed: mergeAsArray,
-      unmounted: mergeAsArray,
-      activated: mergeAsArray,
-      deactivated: mergeAsArray,
-      errorCaptured: mergeAsArray,
-      serverPrefetch: mergeAsArray,
-      // assets
-      components: mergeObjectOptions,
-      directives: mergeObjectOptions,
-      // watch
-      watch: mergeWatchOptions,
-      // provide / inject
-      provide: mergeDataFn,
-      inject: mergeInject
-  };
-  function mergeDataFn(to, from) {
-      if (!from) {
-          return to;
+      // a compiled slot disables block tracking by default to avoid manual
+      // invocation interfering with template-based block tracking, but in
+      // `renderSlot` we can be sure that it's template-based so we can force
+      // enable it.
+      if (slot && slot._c) {
+          slot._d = false;
       }
-      if (!to) {
-          return from;
+      openBlock();
+      const validSlotContent = slot && ensureValidVNode(slot(props));
+      const rendered = createBlock(Fragment, { key: props.key || `_${name}` }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* STABLE */
+          ? 64 /* STABLE_FRAGMENT */
+          : -2 /* BAIL */);
+      if (!noSlotted && rendered.scopeId) {
+          rendered.slotScopeIds = [rendered.scopeId + '-s'];
       }
-      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;
+      if (slot && slot._c) {
+          slot._d = true;
       }
-      return raw;
-  }
-  function mergeAsArray(to, from) {
-      return to ? [...new Set([].concat(to, from))] : from;
-  }
-  function mergeObjectOptions(to, from) {
-      return to ? extend(extend(Object.create(null), to), from) : from;
+      return rendered;
   }
-  function mergeWatchOptions(to, from) {
-      if (!to)
-          return from;
-      if (!from)
-          return to;
-      const merged = extend(Object.create(null), to);
-      for (const key in from) {
-          merged[key] = mergeAsArray(to[key], from[key]);
-      }
-      return merged;
+  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 initProps(instance, rawProps, isStateful, // result of bitwise flag comparison
-  isSSR = false) {
-      const props = {};
-      const attrs = {};
-      def(attrs, InternalObjectKey, 1);
-      instance.propsDefaults = Object.create(null);
-      setFullProps(instance, rawProps, props, attrs);
-      // ensure all declared prop keys are present
-      for (const key in instance.propsOptions[0]) {
-          if (!(key in props)) {
-              props[key] = undefined;
-          }
-      }
-      // validation
-      {
-          validateProps(rawProps || {}, props, instance);
+  /**
+   * For prefixing keys in v-on="obj" with "on"
+   * @private
+   */
+  function toHandlers(obj) {
+      const ret = {};
+      if (!isObject(obj)) {
+          warn$1(`v-on with no argument expects an object value.`);
+          return ret;
       }
-      if (isStateful) {
-          // stateful
-          instance.props = isSSR ? props : shallowReactive(props);
+      for (const key in obj) {
+          ret[toHandlerKey(key)] = obj[key];
       }
-      else {
-          if (!instance.type.props) {
-              // functional w/ optional props, props === attrs
-              instance.props = attrs;
+      return ret;
+  }
+
+  /**
+   * #2437 In Vue 3, functional components do not have a public instance proxy but
+   * they exist in the internal parent chain. For code that relies on traversing
+   * public $parent chains, skip functional ones and go to the parent instead.
+   */
+  const getPublicInstance = (i) => {
+      if (!i)
+          return null;
+      if (isStatefulComponent(i))
+          return getExposeProxy(i) || i.proxy;
+      return getPublicInstance(i.parent);
+  };
+  const publicPropertiesMap = 
+  // Move PURE marker to new line to workaround compiler discarding it
+  // due to type annotation
+  /*#__PURE__*/ extend(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),
+      $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 PublicInstanceProxyHandlers = {
+      get({ _: instance }, key) {
+          const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
+          // for internal formatters to know that this is a Vue instance
+          if (key === '__isVue') {
+              return true;
           }
-          else {
-              // functional w/ declared props
-              instance.props = props;
+          // prioritize <script setup> bindings during dev.
+          // this allows even properties that start with _ or $ to be used - so that
+          // it aligns with the production behavior where the render fn is inlined and
+          // indeed has access to all declared variables.
+          if (setupState !== EMPTY_OBJ &&
+              setupState.__isScriptSetup &&
+              hasOwn(setupState, key)) {
+              return setupState[key];
           }
-      }
-      instance.attrs = attrs;
-  }
-  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
-      !((instance.type.__hmrId ||
-              (instance.parent && instance.parent.type.__hmrId))) &&
-          (optimized || patchFlag > 0) &&
-          !(patchFlag & 16 /* FULL_PROPS */)) {
-          if (patchFlag & 8 /* PROPS */) {
-              // Compiler-generated props & no keys change, just set the updated
-              // the props.
-              const propsToUpdate = instance.vnode.dynamicProps;
-              for (let i = 0; i < propsToUpdate.length; i++) {
-                  let key = propsToUpdate[i];
-                  // skip if the prop key is a declared emit event listener
-                  if (isEmitListener(instance.emitsOptions, key)) {
-                      continue;
-                  }
-                  // PROPS flag guarantees rawProps to be non-null
-                  const value = rawProps[key];
-                  if (options) {
-                      // attr / props separation was done on init and will be consistent
-                      // in this code path, so just check if attrs have it.
-                      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 /* isAbsent */);
-                      }
-                  }
-                  else {
-                      if (value !== attrs[key]) {
-                          attrs[key] = value;
-                          hasAttrsChanged = true;
-                      }
+          // data / props / ctx
+          // This getter gets called for every property access on the render context
+          // during render and is a major hotspot. The most expensive part of this
+          // is the multiple hasOwn() calls. It's much faster to do a simple property
+          // access on a plain object, so we use an accessCache object (with null
+          // prototype) to memoize what access type a key corresponds to.
+          let normalizedProps;
+          if (key[0] !== '$') {
+              const n = accessCache[key];
+              if (n !== undefined) {
+                  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];
+                      // default: just fallthrough
                   }
               }
-          }
-      }
-      else {
-          // full props update.
-          if (setFullProps(instance, rawProps, props, attrs)) {
-              hasAttrsChanged = true;
-          }
-          // in case of dynamic props, check if we need to delete keys from
-          // the props object
-          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] !== undefined ||
-                              // for kebab-case
-                              rawPrevProps[kebabKey] !== undefined)) {
-                          props[key] = resolvePropValue(options, rawCurrentProps, key, undefined, instance, true /* isAbsent */);
-                      }
-                  }
-                  else {
-                      delete props[key];
-                  }
+              else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+                  accessCache[key] = 1 /* SETUP */;
+                  return setupState[key];
               }
-          }
-          // in the case of functional component w/o props declaration, props and
-          // attrs point to the same object so it should already have been updated.
-          if (attrs !== rawCurrentProps) {
-              for (const key in attrs) {
-                  if (!rawProps ||
-                      (!hasOwn(rawProps, key) &&
-                          (!false ))) {
-                      delete attrs[key];
-                      hasAttrsChanged = true;
-                  }
+              else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+                  accessCache[key] = 2 /* DATA */;
+                  return data[key];
               }
-          }
-      }
-      // trigger updates for $attrs in case it's used in component slots
-      if (hasAttrsChanged) {
-          trigger(instance, "set" /* SET */, '$attrs');
-      }
-      {
-          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) {
-              // key, ref are reserved and never passed down
-              if (isReservedProp(key)) {
-                  continue;
+              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];
               }
-              const value = rawProps[key];
-              // prop option names are camelized during normalization, so to support
-              // kebab -> camel conversion here we need to camelize the 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 (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
+                  accessCache[key] = 4 /* CONTEXT */;
+                  return ctx[key];
               }
-              else if (!isEmitListener(instance.emitsOptions, key)) {
-                  if (!(key in attrs) || value !== attrs[key]) {
-                      attrs[key] = value;
-                      hasAttrsChanged = true;
-                  }
+              else if (shouldCacheAccess) {
+                  accessCache[key] = 0 /* OTHER */;
               }
           }
-      }
-      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');
-          // default values
-          if (hasDefault && value === undefined) {
-              const defaultValue = opt.default;
-              if (opt.type !== Function && isFunction(defaultValue)) {
-                  const { propsDefaults } = instance;
-                  if (key in propsDefaults) {
-                      value = propsDefaults[key];
-                  }
-                  else {
-                      setCurrentInstance(instance);
-                      value = propsDefaults[key] = defaultValue.call(null, props);
-                      unsetCurrentInstance();
-                  }
+          const publicGetter = publicPropertiesMap[key];
+          let cssModule, globalProperties;
+          // public $xxx properties
+          if (publicGetter) {
+              if (key === '$attrs') {
+                  track(instance, "get" /* GET */, key);
+                  markAttrsAccessed();
               }
-              else {
-                  value = defaultValue;
+              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)) {
+              // user may set custom properties to `this` that start with `$`
+              accessCache[key] = 4 /* CONTEXT */;
+              return ctx[key];
+          }
+          else if (
+          // global properties
+          ((globalProperties = appContext.config.globalProperties),
+              hasOwn(globalProperties, key))) {
+              {
+                  return globalProperties[key];
               }
           }
-          // boolean casting
-          if (opt[0 /* shouldCast */]) {
-              if (isAbsent && !hasDefault) {
-                  value = false;
+          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 (opt[1 /* shouldCastTrue */] &&
-                  (value === '' || value === hyphenate(key))) {
-                  value = true;
+              else if (instance === currentRenderingInstance) {
+                  warn$1(`Property ${JSON.stringify(key)} was accessed during render ` +
+                      `but is not defined on instance.`);
               }
           }
-      }
-      return value;
-  }
-  function normalizePropsOptions(comp, appContext, asMixin = false) {
-      const cache = appContext.propsCache;
-      const cached = cache.get(comp);
-      if (cached) {
-          return cached;
-      }
-      const raw = comp.props;
-      const normalized = {};
-      const needCastKeys = [];
-      // apply mixin/extends props
-      let hasExtends = false;
-      if (!isFunction(comp)) {
-          const extendProps = (raw) => {
-              hasExtends = true;
-              const [props, keys] = normalizePropsOptions(raw, appContext, true);
-              extend(normalized, props);
-              if (keys)
-                  needCastKeys.push(...keys);
-          };
-          if (!asMixin && appContext.mixins.length) {
-              appContext.mixins.forEach(extendProps);
+      },
+      set({ _: instance }, key, value) {
+          const { data, setupState, ctx } = instance;
+          if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
+              setupState[key] = value;
+              return true;
           }
-          if (comp.extends) {
-              extendProps(comp.extends);
+          else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
+              data[key] = value;
+              return true;
           }
-          if (comp.mixins) {
-              comp.mixins.forEach(extendProps);
+          else if (hasOwn(instance.props, key)) {
+              warn$1(`Attempting to mutate prop "${key}". Props are readonly.`, instance);
+              return false;
           }
-      }
-      if (!raw && !hasExtends) {
-          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]);
+          if (key[0] === '$' && key.slice(1) in instance) {
+              warn$1(`Attempting to mutate public property "${key}". ` +
+                      `Properties starting with $ are reserved and readonly.`, instance);
+              return false;
+          }
+          else {
+              if (key in instance.appContext.config.globalProperties) {
+                  Object.defineProperty(ctx, key, {
+                      enumerable: true,
+                      configurable: true,
+                      value
+                  });
               }
-              const normalizedKey = camelize(raw[i]);
-              if (validatePropName(normalizedKey)) {
-                  normalized[normalizedKey] = EMPTY_OBJ;
+              else {
+                  ctx[key] = value;
               }
           }
-      }
-      else if (raw) {
-          if (!isObject(raw)) {
-              warn$1(`invalid props options`, raw);
+          return true;
+      },
+      has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
+          let normalizedProps;
+          return (!!accessCache[key] ||
+              (data !== EMPTY_OBJ && hasOwn(data, key)) ||
+              (setupState !== EMPTY_OBJ && hasOwn(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) {
+              // invalidate key cache of a getter based property #5417
+              target._.accessCache[key] = 0;
           }
-          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 } : opt);
-                  if (prop) {
-                      const booleanIndex = getTypeIndex(Boolean, prop.type);
-                      const stringIndex = getTypeIndex(String, prop.type);
-                      prop[0 /* shouldCast */] = booleanIndex > -1;
-                      prop[1 /* shouldCastTrue */] =
-                          stringIndex < 0 || booleanIndex < stringIndex;
-                      // if the prop needs boolean casting or default value
-                      if (booleanIndex > -1 || hasOwn(prop, 'default')) {
-                          needCastKeys.push(normalizedKey);
-                      }
-                  }
-              }
+          else if (hasOwn(descriptor, 'value')) {
+              this.set(target, key, descriptor.value, null);
           }
+          return Reflect.defineProperty(target, key, descriptor);
       }
-      const res = [normalized, needCastKeys];
-      cache.set(comp, res);
-      return res;
-  }
-  function validatePropName(key) {
-      if (key[0] !== '$') {
-          return true;
-      }
-      else {
-          warn$1(`Invalid prop name: "${key}" is a reserved property.`);
-      }
-      return false;
-  }
-  // use function string name to check type constructors
-  // so that it works across vms / iframes.
-  function getType(ctor) {
-      const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
-      return match ? match[1] : ctor === null ? 'null' : '';
-  }
-  function isSameType(a, b) {
-      return getType(a) === getType(b);
+  };
+  {
+      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 getTypeIndex(type, expectedTypes) {
-      if (isArray(expectedTypes)) {
-          return expectedTypes.findIndex(t => isSameType(t, type));
-      }
-      else if (isFunction(expectedTypes)) {
-          return isSameType(expectedTypes, type) ? 0 : -1;
+  const RuntimeCompiledPublicInstanceProxyHandlers = /*#__PURE__*/ extend({}, PublicInstanceProxyHandlers, {
+      get(target, key) {
+          // fast path for unscopables when using `with` block
+          if (key === Symbol.unscopables) {
+              return;
+          }
+          return PublicInstanceProxyHandlers.get(target, key, target);
+      },
+      has(_, key) {
+          const has = key[0] !== '_' && !isGloballyWhitelisted(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;
       }
-      return -1;
+  });
+  // dev only
+  // In dev mode, the proxy target exposes the same properties as seen on `this`
+  // for easier console inspection. In prod mode it will be an empty object so
+  // these properties definitions can be skipped.
+  function createDevRenderContext(instance) {
+      const target = {};
+      // expose internal instance for proxy handlers
+      Object.defineProperty(target, `_`, {
+          configurable: true,
+          enumerable: false,
+          get: () => instance
+      });
+      // expose public properties
+      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;
   }
-  /**
-   * dev only
-   */
-  function validateProps(rawProps, props, instance) {
-      const resolvedValues = toRaw(props);
-      const options = instance.propsOptions[0];
-      for (const key in options) {
-          let opt = options[key];
-          if (opt == null)
-              continue;
-          validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key)));
+  // dev only
+  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
+              });
+          });
       }
   }
-  /**
-   * dev only
-   */
-  function validateProp(name, value, prop, isAbsent) {
-      const { type, required, validator } = prop;
-      // required!
-      if (required && isAbsent) {
-          warn$1('Missing required prop: "' + name + '"');
-          return;
-      }
-      // missing but optional
-      if (value == null && !prop.required) {
-          return;
-      }
-      // type check
-      if (type != null && type !== true) {
-          let isValid = false;
-          const types = isArray(type) ? type : [type];
-          const expectedTypes = [];
-          // value is valid as long as one of the specified types match
-          for (let i = 0; i < types.length && !isValid; i++) {
-              const { valid, expectedType } = assertType(value, types[i]);
-              expectedTypes.push(expectedType || '');
-              isValid = valid;
+  // dev only
+  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
+              });
           }
-          if (!isValid) {
-              warn$1(getInvalidTypeMessage(name, value, expectedTypes));
-              return;
+      });
+  }
+
+  function createDuplicateChecker() {
+      const cache = Object.create(null);
+      return (type, key) => {
+          if (cache[key]) {
+              warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
           }
-      }
-      // custom validator
-      if (validator && !validator(value)) {
-          warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
-      }
-  }
-  const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol,BigInt');
-  /**
-   * dev only
-   */
-  function assertType(value, type) {
-      let valid;
-      const expectedType = getType(type);
-      if (isSimpleType(expectedType)) {
-          const t = typeof value;
-          valid = t === expectedType.toLowerCase();
-          // for primitive wrapper objects
-          if (!valid && t === 'object') {
-              valid = value instanceof type;
+          else {
+              cache[key] = type;
           }
-      }
-      else if (expectedType === 'Object') {
-          valid = isObject(value);
-      }
-      else if (expectedType === 'Array') {
-          valid = isArray(value);
-      }
-      else if (expectedType === 'null') {
-          valid = value === null;
-      }
-      else {
-          valid = value instanceof type;
-      }
-      return {
-          valid,
-          expectedType
       };
   }
-  /**
-   * dev only
-   */
-  function getInvalidTypeMessage(name, value, expectedTypes) {
-      let message = `Invalid prop: type check failed for prop "${name}".` +
-          ` Expected ${expectedTypes.map(capitalize).join(' | ')}`;
-      const expectedType = expectedTypes[0];
-      const receivedType = toRawType(value);
-      const expectedValue = styleValue(value, expectedType);
-      const receivedValue = styleValue(value, receivedType);
-      // check if we need to specify expected value
-      if (expectedTypes.length === 1 &&
-          isExplicable(expectedType) &&
-          !isBoolean(expectedType, receivedType)) {
-          message += ` with value ${expectedValue}`;
-      }
-      message += `, got ${receivedType} `;
-      // check if we need to specify received value
-      if (isExplicable(receivedType)) {
-          message += `with value ${receivedValue}.`;
+  let shouldCacheAccess = true;
+  function applyOptions(instance) {
+      const options = resolveMergedOptions(instance);
+      const publicThis = instance.proxy;
+      const ctx = instance.ctx;
+      // do not cache property access on public proxy during state initialization
+      shouldCacheAccess = false;
+      // call beforeCreate first before accessing other options since
+      // the hook may mutate resolved options (#2791)
+      if (options.beforeCreate) {
+          callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */);
       }
-      return message;
-  }
-  /**
-   * dev only
-   */
-  function styleValue(value, type) {
-      if (type === 'String') {
-          return `"${value}"`;
-      }
-      else if (type === 'Number') {
-          return `${Number(value)}`;
+      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);
+              }
+          }
       }
-      else {
-          return `${value}`;
+      // options initialization order (to be consistent with Vue 2):
+      // - props (already done outside of this function)
+      // - inject
+      // - methods
+      // - data (deferred since it relies on `this` access)
+      // - computed
+      // - watch (deferred since it relies on `this` access)
+      if (injectOptions) {
+          resolveInjections(injectOptions, ctx, checkDuplicateProperties, instance.appContext.config.unwrapInjectedRef);
       }
-  }
-  /**
-   * dev only
-   */
-  function isExplicable(type) {
-      const explicitTypes = ['string', 'number', 'boolean'];
-      return explicitTypes.some(elem => type.toLowerCase() === elem);
-  }
-  /**
-   * dev only
-   */
-  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) => {
-      const normalized = withCtx((...args) => {
-          if (currentInstance) {
-              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.`);
+      if (methods) {
+          for (const key in methods) {
+              const methodHandler = methods[key];
+              if (isFunction(methodHandler)) {
+                  // In dev mode, we use the `createRenderContext` function to define
+                  // methods to the proxy target, and those are read-only but
+                  // reconfigurable, so it needs to be redefined here
+                  {
+                      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?`);
               }
-              const normalized = normalizeSlotValue(value);
-              slots[key] = () => normalized;
           }
       }
-  };
-  const normalizeVNodeSlots = (instance, children) => {
-      if (!isKeepAlive(instance.vnode) &&
-          !(false )) {
-          warn$1(`Non-function value encountered for default slot. ` +
-              `Prefer function slots for better performance.`);
-      }
-      const normalized = normalizeSlotValue(children);
-      instance.slots.default = () => normalized;
-  };
-  const initSlots = (instance, children) => {
-      if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
-          const type = children._;
-          if (type) {
-              // users can get the shallow readonly version of the slots object through `this.$slots`,
-              // we should avoid the proxy object polluting the slots of the internal instance
-              instance.slots = toRaw(children);
-              // make compiler marker non-enumerable
-              def(children, '_', type);
+      if (dataOptions) {
+          if (!isFunction(dataOptions)) {
+              warn$1(`The data option must be a function. ` +
+                  `Plain object usage is no longer supported.`);
           }
-          else {
-              normalizeObjectSlots(children, (instance.slots = {}));
+          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>.`);
           }
-      }
-      else {
-          instance.slots = {};
-          if (children) {
-              normalizeVNodeSlots(instance, children);
+          if (!isObject(data)) {
+              warn$1(`data() should return an object.`);
           }
-      }
-      def(instance.slots, InternalObjectKey, 1);
-  };
-  const updateSlots = (instance, children, optimized) => {
-      const { vnode, slots } = instance;
-      let needDeletionCheck = true;
-      let deletionComparisonTarget = EMPTY_OBJ;
-      if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
-          const type = children._;
-          if (type) {
-              // compiled slots.
-              if (isHmrUpdating) {
-                  // Parent was HMR updated so slot content may have changed.
-                  // force update slots and mark instance for hmr as well
-                  extend(slots, children);
+          else {
+              instance.data = reactive(data);
+              {
+                  for (const key in data) {
+                      checkDuplicateProperties("Data" /* DATA */, key);
+                      // expose data on ctx during dev
+                      if (!isReservedPrefix(key[0])) {
+                          Object.defineProperty(ctx, key, {
+                              configurable: true,
+                              enumerable: true,
+                              get: () => data[key],
+                              set: NOOP
+                          });
+                      }
+                  }
               }
-              else if (optimized && type === 1 /* STABLE */) {
-                  // compiled AND stable.
-                  // no need to update, and skip stale slots removal.
-                  needDeletionCheck = false;
+          }
+      }
+      // state initialization complete at this point - start caching access
+      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.`);
               }
-              else {
-                  // compiled but dynamic (v-if/v-for on slots) - update slots, but skip
-                  // normalization.
-                  extend(slots, children);
-                  // #2893
-                  // when rendering the optimized slots by manually written render function,
-                  // we need to delete the `slots._` flag if necessary to make subsequent updates reliable,
-                  // i.e. let the `renderSlot` create the bailed Fragment
-                  if (!optimized && type === 1 /* STABLE */) {
-                      delete slots._;
-                  }
+              const set = !isFunction(opt) && isFunction(opt.set)
+                  ? opt.set.bind(publicThis)
+                  : () => {
+                          warn$1(`Write operation failed: computed property "${key}" is readonly.`);
+                      }
+                      ;
+              const c = computed$1({
+                  get,
+                  set
+              });
+              Object.defineProperty(ctx, key, {
+                  enumerable: true,
+                  configurable: true,
+                  get: () => c.value,
+                  set: v => (c.value = v)
+              });
+              {
+                  checkDuplicateProperties("Computed" /* COMPUTED */, key);
               }
           }
-          else {
-              needDeletionCheck = !children.$stable;
-              normalizeObjectSlots(children, slots);
+      }
+      if (watchOptions) {
+          for (const key in watchOptions) {
+              createWatcher(watchOptions[key], ctx, publicThis, key);
           }
-          deletionComparisonTarget = children;
       }
-      else if (children) {
-          // non slot object children (direct value) passed to a component
-          normalizeVNodeSlots(instance, children);
-          deletionComparisonTarget = { default: 1 };
+      if (provideOptions) {
+          const provides = isFunction(provideOptions)
+              ? provideOptions.call(publicThis)
+              : provideOptions;
+          Reflect.ownKeys(provides).forEach(key => {
+              provide(key, provides[key]);
+          });
       }
-      // delete stale slots
-      if (needDeletionCheck) {
-          for (const key in slots) {
-              if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
-                  delete slots[key];
-              }
+      if (created) {
+          callHook(created, instance, "c" /* CREATED */);
+      }
+      function registerLifecycleHook(register, hook) {
+          if (isArray(hook)) {
+              hook.forEach(_hook => register(_hook.bind(publicThis)));
+          }
+          else if (hook) {
+              register(hook.bind(publicThis));
           }
       }
-  };
-
-  /**
-  Runtime helper for applying directives to a vnode. Example usage:
-
-  const comp = resolveComponent('comp')
-  const foo = resolveDirective('foo')
-  const bar = resolveDirective('bar')
-
-  return withDirectives(h(comp), [
-    [foo, this.x],
-    [bar, this.y]
-  ])
-  */
-  function validateDirectiveName(name) {
-      if (isBuiltInDirective(name)) {
-          warn$1('Do not use built-in directive ids as custom directive id: ' + name);
+      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 = {};
+          }
+      }
+      // options that are handled when creating the instance but also need to be
+      // applied from mixins
+      if (render && instance.render === NOOP) {
+          instance.render = render;
+      }
+      if (inheritAttrs != null) {
+          instance.inheritAttrs = inheritAttrs;
       }
+      // asset options.
+      if (components)
+          instance.components = components;
+      if (directives)
+          instance.directives = directives;
   }
-  /**
-   * Adds directives to a VNode.
-   */
-  function withDirectives(vnode, directives) {
-      const internalInstance = currentRenderingInstance;
-      if (internalInstance === null) {
-          warn$1(`withDirectives can only be used inside render functions.`);
-          return vnode;
+  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
+      if (isArray(injectOptions)) {
+          injectOptions = normalizeInject(injectOptions);
       }
-      const instance = getExposeProxy(internalInstance) ||
-          internalInstance.proxy;
-      const bindings = vnode.dirs || (vnode.dirs = []);
-      for (let i = 0; i < directives.length; i++) {
-          let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
-          if (isFunction(dir)) {
-              dir = {
-                  mounted: dir,
-                  updated: dir
-              };
+      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 /* treat default function as factory */);
+              }
+              else {
+                  injected = inject(opt.from || key);
+              }
           }
-          if (dir.deep) {
-              traverse(value);
+          else {
+              injected = inject(opt);
+          }
+          if (isRef(injected)) {
+              // TODO remove the check in 3.3
+              if (unwrapRef) {
+                  Object.defineProperty(ctx, key, {
+                      enumerable: true,
+                      configurable: true,
+                      get: () => injected.value,
+                      set: v => (injected.value = v)
+                  });
+              }
+              else {
+                  {
+                      warn$1(`injected property "${key}" is a ref and will be auto-unwrapped ` +
+                          `and no longer needs \`.value\` in the next minor release. ` +
+                          `To opt-in to the new behavior now, ` +
+                          `set \`app.config.unwrapInjectedRef = true\` (this config is ` +
+                          `temporary and will not be needed in the future.)`);
+                  }
+                  ctx[key] = injected;
+              }
+          }
+          else {
+              ctx[key] = injected;
+          }
+          {
+              checkDuplicateProperties("Inject" /* INJECT */, key);
           }
-          bindings.push({
-              dir,
-              instance,
-              value,
-              oldValue: void 0,
-              arg,
-              modifiers
-          });
       }
-      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;
+  function callHook(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) {
+      const getter = key.includes('.')
+          ? createPathGetter(publicThis, key)
+          : () => publicThis[key];
+      if (isString(raw)) {
+          const handler = ctx[raw];
+          if (isFunction(handler)) {
+              watch(getter, handler);
           }
-          let hook = binding.dir[name];
-          if (hook) {
-              // disable tracking inside all lifecycle hooks
-              // since they can potentially be called inside effects.
-              pauseTracking();
-              callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [
-                  vnode.el,
-                  binding,
-                  vnode,
-                  prevVNode
-              ]);
-              resetTracking();
+          else {
+              warn$1(`Invalid watch handler specified by key "${raw}"`, handler);
           }
       }
-  }
-
-  function createAppContext() {
-      return {
-          app: null,
-          config: {
-              isNativeTag: NO,
-              performance: false,
-              globalProperties: {},
-              optionMergeStrategies: {},
-              errorHandler: undefined,
-              warnHandler: undefined,
-              compilerOptions: {}
-          },
-          mixins: [],
-          components: {},
-          directives: {},
-          provides: Object.create(null),
-          optionsCache: new WeakMap(),
-          propsCache: new WeakMap(),
-          emitsCache: new WeakMap()
-      };
+      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);
+      }
   }
-  let uid = 0;
-  function createAppAPI(render, hydrate) {
-      return function createApp(rootComponent, rootProps = null) {
-          if (!isFunction(rootComponent)) {
-              rootComponent = Object.assign({}, rootComponent);
+  /**
+   * Resolve merged options and cache it on the component.
+   * This is done only once per-component since the merging does not involve
+   * instances.
+   */
+  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;
           }
-          if (rootProps != null && !isObject(rootProps)) {
-              warn$1(`root props passed to app.mount() must be an object.`);
-              rootProps = null;
+      }
+      else {
+          resolved = {};
+          if (globalMixins.length) {
+              globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true));
           }
-          const context = createAppContext();
-          const installedPlugins = new Set();
-          let isMounted = false;
-          const app = (context.app = {
-              _uid: uid++,
-              _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)) {
+          mergeOptions(resolved, base, optionMergeStrategies);
+      }
+      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: mergeObjectOptions,
+      emits: mergeObjectOptions,
+      // objects
+      methods: mergeObjectOptions,
+      computed: mergeObjectOptions,
+      // lifecycle
+      beforeCreate: mergeAsArray,
+      created: mergeAsArray,
+      beforeMount: mergeAsArray,
+      mounted: mergeAsArray,
+      beforeUpdate: mergeAsArray,
+      updated: mergeAsArray,
+      beforeDestroy: mergeAsArray,
+      beforeUnmount: mergeAsArray,
+      destroyed: mergeAsArray,
+      unmounted: mergeAsArray,
+      activated: mergeAsArray,
+      deactivated: mergeAsArray,
+      errorCaptured: mergeAsArray,
+      serverPrefetch: mergeAsArray,
+      // 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(to, from) {
+      return to ? [...new Set([].concat(to, from))] : from;
+  }
+  function mergeObjectOptions(to, from) {
+      return to ? extend(extend(Object.create(null), to), from) : from;
+  }
+  function mergeWatchOptions(to, from) {
+      if (!to)
+          return from;
+      if (!from)
+          return to;
+      const merged = extend(Object.create(null), to);
+      for (const key in from) {
+          merged[key] = mergeAsArray(to[key], from[key]);
+      }
+      return merged;
+  }
+
+  function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison
+  isSSR = false) {
+      const props = {};
+      const attrs = {};
+      def(attrs, InternalObjectKey, 1);
+      instance.propsDefaults = Object.create(null);
+      setFullProps(instance, rawProps, props, attrs);
+      // ensure all declared prop keys are present
+      for (const key in instance.propsOptions[0]) {
+          if (!(key in props)) {
+              props[key] = undefined;
+          }
+      }
+      // validation
+      {
+          validateProps(rawProps || {}, props, instance);
+      }
+      if (isStateful) {
+          // stateful
+          instance.props = isSSR ? props : shallowReactive(props);
+      }
+      else {
+          if (!instance.type.props) {
+              // functional w/ optional props, props === attrs
+              instance.props = attrs;
+          }
+          else {
+              // functional w/ declared props
+              instance.props = props;
+          }
+      }
+      instance.attrs = attrs;
+  }
+  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
+      !((instance.type.__hmrId ||
+              (instance.parent && instance.parent.type.__hmrId))) &&
+          (optimized || patchFlag > 0) &&
+          !(patchFlag & 16 /* FULL_PROPS */)) {
+          if (patchFlag & 8 /* PROPS */) {
+              // Compiler-generated props & no keys change, just set the updated
+              // the props.
+              const propsToUpdate = instance.vnode.dynamicProps;
+              for (let i = 0; i < propsToUpdate.length; i++) {
+                  let key = propsToUpdate[i];
+                  // skip if the prop key is a declared emit event listener
+                  if (isEmitListener(instance.emitsOptions, key)) {
+                      continue;
+                  }
+                  // PROPS flag guarantees rawProps to be non-null
+                  const value = rawProps[key];
+                  if (options) {
+                      // attr / props separation was done on init and will be consistent
+                      // in this code path, so just check if attrs have it.
+                      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 /* isAbsent */);
+                      }
+                  }
+                  else {
+                      if (value !== attrs[key]) {
+                          attrs[key] = value;
+                          hasAttrsChanged = true;
+                      }
+                  }
+              }
+          }
+      }
+      else {
+          // full props update.
+          if (setFullProps(instance, rawProps, props, attrs)) {
+              hasAttrsChanged = true;
+          }
+          // in case of dynamic props, check if we need to delete keys from
+          // the props object
+          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] !== undefined ||
+                              // for kebab-case
+                              rawPrevProps[kebabKey] !== undefined)) {
+                          props[key] = resolvePropValue(options, rawCurrentProps, key, undefined, instance, true /* isAbsent */);
+                      }
+                  }
+                  else {
+                      delete props[key];
+                  }
+              }
+          }
+          // in the case of functional component w/o props declaration, props and
+          // attrs point to the same object so it should already have been updated.
+          if (attrs !== rawCurrentProps) {
+              for (const key in attrs) {
+                  if (!rawProps ||
+                      (!hasOwn(rawProps, key) &&
+                          (!false ))) {
+                      delete attrs[key];
+                      hasAttrsChanged = true;
+                  }
+              }
+          }
+      }
+      // trigger updates for $attrs in case it's used in component slots
+      if (hasAttrsChanged) {
+          trigger(instance, "set" /* SET */, '$attrs');
+      }
+      {
+          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) {
+              // key, ref are reserved and never passed down
+              if (isReservedProp(key)) {
+                  continue;
+              }
+              const value = rawProps[key];
+              // prop option names are camelized during normalization, so to support
+              // kebab -> camel conversion here we need to camelize the 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');
+          // default values
+          if (hasDefault && value === undefined) {
+              const defaultValue = opt.default;
+              if (opt.type !== Function && isFunction(defaultValue)) {
+                  const { propsDefaults } = instance;
+                  if (key in propsDefaults) {
+                      value = propsDefaults[key];
+                  }
+                  else {
+                      setCurrentInstance(instance);
+                      value = propsDefaults[key] = defaultValue.call(null, props);
+                      unsetCurrentInstance();
+                  }
+              }
+              else {
+                  value = defaultValue;
+              }
+          }
+          // boolean casting
+          if (opt[0 /* shouldCast */]) {
+              if (isAbsent && !hasDefault) {
+                  value = false;
+              }
+              else if (opt[1 /* shouldCastTrue */] &&
+                  (value === '' || value === hyphenate(key))) {
+                  value = true;
+              }
+          }
+      }
+      return value;
+  }
+  function normalizePropsOptions(comp, appContext, asMixin = false) {
+      const cache = appContext.propsCache;
+      const cached = cache.get(comp);
+      if (cached) {
+          return cached;
+      }
+      const raw = comp.props;
+      const normalized = {};
+      const needCastKeys = [];
+      // apply mixin/extends props
+      let hasExtends = false;
+      if (!isFunction(comp)) {
+          const extendProps = (raw) => {
+              hasExtends = true;
+              const [props, keys] = normalizePropsOptions(raw, 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) {
+          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 } : opt);
+                  if (prop) {
+                      const booleanIndex = getTypeIndex(Boolean, prop.type);
+                      const stringIndex = getTypeIndex(String, prop.type);
+                      prop[0 /* shouldCast */] = booleanIndex > -1;
+                      prop[1 /* shouldCastTrue */] =
+                          stringIndex < 0 || booleanIndex < stringIndex;
+                      // if the prop needs boolean casting or default value
+                      if (booleanIndex > -1 || hasOwn(prop, 'default')) {
+                          needCastKeys.push(normalizedKey);
+                      }
+                  }
+              }
+          }
+      }
+      const res = [normalized, needCastKeys];
+      cache.set(comp, res);
+      return res;
+  }
+  function validatePropName(key) {
+      if (key[0] !== '$') {
+          return true;
+      }
+      else {
+          warn$1(`Invalid prop name: "${key}" is a reserved property.`);
+      }
+      return false;
+  }
+  // use function string name to check type constructors
+  // so that it works across vms / iframes.
+  function getType(ctor) {
+      const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
+      return match ? match[1] : ctor === null ? 'null' : '';
+  }
+  function isSameType(a, b) {
+      return getType(a) === getType(b);
+  }
+  function getTypeIndex(type, expectedTypes) {
+      if (isArray(expectedTypes)) {
+          return expectedTypes.findIndex(t => isSameType(t, type));
+      }
+      else if (isFunction(expectedTypes)) {
+          return isSameType(expectedTypes, type) ? 0 : -1;
+      }
+      return -1;
+  }
+  /**
+   * dev only
+   */
+  function validateProps(rawProps, props, instance) {
+      const resolvedValues = toRaw(props);
+      const options = instance.propsOptions[0];
+      for (const key in options) {
+          let opt = options[key];
+          if (opt == null)
+              continue;
+          validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key)));
+      }
+  }
+  /**
+   * dev only
+   */
+  function validateProp(name, value, prop, isAbsent) {
+      const { type, required, validator } = prop;
+      // required!
+      if (required && isAbsent) {
+          warn$1('Missing required prop: "' + name + '"');
+          return;
+      }
+      // missing but optional
+      if (value == null && !prop.required) {
+          return;
+      }
+      // type check
+      if (type != null && type !== true) {
+          let isValid = false;
+          const types = isArray(type) ? type : [type];
+          const expectedTypes = [];
+          // value is valid as long as one of the specified types match
+          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;
+          }
+      }
+      // custom validator
+      if (validator && !validator(value)) {
+          warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
+      }
+  }
+  const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol,BigInt');
+  /**
+   * dev only
+   */
+  function assertType(value, type) {
+      let valid;
+      const expectedType = getType(type);
+      if (isSimpleType(expectedType)) {
+          const t = typeof value;
+          valid = t === expectedType.toLowerCase();
+          // for primitive wrapper objects
+          if (!valid && t === 'object') {
+              valid = value instanceof type;
+          }
+      }
+      else if (expectedType === 'Object') {
+          valid = isObject(value);
+      }
+      else if (expectedType === 'Array') {
+          valid = isArray(value);
+      }
+      else if (expectedType === 'null') {
+          valid = value === null;
+      }
+      else {
+          valid = value instanceof type;
+      }
+      return {
+          valid,
+          expectedType
+      };
+  }
+  /**
+   * dev only
+   */
+  function getInvalidTypeMessage(name, value, expectedTypes) {
+      let message = `Invalid prop: type check failed for prop "${name}".` +
+          ` Expected ${expectedTypes.map(capitalize).join(' | ')}`;
+      const expectedType = expectedTypes[0];
+      const receivedType = toRawType(value);
+      const expectedValue = styleValue(value, expectedType);
+      const receivedValue = styleValue(value, receivedType);
+      // check if we need to specify expected value
+      if (expectedTypes.length === 1 &&
+          isExplicable(expectedType) &&
+          !isBoolean(expectedType, receivedType)) {
+          message += ` with value ${expectedValue}`;
+      }
+      message += `, got ${receivedType} `;
+      // check if we need to specify received value
+      if (isExplicable(receivedType)) {
+          message += `with value ${receivedValue}.`;
+      }
+      return message;
+  }
+  /**
+   * dev only
+   */
+  function styleValue(value, type) {
+      if (type === 'String') {
+          return `"${value}"`;
+      }
+      else if (type === 'Number') {
+          return `${Number(value)}`;
+      }
+      else {
+          return `${value}`;
+      }
+  }
+  /**
+   * dev only
+   */
+  function isExplicable(type) {
+      const explicitTypes = ['string', 'number', 'boolean'];
+      return explicitTypes.some(elem => type.toLowerCase() === elem);
+  }
+  /**
+   * dev only
+   */
+  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) {
+          // already normalized - #5353
+          return rawSlot;
+      }
+      const normalized = withCtx((...args) => {
+          if (currentInstance) {
+              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) &&
+          !(false )) {
+          warn$1(`Non-function value encountered for default slot. ` +
+              `Prefer function slots for better performance.`);
+      }
+      const normalized = normalizeSlotValue(children);
+      instance.slots.default = () => normalized;
+  };
+  const initSlots = (instance, children) => {
+      if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
+          const type = children._;
+          if (type) {
+              // users can get the shallow readonly version of the slots object through `this.$slots`,
+              // we should avoid the proxy object polluting the slots of the internal instance
+              instance.slots = toRaw(children);
+              // make compiler marker non-enumerable
+              def(children, '_', type);
+          }
+          else {
+              normalizeObjectSlots(children, (instance.slots = {}));
+          }
+      }
+      else {
+          instance.slots = {};
+          if (children) {
+              normalizeVNodeSlots(instance, children);
+          }
+      }
+      def(instance.slots, InternalObjectKey, 1);
+  };
+  const updateSlots = (instance, children, optimized) => {
+      const { vnode, slots } = instance;
+      let needDeletionCheck = true;
+      let deletionComparisonTarget = EMPTY_OBJ;
+      if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
+          const type = children._;
+          if (type) {
+              // compiled slots.
+              if (isHmrUpdating) {
+                  // Parent was HMR updated so slot content may have changed.
+                  // force update slots and mark instance for hmr as well
+                  extend(slots, children);
+              }
+              else if (optimized && type === 1 /* STABLE */) {
+                  // compiled AND stable.
+                  // no need to update, and skip stale slots removal.
+                  needDeletionCheck = false;
+              }
+              else {
+                  // compiled but dynamic (v-if/v-for on slots) - update slots, but skip
+                  // normalization.
+                  extend(slots, children);
+                  // #2893
+                  // when rendering the optimized slots by manually written render function,
+                  // we need to delete the `slots._` flag if necessary to make subsequent updates reliable,
+                  // i.e. let the `renderSlot` create the bailed Fragment
+                  if (!optimized && type === 1 /* STABLE */) {
+                      delete slots._;
+                  }
+              }
+          }
+          else {
+              needDeletionCheck = !children.$stable;
+              normalizeObjectSlots(children, slots);
+          }
+          deletionComparisonTarget = children;
+      }
+      else if (children) {
+          // non slot object children (direct value) passed to a component
+          normalizeVNodeSlots(instance, children);
+          deletionComparisonTarget = { default: 1 };
+      }
+      // delete stale slots
+      if (needDeletionCheck) {
+          for (const key in slots) {
+              if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
+                  delete slots[key];
+              }
+          }
+      }
+  };
+
+  function createAppContext() {
+      return {
+          app: null,
+          config: {
+              isNativeTag: NO,
+              performance: false,
+              globalProperties: {},
+              optionMergeStrategies: {},
+              errorHandler: undefined,
+              warnHandler: undefined,
+              compilerOptions: {}
+          },
+          mixins: [],
+          components: {},
+          directives: {},
+          provides: Object.create(null),
+          optionsCache: new WeakMap(),
+          propsCache: new WeakMap(),
+          emitsCache: new WeakMap()
+      };
+  }
+  let uid = 0;
+  function createAppAPI(render, hydrate) {
+      return function createApp(rootComponent, rootProps = null) {
+          if (!isFunction(rootComponent)) {
+              rootComponent = Object.assign({}, 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 = new Set();
+          let isMounted = false;
+          const app = (context.app = {
+              _uid: uid++,
+              _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);
                   }
@@ -5399,6 +5903,12 @@ var Vue = (function (exports) {
               },
               mount(rootContainer, isHydrate, isSVG) {
                   if (!isMounted) {
+                      // #5571
+                      if (rootContainer.__vue_app__) {
+                          warn$1(`There is already an app instance mounted on the host container.\n` +
+                              ` 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 = createVNode(rootComponent, rootProps);
                       // store app context on the root VNode.
                       // this will be set on the root instance on initial mount.
@@ -5449,8 +5959,6 @@ var Vue = (function (exports) {
                       warn$1(`App already provides property with key "${String(key)}". ` +
                           `It will be overwritten with the new value.`);
                   }
-                  // TypeScript doesn't allow symbols as index type
-                  // https://github.com/Microsoft/TypeScript/issues/24587
                   context.provides[key] = value;
                   return app;
               }
@@ -5567,7 +6075,7 @@ var Vue = (function (exports) {
   // Hydration also depends on some renderer internal logic which needs to be
   // passed in via arguments.
   function createHydrationFunctions(rendererInternals) {
-      const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = 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. ` +
@@ -5587,14 +6095,26 @@ var Vue = (function (exports) {
       const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => {
           const isFragmentStart = isComment(node) && node.data === '[';
           const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart);
-          const { type, ref, shapeFlag } = vnode;
+          const { type, ref, shapeFlag, patchFlag } = vnode;
           const domType = node.nodeType;
           vnode.el = node;
+          if (patchFlag === -2 /* BAIL */) {
+              optimized = false;
+              vnode.dynamicChildren = null;
+          }
           let nextNode = null;
           switch (type) {
               case Text:
                   if (domType !== 3 /* TEXT */) {
-                      nextNode = onMismatch();
+                      // #5728 empty text node inside a slot can cause hydration failure
+                      // because the server rendered HTML won't contain a text node
+                      if (vnode.children === '') {
+                          insert((vnode.el = createText('')), parentNode(node), node);
+                          nextNode = node;
+                      }
+                      else {
+                          nextNode = onMismatch();
+                      }
                   }
                   else {
                       if (node.data !== vnode.children) {
@@ -5668,6 +6188,12 @@ var Vue = (function (exports) {
                       nextNode = isFragmentStart
                           ? locateClosingAsyncAnchor(node)
                           : nextSibling(node);
+                      // #4293 teleport as component root
+                      if (nextNode &&
+                          isComment(nextNode) &&
+                          nextNode.data === 'teleport end') {
+                          nextNode = nextSibling(nextNode);
+                      }
                       // #3787
                       // if component is async, it may get moved / unmounted before its
                       // inner component is loaded, so we need to give it a placeholder
@@ -6331,8 +6857,9 @@ var Vue = (function (exports) {
           const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText(''));
           const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));
           let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
-          if (isHmrUpdating) {
-              // HMR updated, force full diff
+          if (// #5523 dev root fragment may inherit directives
+              (isHmrUpdating || patchFlag & 2048 /* DEV_ROOT_FRAGMENT */)) {
+              // HMR updated / Dev root fragment (w/ comments), force full diff
               patchFlag = 0;
               optimized = false;
               dynamicChildren = null;
@@ -6466,7 +6993,6 @@ var Vue = (function (exports) {
           }
           else {
               // no update needed. just copy over properties
-              n2.component = n1.component;
               n2.el = n1.el;
               instance.vnode = n2;
           }
@@ -6549,7 +7075,10 @@ var Vue = (function (exports) {
                   // activated hook for keep-alive roots.
                   // #1742 activated hook must be accessed after first render
                   // since the hook may be injected by a child keep-alive
-                  if (initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
+                  if (initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ ||
+                      (parent &&
+                          isAsyncWrapper(parent.vnode) &&
+                          parent.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */)) {
                       instance.a && queuePostRenderEffect(instance.a, parentSuspense);
                   }
                   instance.isMounted = true;
@@ -6632,9 +7161,9 @@ var Vue = (function (exports) {
               }
           };
           // create reactive effect for rendering
-          const effect = (instance.effect = new ReactiveEffect(componentUpdateFn, () => queueJob(instance.update), instance.scope // track it in component's effect scope
+          const effect = (instance.effect = new ReactiveEffect(componentUpdateFn, () => queueJob(update), instance.scope // track it in component's effect scope
           ));
-          const update = (instance.update = effect.run.bind(effect));
+          const update = (instance.update = () => effect.run());
           update.id = instance.uid;
           // allowRecurse
           // #1801, #2043 component render effects should allow recursive updates
@@ -6646,7 +7175,6 @@ var Vue = (function (exports) {
               effect.onTrigger = instance.rtg
                   ? e => invokeArrayFns(instance.rtg, e)
                   : void 0;
-              // @ts-ignore (for scheduler)
               update.ownerInstance = instance;
           }
           update();
@@ -7431,96 +7959,36 @@ var Vue = (function (exports) {
           // if multiple teleports rendered to the same target element, we need to
           // pick up from where the last teleport finished instead of the first node
           const targetNode = target._lpa || target.firstChild;
-          if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
-              if (isTeleportDisabled(vnode.props)) {
-                  vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, slotScopeIds, optimized);
-                  vnode.targetAnchor = targetNode;
-              }
-              else {
-                  vnode.anchor = nextSibling(node);
-                  vnode.targetAnchor = hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
-              }
-              target._lpa =
-                  vnode.targetAnchor && nextSibling(vnode.targetAnchor);
-          }
-      }
-      return vnode.anchor && nextSibling(vnode.anchor);
-  }
-  // Force-casted public typing for h and TSX props inference
-  const Teleport = TeleportImpl;
-
-  const COMPONENTS = 'components';
-  const DIRECTIVES = 'directives';
-  /**
-   * @private
-   */
-  function resolveComponent(name, maybeSelfReference) {
-      return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
-  }
-  const NULL_DYNAMIC_COMPONENT = Symbol();
-  /**
-   * @private
-   */
-  function resolveDynamicComponent(component) {
-      if (isString(component)) {
-          return resolveAsset(COMPONENTS, component, false) || component;
-      }
-      else {
-          // invalid types will fallthrough to createVNode and raise warning
-          return (component || NULL_DYNAMIC_COMPONENT);
-      }
-  }
-  /**
-   * @private
-   */
-  function resolveDirective(name) {
-      return resolveAsset(DIRECTIVES, name);
-  }
-  // implementation
-  function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
-      const instance = currentRenderingInstance || currentInstance;
-      if (instance) {
-          const Component = instance.type;
-          // explicit self name has highest priority
-          if (type === COMPONENTS) {
-              const selfName = getComponentName(Component);
-              if (selfName &&
-                  (selfName === name ||
-                      selfName === camelize(name) ||
-                      selfName === capitalize(camelize(name)))) {
-                  return Component;
-              }
-          }
-          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) {
-              // fallback to implicit self-reference
-              return Component;
-          }
-          if (warnMissing && !res) {
-              const extra = type === COMPONENTS
-                  ? `\nIf 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}`);
+          if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
+              if (isTeleportDisabled(vnode.props)) {
+                  vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, slotScopeIds, optimized);
+                  vnode.targetAnchor = targetNode;
+              }
+              else {
+                  vnode.anchor = nextSibling(node);
+                  // lookahead until we find the target anchor
+                  // we cannot rely on return value of hydrateChildren() because there
+                  // could be nested teleports
+                  let targetAnchor = targetNode;
+                  while (targetAnchor) {
+                      targetAnchor = nextSibling(targetAnchor);
+                      if (targetAnchor &&
+                          targetAnchor.nodeType === 8 &&
+                          targetAnchor.data === 'teleport anchor') {
+                          vnode.targetAnchor = targetAnchor;
+                          target._lpa =
+                              vnode.targetAnchor && nextSibling(vnode.targetAnchor);
+                          break;
+                      }
+                  }
+                  hydrateChildren(targetNode, vnode, target, parentComponent, parentSuspense, slotScopeIds, optimized);
+              }
           }
-          return res;
-      }
-      else {
-          warn$1(`resolve${capitalize(type.slice(0, -1))} ` +
-              `can only be used in render() or setup().`);
       }
+      return vnode.anchor && nextSibling(vnode.anchor);
   }
-  function resolve(registry, name) {
-      return (registry &&
-          (registry[name] ||
-              registry[camelize(name)] ||
-              registry[capitalize(camelize(name))]));
-  }
+  // Force-casted public typing for h and TSX props inference
+  const Teleport = TeleportImpl;
 
   const Fragment = Symbol('Fragment' );
   const Text = Symbol('Text' );
@@ -7724,6 +8192,15 @@ var Vue = (function (exports) {
           if (children) {
               normalizeChildren(cloned, children);
           }
+          if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
+              if (cloned.shapeFlag & 6 /* COMPONENT */) {
+                  currentBlock[currentBlock.indexOf(type)] = cloned;
+              }
+              else {
+                  currentBlock.push(cloned);
+              }
+          }
+          cloned.patchFlag |= -2 /* BAIL */;
           return cloned;
       }
       // class component normalization.
@@ -7807,600 +8284,188 @@ var Vue = (function (exports) {
           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 // hoisted node
-                  ? 16 /* FULL_PROPS */
-                  : patchFlag | 16 /* FULL_PROPS */
-              : patchFlag,
-          dynamicProps: vnode.dynamicProps,
-          dynamicChildren: vnode.dynamicChildren,
-          appContext: vnode.appContext,
-          dirs: vnode.dirs,
-          transition: vnode.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
-      };
-      return cloned;
-  }
-  /**
-   * Dev only, for HMR of hoisted vnodes reused in v-for
-   * https://github.com/vitejs/vite/issues/2022
-   */
-  function deepCloneVNode(vnode) {
-      const cloned = cloneVNode(vnode);
-      if (isArray(vnode.children)) {
-          cloned.children = vnode.children.map(deepCloneVNode);
-      }
-      return cloned;
-  }
-  /**
-   * @private
-   */
-  function createTextVNode(text = ' ', flag = 0) {
-      return createVNode(Text, null, text, flag);
-  }
-  /**
-   * @private
-   */
-  function createStaticVNode(content, numberOfNodes) {
-      // A static vnode can contain multiple stringified elements, and the number
-      // of elements is necessary for hydration.
-      const vnode = createVNode(Static, null, content);
-      vnode.staticCount = numberOfNodes;
-      return vnode;
-  }
-  /**
-   * @private
-   */
-  function createCommentVNode(text = '', 
-  // when used as the v-else branch, the comment node must be created as a
-  // block to ensure correct updates.
-  asBlock = false) {
-      return asBlock
-          ? (openBlock(), createBlock(Comment, null, text))
-          : createVNode(Comment, null, text);
-  }
-  function normalizeVNode(child) {
-      if (child == null || typeof child === 'boolean') {
-          // empty placeholder
-          return createVNode(Comment);
-      }
-      else if (isArray(child)) {
-          // fragment
-          return createVNode(Fragment, null, 
-          // #3666, avoid reference pollution when reusing vnode
-          child.slice());
-      }
-      else if (typeof child === 'object') {
-          // already vnode, this should be the most common since compiled templates
-          // always produce all-vnode children arrays
-          return cloneIfMounted(child);
-      }
-      else {
-          // strings and numbers
-          return createVNode(Text, null, String(child));
-      }
-  }
-  // optimized normalization for template-compiled render fns
-  function cloneIfMounted(child) {
-      return child.el === null || 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 /* ARRAY_CHILDREN */;
-      }
-      else if (typeof children === 'object') {
-          if (shapeFlag & (1 /* ELEMENT */ | 64 /* TELEPORT */)) {
-              // Normalize slot to plain children for plain element and Teleport
-              const slot = children.default;
-              if (slot) {
-                  // _c marker is added by withCtx() indicating this is a compiled slot
-                  slot._c && (slot._d = false);
-                  normalizeChildren(vnode, slot());
-                  slot._c && (slot._d = true);
-              }
-              return;
-          }
-          else {
-              type = 32 /* SLOTS_CHILDREN */;
-              const slotFlag = children._;
-              if (!slotFlag && !(InternalObjectKey in children)) {
-                  children._ctx = currentRenderingInstance;
-              }
-              else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {
-                  // a child component receives forwarded slots from the parent.
-                  // its slot type is determined by its parent's slot type.
-                  if (currentRenderingInstance.slots._ === 1 /* STABLE */) {
-                      children._ = 1 /* STABLE */;
-                  }
-                  else {
-                      children._ = 2 /* DYNAMIC */;
-                      vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;
-                  }
-              }
-          }
-      }
-      else if (isFunction(children)) {
-          children = { default: children, _ctx: currentRenderingInstance };
-          type = 32 /* SLOTS_CHILDREN */;
-      }
-      else {
-          children = String(children);
-          // force teleport children to array so it can be moved around
-          if (shapeFlag & 64 /* TELEPORT */) {
-              type = 16 /* ARRAY_CHILDREN */;
-              children = [createTextVNode(children)];
-          }
-          else {
-              type = 8 /* TEXT_CHILDREN */;
-          }
-      }
-      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_HOOK */, [
-          vnode,
-          prevVNode
-      ]);
-  }
-
-  /**
-   * Actual implementation
-   */
-  function renderList(source, renderItem, cache, index) {
-      let ret;
-      const cached = (cache && cache[index]);
-      if (isArray(source) || isString(source)) {
-          ret = new Array(source.length);
-          for (let i = 0, l = source.length; i < l; i++) {
-              ret[i] = renderItem(source[i], i, undefined, cached && cached[i]);
-          }
-      }
-      else if (typeof source === 'number') {
-          if (!Number.isInteger(source)) {
-              warn$1(`The v-for range expect an integer value but got ${source}.`);
-              return [];
-          }
-          ret = new Array(source);
-          for (let i = 0; i < source; i++) {
-              ret[i] = renderItem(i + 1, i, undefined, cached && cached[i]);
-          }
-      }
-      else if (isObject(source)) {
-          if (source[Symbol.iterator]) {
-              ret = Array.from(source, (item, i) => renderItem(item, i, undefined, cached && cached[i]));
-          }
-          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;
-      }
-      return ret;
-  }
-
+          // note: preserve flag for fragments since they use the flag for children
+          // fast paths only.
+          patchFlag: extraProps && vnode.type !== Fragment
+              ? patchFlag === -1 // hoisted node
+                  ? 16 /* FULL_PROPS */
+                  : patchFlag | 16 /* FULL_PROPS */
+              : patchFlag,
+          dynamicProps: vnode.dynamicProps,
+          dynamicChildren: vnode.dynamicChildren,
+          appContext: vnode.appContext,
+          dirs: vnode.dirs,
+          transition: vnode.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
+      };
+      return cloned;
+  }
   /**
-   * Compiler runtime helper for creating dynamic slots object
-   * @private
+   * Dev only, for HMR of hoisted vnodes reused in v-for
+   * https://github.com/vitejs/vite/issues/2022
    */
-  function createSlots(slots, dynamicSlots) {
-      for (let i = 0; i < dynamicSlots.length; i++) {
-          const slot = dynamicSlots[i];
-          // array of dynamic slot generated by <template v-for="..." #[...]>
-          if (isArray(slot)) {
-              for (let j = 0; j < slot.length; j++) {
-                  slots[slot[j].name] = slot[j].fn;
-              }
-          }
-          else if (slot) {
-              // conditional single slot generated by <template v-if="..." #foo>
-              slots[slot.name] = slot.fn;
-          }
+  function deepCloneVNode(vnode) {
+      const cloned = cloneVNode(vnode);
+      if (isArray(vnode.children)) {
+          cloned.children = vnode.children.map(deepCloneVNode);
       }
-      return slots;
-  }
-
+      return cloned;
+  }
   /**
-   * Compiler runtime helper for rendering `<slot/>`
    * @private
    */
-  function renderSlot(slots, name, props = {}, 
-  // this is not a user-facing function, so the fallback is always generated by
-  // the compiler and guaranteed to be a function returning an array
-  fallback, noSlotted) {
-      if (currentRenderingInstance.isCE ||
-          (currentRenderingInstance.parent &&
-              isAsyncWrapper(currentRenderingInstance.parent) &&
-              currentRenderingInstance.parent.isCE)) {
-          return createVNode('slot', name === 'default' ? null : { name }, fallback && fallback());
-      }
-      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 = () => [];
-      }
-      // a compiled slot disables block tracking by default to avoid manual
-      // invocation interfering with template-based block tracking, but in
-      // `renderSlot` we can be sure that it's template-based so we can force
-      // enable it.
-      if (slot && slot._c) {
-          slot._d = false;
-      }
-      openBlock();
-      const validSlotContent = slot && ensureValidVNode(slot(props));
-      const rendered = createBlock(Fragment, { key: props.key || `_${name}` }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* STABLE */
-          ? 64 /* STABLE_FRAGMENT */
-          : -2 /* BAIL */);
-      if (!noSlotted && rendered.scopeId) {
-          rendered.slotScopeIds = [rendered.scopeId + '-s'];
-      }
-      if (slot && slot._c) {
-          slot._d = true;
-      }
-      return rendered;
+  function createTextVNode(text = ' ', flag = 0) {
+      return createVNode(Text, null, text, flag);
   }
-  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;
-  }
-
   /**
-   * For prefixing keys in v-on="obj" with "on"
    * @private
    */
-  function toHandlers(obj) {
-      const ret = {};
-      if (!isObject(obj)) {
-          warn$1(`v-on with no argument expects an object value.`);
-          return ret;
-      }
-      for (const key in obj) {
-          ret[toHandlerKey(key)] = obj[key];
-      }
-      return ret;
-  }
-
-  /**
-   * #2437 In Vue 3, functional components do not have a public instance proxy but
-   * they exist in the internal parent chain. For code that relies on traversing
-   * public $parent chains, skip functional ones and go to the parent instead.
-   */
-  const getPublicInstance = (i) => {
-      if (!i)
-          return null;
-      if (isStatefulComponent(i))
-          return getExposeProxy(i) || i.proxy;
-      return getPublicInstance(i.parent);
-  };
-  const publicPropertiesMap = 
-  // Move PURE marker to new line to workaround compiler discarding it
-  // due to type annotation
-  /*#__PURE__*/ extend(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),
-      $emit: i => i.emit,
-      $options: i => (resolveMergedOptions(i) ),
-      $forceUpdate: i => () => queueJob(i.update),
-      $nextTick: i => nextTick.bind(i.proxy),
-      $watch: i => (instanceWatch.bind(i) )
-  });
-  const PublicInstanceProxyHandlers = {
-      get({ _: instance }, key) {
-          const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
-          // for internal formatters to know that this is a Vue instance
-          if (key === '__isVue') {
-              return true;
-          }
-          // prioritize <script setup> bindings during dev.
-          // this allows even properties that start with _ or $ to be used - so that
-          // it aligns with the production behavior where the render fn is inlined and
-          // indeed has access to all declared variables.
-          if (setupState !== EMPTY_OBJ &&
-              setupState.__isScriptSetup &&
-              hasOwn(setupState, key)) {
-              return setupState[key];
-          }
-          // data / props / ctx
-          // This getter gets called for every property access on the render context
-          // during render and is a major hotspot. The most expensive part of this
-          // is the multiple hasOwn() calls. It's much faster to do a simple property
-          // access on a plain object, so we use an accessCache object (with null
-          // prototype) to memoize what access type a key corresponds to.
-          let normalizedProps;
-          if (key[0] !== '$') {
-              const n = accessCache[key];
-              if (n !== undefined) {
-                  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];
-                      // default: just fallthrough
-                  }
-              }
-              else if (setupState !== EMPTY_OBJ && hasOwn(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 */;
-              }
-          }
-          const publicGetter = publicPropertiesMap[key];
-          let cssModule, globalProperties;
-          // public $xxx properties
-          if (publicGetter) {
-              if (key === '$attrs') {
-                  track(instance, "get" /* GET */, key);
-                  markAttrsAccessed();
-              }
-              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)) {
-              // user may set custom properties to `this` that start with `$`
-              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 &&
-                  (key[0] === '$' || 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.`);
+  function createStaticVNode(content, numberOfNodes) {
+      // A static vnode can contain multiple stringified elements, and the number
+      // of elements is necessary for hydration.
+      const vnode = createVNode(Static, null, content);
+      vnode.staticCount = numberOfNodes;
+      return vnode;
+  }
+  /**
+   * @private
+   */
+  function createCommentVNode(text = '', 
+  // when used as the v-else branch, the comment node must be created as a
+  // block to ensure correct updates.
+  asBlock = false) {
+      return asBlock
+          ? (openBlock(), createBlock(Comment, null, text))
+          : createVNode(Comment, null, text);
+  }
+  function normalizeVNode(child) {
+      if (child == null || typeof child === 'boolean') {
+          // empty placeholder
+          return createVNode(Comment);
+      }
+      else if (isArray(child)) {
+          // fragment
+          return createVNode(Fragment, null, 
+          // #3666, avoid reference pollution when reusing vnode
+          child.slice());
+      }
+      else if (typeof child === 'object') {
+          // already vnode, this should be the most common since compiled templates
+          // always produce all-vnode children arrays
+          return cloneIfMounted(child);
+      }
+      else {
+          // strings and numbers
+          return createVNode(Text, null, String(child));
+      }
+  }
+  // optimized normalization for template-compiled render fns
+  function cloneIfMounted(child) {
+      return child.el === null || 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 /* ARRAY_CHILDREN */;
+      }
+      else if (typeof children === 'object') {
+          if (shapeFlag & (1 /* ELEMENT */ | 64 /* TELEPORT */)) {
+              // Normalize slot to plain children for plain element and Teleport
+              const slot = children.default;
+              if (slot) {
+                  // _c marker is added by withCtx() indicating this is a compiled slot
+                  slot._c && (slot._d = false);
+                  normalizeChildren(vnode, slot());
+                  slot._c && (slot._d = true);
               }
-          }
-      },
-      set({ _: instance }, key, value) {
-          const { data, setupState, ctx } = instance;
-          if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
-              setupState[key] = value;
-              return true;
-          }
-          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.`, instance);
-              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.`, instance);
-              return false;
+              return;
           }
           else {
-              if (key in instance.appContext.config.globalProperties) {
-                  Object.defineProperty(ctx, key, {
-                      enumerable: true,
-                      configurable: true,
-                      value
-                  });
+              type = 32 /* SLOTS_CHILDREN */;
+              const slotFlag = children._;
+              if (!slotFlag && !(InternalObjectKey in children)) {
+                  children._ctx = currentRenderingInstance;
               }
-              else {
-                  ctx[key] = value;
+              else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {
+                  // a child component receives forwarded slots from the parent.
+                  // its slot type is determined by its parent's slot type.
+                  if (currentRenderingInstance.slots._ === 1 /* STABLE */) {
+                      children._ = 1 /* STABLE */;
+                  }
+                  else {
+                      children._ = 2 /* DYNAMIC */;
+                      vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;
+                  }
               }
           }
-          return true;
-      },
-      has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) {
-          let normalizedProps;
-          return (!!accessCache[key] ||
-              (data !== EMPTY_OBJ && hasOwn(data, key)) ||
-              (setupState !== EMPTY_OBJ && hasOwn(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) {
-              // invalidate key cache of a getter based property #5417
-              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);
-      };
-  }
-  const RuntimeCompiledPublicInstanceProxyHandlers = /*#__PURE__*/ extend({}, PublicInstanceProxyHandlers, {
-      get(target, key) {
-          // fast path for unscopables when using `with` block
-          if (key === Symbol.unscopables) {
-              return;
+      else if (isFunction(children)) {
+          children = { default: children, _ctx: currentRenderingInstance };
+          type = 32 /* SLOTS_CHILDREN */;
+      }
+      else {
+          children = String(children);
+          // force teleport children to array so it can be moved around
+          if (shapeFlag & 64 /* TELEPORT */) {
+              type = 16 /* ARRAY_CHILDREN */;
+              children = [createTextVNode(children)];
           }
-          return PublicInstanceProxyHandlers.get(target, key, target);
-      },
-      has(_, key) {
-          const has = key[0] !== '_' && !isGloballyWhitelisted(key);
-          if (!has && PublicInstanceProxyHandlers.has(_, key)) {
-              warn$1(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`);
+          else {
+              type = 8 /* TEXT_CHILDREN */;
           }
-          return has;
-      }
-  });
-  // dev only
-  // In dev mode, the proxy target exposes the same properties as seen on `this`
-  // for easier console inspection. In prod mode it will be an empty object so
-  // these properties definitions can be skipped.
-  function createDevRenderContext(instance) {
-      const target = {};
-      // expose internal instance for proxy handlers
-      Object.defineProperty(target, `_`, {
-          configurable: true,
-          enumerable: false,
-          get: () => instance
-      });
-      // expose public properties
-      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;
-  }
-  // dev only
-  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
-              });
-          });
       }
+      vnode.children = children;
+      vnode.shapeFlag |= type;
   }
-  // dev only
-  function exposeSetupStateOnRenderContext(instance) {
-      const { ctx, setupState } = instance;
-      Object.keys(toRaw(setupState)).forEach(key => {
-          if (!setupState.__isScriptSetup) {
-              if (key[0] === '$' || key[0] === '_') {
-                  warn$1(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` +
-                      `which are reserved prefixes for Vue internals.`);
-                  return;
+  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];
               }
-              Object.defineProperty(ctx, key, {
-                  enumerable: true,
-                  configurable: true,
-                  get: () => setupState[key],
-                  set: NOOP
-              });
           }
-      });
+      }
+      return ret;
+  }
+  function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
+      callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [
+          vnode,
+          prevVNode
+      ]);
   }
 
   const emptyAppContext = createAppContext();
@@ -8429,7 +8494,7 @@ var Vue = (function (exports) {
           provides: parent ? parent.provides : Object.create(appContext.provides),
           accessCache: null,
           renderCache: [],
-          // local resovled assets
+          // local resolved assets
           components: null,
           directives: null,
           // resolved props and emits options
@@ -9185,7 +9250,7 @@ var Vue = (function (exports) {
           return false;
       }
       for (let i = 0; i < prev.length; i++) {
-          if (prev[i] !== memo[i]) {
+          if (hasChanged(prev[i], memo[i])) {
               return false;
           }
       }
@@ -9197,7 +9262,7 @@ var Vue = (function (exports) {
   }
 
   // Core API ------------------------------------------------------------------
-  const version = "3.2.33";
+  const version = "3.2.35";
   /**
    * SSR utils for \@vue/server-renderer. Only exposed in cjs builds.
    * @internal
@@ -9674,11 +9739,11 @@ var Vue = (function (exports) {
       return key in el;
   }
 
-  function defineCustomElement(options, hydate) {
+  function defineCustomElement(options, hydrate) {
       const Comp = defineComponent(options);
       class VueCustomElement extends VueElement {
           constructor(initialProps) {
-              super(Comp, initialProps, hydate);
+              super(Comp, initialProps, hydrate);
           }
       }
       VueCustomElement.def = Comp;
@@ -10026,7 +10091,10 @@ var Vue = (function (exports) {
           removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass);
           done && done();
       };
+      let isLeaving = false;
       const finishLeave = (el, done) => {
+          isLeaving = false;
+          removeTransitionClass(el, leaveFromClass);
           removeTransitionClass(el, leaveToClass);
           removeTransitionClass(el, leaveActiveClass);
           done && done();
@@ -10059,12 +10127,17 @@ var Vue = (function (exports) {
           onEnter: makeEnterHook(false),
           onAppear: makeEnterHook(true),
           onLeave(el, done) {
+              isLeaving = true;
               const resolve = () => finishLeave(el, done);
               addTransitionClass(el, leaveFromClass);
               // force reflow so *-leave-from classes immediately take effect (#2593)
               forceReflow();
               addTransitionClass(el, leaveActiveClass);
               nextFrame(() => {
+                  if (!isLeaving) {
+                      // cancelled
+                      return;
+                  }
                   removeTransitionClass(el, leaveFromClass);
                   addTransitionClass(el, leaveToClass);
                   if (!hasExplicitCallback(onLeave)) {
@@ -10356,7 +10429,8 @@ var Vue = (function (exports) {
   }
 
   const getModelAssigner = (vnode) => {
-      const fn = vnode.props['onUpdate:modelValue'];
+      const fn = vnode.props['onUpdate:modelValue'] ||
+          (false );
       return isArray(fn) ? value => invokeArrayFns(fn, value) : fn;
   };
   function onCompositionStart(e) {
@@ -10366,14 +10440,9 @@ var Vue = (function (exports) {
       const target = e.target;
       if (target.composing) {
           target.composing = false;
-          trigger$1(target, 'input');
+          target.dispatchEvent(new Event('input'));
       }
   }
-  function trigger$1(el, type) {
-      const e = document.createEvent('HTMLEvents');
-      e.initEvent(type, true, true);
-      el.dispatchEvent(e);
-  }
   // We are exporting the v-model runtime directly as vnode hooks so that it can
   // be tree-shaken in case v-model is never used.
   const vModelText = {
@@ -10387,7 +10456,7 @@ var Vue = (function (exports) {
               if (trim) {
                   domValue = domValue.trim();
               }
-              else if (castToNumber) {
+              if (castToNumber) {
                   domValue = toNumber(domValue);
               }
               el._assign(domValue);
@@ -10416,7 +10485,7 @@ var Vue = (function (exports) {
           // avoid clearing unresolved text. #2302
           if (el.composing)
               return;
-          if (document.activeElement === el) {
+          if (document.activeElement === el && el.type !== 'range') {
               if (lazy) {
                   return;
               }
@@ -10586,27 +10655,25 @@ var Vue = (function (exports) {
           callModelHook(el, binding, vnode, prevVNode, 'updated');
       }
   };
-  function callModelHook(el, binding, vnode, prevVNode, hook) {
-      let modelToUse;
-      switch (el.tagName) {
+  function resolveDynamicModel(tagName, type) {
+      switch (tagName) {
           case 'SELECT':
-              modelToUse = vModelSelect;
-              break;
+              return vModelSelect;
           case 'TEXTAREA':
-              modelToUse = vModelText;
-              break;
+              return vModelText;
           default:
-              switch (vnode.props && vnode.props.type) {
+              switch (type) {
                   case 'checkbox':
-                      modelToUse = vModelCheckbox;
-                      break;
+                      return vModelCheckbox;
                   case 'radio':
-                      modelToUse = vModelRadio;
-                      break;
+                      return vModelRadio;
                   default:
-                      modelToUse = vModelText;
+                      return vModelText;
               }
       }
+  }
+  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);
   }
@@ -12872,6 +12939,7 @@ var Vue = (function (exports) {
   }
 
   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,
@@ -12948,9 +13016,7 @@ var Vue = (function (exports) {
           // function mode const declarations should be inside with block
           // also they should be renamed to avoid collision with user properties
           if (hasHelpers) {
-              push(`const { ${ast.helpers
-                .map(s => `${helperNameMap[s]}: _${helperNameMap[s]}`)
-                .join(', ')} } = _Vue`);
+              push(`const { ${ast.helpers.map(aliasHelper).join(', ')} } = _Vue`);
               push(`\n`);
               newline();
           }
@@ -13005,7 +13071,6 @@ var Vue = (function (exports) {
   function genFunctionPreamble(ast, context) {
       const { ssr, prefixIdentifiers, push, newline, runtimeModuleName, runtimeGlobalName, ssrRuntimeModuleName } = context;
       const VueBinding = runtimeGlobalName;
-      const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
       // Generate const declaration for helpers
       // In prefix mode, we place the const declaration at top so it's done
       // only once; But if we not prefixing, we place the declaration inside the
@@ -13618,14 +13683,14 @@ var Vue = (function (exports) {
       }
   }
   function createIfBranch(node, dir) {
+      const isTemplateIf = node.tagType === 3 /* TEMPLATE */;
       return {
           type: 10 /* IF_BRANCH */,
           loc: node.loc,
           condition: dir.name === 'else' ? undefined : dir.exp,
-          children: node.tagType === 3 /* TEMPLATE */ && !findDir(node, 'for')
-              ? node.children
-              : [node],
-          userKey: findProp(node, `key`)
+          children: isTemplateIf && !findDir(node, 'for') ? node.children : [node],
+          userKey: findProp(node, `key`),
+          isTemplateIf
       };
   }
   function createCodegenNodeForBranch(branch, keyIndex, context) {
@@ -13660,7 +13725,8 @@ var Vue = (function (exports) {
               let patchFlagText = PatchFlagNames[64 /* STABLE_FRAGMENT */];
               // check if the fragment actually contains a single valid child with
               // the rest being comments
-              if (children.filter(c => c.type !== 3 /* COMMENT */).length === 1) {
+              if (!branch.isTemplateIf &&
+                  children.filter(c => c.type !== 3 /* COMMENT */).length === 1) {
                   patchFlag |= 2048 /* DEV_ROOT_FRAGMENT */;
                   patchFlagText += `, ${PatchFlagNames[2048 /* DEV_ROOT_FRAGMENT */]}`;
               }
@@ -14211,7 +14277,7 @@ var Vue = (function (exports) {
                   (tag === 'svg' || tag === 'foreignObject'));
           // props
           if (props.length > 0) {
-              const propsBuildResult = buildProps(node, context);
+              const propsBuildResult = buildProps(node, context, undefined, isComponent, isDynamicComponent);
               vnodeProps = propsBuildResult.props;
               patchFlag = propsBuildResult.patchFlag;
               dynamicPropNames = propsBuildResult.dynamicPropNames;
@@ -14350,9 +14416,8 @@ var Vue = (function (exports) {
       context.components.add(tag);
       return toValidAssetId(tag, `component`);
   }
-  function buildProps(node, context, props = node.props, ssr = false) {
+  function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
       const { tag, loc: elementLoc, children } = node;
-      const isComponent = node.tagType === 1 /* COMPONENT */;
       let properties = [];
       const mergeArgs = [];
       const runtimeDirectives = [];
@@ -14371,8 +14436,8 @@ var Vue = (function (exports) {
           if (isStaticExp(key)) {
               const name = key.content;
               const isEventHandler = isOn(name);
-              if (!isComponent &&
-                  isEventHandler &&
+              if (isEventHandler &&
+                  (!isComponent || isDynamicComponent) &&
                   // omit the flag for click handlers because hydration gives click
                   // dedicated fast path.
                   name.toLowerCase() !== 'onclick' &&
@@ -14598,10 +14663,11 @@ var Vue = (function (exports) {
                           classProp.value = createCallExpression(context.helper(NORMALIZE_CLASS), [classProp.value]);
                       }
                       if (styleProp &&
-                          !isStaticExp(styleProp.value) &&
                           // 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 /* SIMPLE_EXPRESSION */ &&
+                                  styleProp.value.content.trim()[0] === `[`) ||
                               // v-bind:style and style both exist,
                               // v-bind:style with static literal object
                               styleProp.value.type === 17 /* JS_ARRAY_EXPRESSION */)) {
@@ -14780,7 +14846,7 @@ var Vue = (function (exports) {
           }
       }
       if (nonNameProps.length > 0) {
-          const { props, directives } = buildProps(node, context, nonNameProps);
+          const { props, directives } = buildProps(node, context, nonNameProps, false, false);
           slotProps = props;
           if (directives.length) {
               context.onError(createCompilerError(36 /* X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET */, directives[0].loc));
@@ -14951,11 +15017,7 @@ var Vue = (function (exports) {
                           const next = children[j];
                           if (isText(next)) {
                               if (!currentContainer) {
-                                  currentContainer = children[i] = {
-                                      type: 8 /* COMPOUND_EXPRESSION */,
-                                      loc: child.loc,
-                                      children: [child]
-                                  };
+                                  currentContainer = children[i] = createCompoundExpression([child], child.loc);
                               }
                               // merge adjacent text node into current
                               currentContainer.children.push(` + `, next);
@@ -15362,7 +15424,9 @@ var Vue = (function (exports) {
       return {
           props: [
               createObjectProperty(createSimpleExpression(`textContent`, true), exp
-                  ? createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc)
+                  ? getConstantType(exp, context) > 0
+                      ? exp
+                      : createCallExpression(context.helperString(TO_DISPLAY_STRING), [exp], loc)
                   : createSimpleExpression('', true))
           ]
       };
@@ -15570,19 +15634,38 @@ var Vue = (function (exports) {
       };
   };
 
-  const warnTransitionChildren = (node, context) => {
+  const transformTransition = (node, context) => {
       if (node.type === 1 /* ELEMENT */ &&
           node.tagType === 1 /* COMPONENT */) {
           const component = context.isBuiltInComponent(node.tag);
           if (component === TRANSITION$1) {
               return () => {
-                  if (node.children.length && hasMultipleChildren(node)) {
+                  if (!node.children.length) {
+                      return;
+                  }
+                  // warn multiple transition children
+                  if (hasMultipleChildren(node)) {
                       context.onError(createDOMCompilerError(59 /* X_TRANSITION_INVALID_CHILDREN */, {
                           start: node.children[0].loc.start,
                           end: node.children[node.children.length - 1].loc.end,
                           source: ''
                       }));
                   }
+                  // check if it's s single child w/ v-show
+                  // if yes, inject "persisted: true" to the transition props
+                  const child = node.children[0];
+                  if (child.type === 1 /* ELEMENT */) {
+                      for (const p of child.props) {
+                          if (p.type === 7 /* DIRECTIVE */ && p.name === 'show') {
+                              node.props.push({
+                                  type: 6 /* ATTRIBUTE */,
+                                  name: 'persisted',
+                                  value: undefined,
+                                  loc: node.loc
+                              });
+                          }
+                      }
+                  }
               };
           }
       }
@@ -15608,7 +15691,7 @@ var Vue = (function (exports) {
 
   const DOMNodeTransforms = [
       transformStyle,
-      ...([warnTransitionChildren] )
+      ...([transformTransition] )
   ];
   const DOMDirectiveTransforms = {
       cloak: noopDirectiveTransform,