@vue/compat 3.3.0-alpha.7 → 3.3.0-alpha.9

package/dist/vue.global.js

@@ -3539,33 +3539,41 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
     }
   }
 
-  function provide(key, value) {
-    if (!currentInstance) {
-      {
-        warn(`provide() can only be used inside setup().`);
-      }
-    } else {
-      let provides = currentInstance.provides;
-      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
-      if (parentProvides === provides) {
-        provides = currentInstance.provides = Object.create(parentProvides);
-      }
-      provides[key] = value;
-    }
-  }
-  function inject(key, defaultValue, treatDefaultAsFactory = false) {
-    const instance = currentInstance || currentRenderingInstance;
-    if (instance) {
-      const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides;
-      if (provides && key in provides) {
-        return provides[key];
-      } else if (arguments.length > 1) {
-        return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue;
+  const legacyDirectiveHookMap = {
+    beforeMount: "bind",
+    mounted: "inserted",
+    updated: ["update", "componentUpdated"],
+    unmounted: "unbind"
+  };
+  function mapCompatDirectiveHook(name, dir, instance) {
+    const mappedName = legacyDirectiveHookMap[name];
+    if (mappedName) {
+      if (isArray(mappedName)) {
+        const hook = [];
+        mappedName.forEach((mapped) => {
+          const mappedHook = dir[mapped];
+          if (mappedHook) {
+            softAssertCompatEnabled(
+              "CUSTOM_DIR",
+              instance,
+              mapped,
+              name
+            );
+            hook.push(mappedHook);
+          }
+        });
+        return hook.length ? hook : void 0;
       } else {
-        warn(`injection "${String(key)}" not found.`);
+        if (dir[mappedName]) {
+          softAssertCompatEnabled(
+            "CUSTOM_DIR",
+            instance,
+            mappedName,
+            name
+          );
+        }
+        return dir[mappedName];
       }
-    } else {
-      warn(`inject() can only be used inside setup() or functional components.`);
     }
   }
 
@@ -3804,6 +3812,68 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
     return value;
   }
 
+  function validateDirectiveName(name) {
+    if (isBuiltInDirective(name)) {
+      warn("Do not use built-in directive ids as custom directive id: " + name);
+    }
+  }
+  function withDirectives(vnode, directives) {
+    const internalInstance = currentRenderingInstance;
+    if (internalInstance === null) {
+      warn(`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 (dir) {
+        if (isFunction(dir)) {
+          dir = {
+            mounted: dir,
+            updated: dir
+          };
+        }
+        if (dir.deep) {
+          traverse(value);
+        }
+        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;
+      }
+      let hook = binding.dir[name];
+      if (!hook) {
+        hook = mapCompatDirectiveHook(name, binding.dir, instance);
+      }
+      if (hook) {
+        pauseTracking();
+        callWithAsyncErrorHandling(hook, instance, 8, [
+          vnode.el,
+          binding,
+          vnode,
+          prevVNode
+        ]);
+        resetTracking();
+      }
+    }
+  }
+
   function useTransitionState() {
     const state = {
       isMounted: false,
@@ -4602,106 +4672,6 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
     return listeners;
   }
 
-  const legacyDirectiveHookMap = {
-    beforeMount: "bind",
-    mounted: "inserted",
-    updated: ["update", "componentUpdated"],
-    unmounted: "unbind"
-  };
-  function mapCompatDirectiveHook(name, dir, instance) {
-    const mappedName = legacyDirectiveHookMap[name];
-    if (mappedName) {
-      if (isArray(mappedName)) {
-        const hook = [];
-        mappedName.forEach((mapped) => {
-          const mappedHook = dir[mapped];
-          if (mappedHook) {
-            softAssertCompatEnabled(
-              "CUSTOM_DIR",
-              instance,
-              mapped,
-              name
-            );
-            hook.push(mappedHook);
-          }
-        });
-        return hook.length ? hook : void 0;
-      } else {
-        if (dir[mappedName]) {
-          softAssertCompatEnabled(
-            "CUSTOM_DIR",
-            instance,
-            mappedName,
-            name
-          );
-        }
-        return dir[mappedName];
-      }
-    }
-  }
-
-  function validateDirectiveName(name) {
-    if (isBuiltInDirective(name)) {
-      warn("Do not use built-in directive ids as custom directive id: " + name);
-    }
-  }
-  function withDirectives(vnode, directives) {
-    const internalInstance = currentRenderingInstance;
-    if (internalInstance === null) {
-      warn(`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 (dir) {
-        if (isFunction(dir)) {
-          dir = {
-            mounted: dir,
-            updated: dir
-          };
-        }
-        if (dir.deep) {
-          traverse(value);
-        }
-        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;
-      }
-      let hook = binding.dir[name];
-      if (!hook) {
-        hook = mapCompatDirectiveHook(name, binding.dir, instance);
-      }
-      if (hook) {
-        pauseTracking();
-        callWithAsyncErrorHandling(hook, instance, 8, [
-          vnode.el,
-          binding,
-          vnode,
-          prevVNode
-        ]);
-        resetTracking();
-      }
-    }
-  }
-
   const COMPONENTS = "components";
   const DIRECTIVES = "directives";
   const FILTERS = "filters";
@@ -6042,1179 +6012,1218 @@ If this is a native custom element, make sure to exclude it from component resol
     return merged;
   }
 
-  function createPropsDefaultThis(instance, rawProps, propKey) {
-    return new Proxy(
-      {},
-      {
-        get(_, key) {
-          warnDeprecation$1("PROPS_DEFAULT_THIS", null, propKey);
-          if (key === "$options") {
-            return resolveMergedOptions(instance);
-          }
-          if (key in rawProps) {
-            return rawProps[key];
-          }
-          const injections = instance.type.inject;
-          if (injections) {
-            if (isArray(injections)) {
-              if (injections.includes(key)) {
-                return inject(key);
-              }
-            } else if (key in injections) {
-              return inject(key);
-            }
+  function installLegacyConfigWarnings(config) {
+    const legacyConfigOptions = {
+      silent: "CONFIG_SILENT",
+      devtools: "CONFIG_DEVTOOLS",
+      ignoredElements: "CONFIG_IGNORED_ELEMENTS",
+      keyCodes: "CONFIG_KEY_CODES",
+      productionTip: "CONFIG_PRODUCTION_TIP"
+    };
+    Object.keys(legacyConfigOptions).forEach((key) => {
+      let val = config[key];
+      Object.defineProperty(config, key, {
+        enumerable: true,
+        get() {
+          return val;
+        },
+        set(newVal) {
+          if (!isCopyingConfig) {
+            warnDeprecation$1(legacyConfigOptions[key], null);
           }
+          val = newVal;
         }
-      }
-    );
+      });
+    });
   }
-
-  function shouldSkipAttr(key, instance) {
-    if (key === "is") {
-      return true;
-    }
-    if ((key === "class" || key === "style") && isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance)) {
-      return true;
-    }
-    if (isOn(key) && isCompatEnabled$1("INSTANCE_LISTENERS", instance)) {
-      return true;
-    }
-    if (key.startsWith("routerView") || key === "registerRouteInstance") {
-      return true;
-    }
-    return false;
+  function installLegacyOptionMergeStrats(config) {
+    config.optionMergeStrategies = new Proxy({}, {
+      get(target, key) {
+        if (key in target) {
+          return target[key];
+        }
+        if (key in internalOptionMergeStrats && softAssertCompatEnabled(
+          "CONFIG_OPTION_MERGE_STRATS",
+          null
+        )) {
+          return internalOptionMergeStrats[key];
+        }
+      }
+    });
   }
 
-  function initProps(instance, rawProps, isStateful, isSSR = false) {
-    const props = {};
-    const attrs = {};
-    def(attrs, InternalObjectKey, 1);
-    instance.propsDefaults = /* @__PURE__ */ Object.create(null);
-    setFullProps(instance, rawProps, props, attrs);
-    for (const key in instance.propsOptions[0]) {
-      if (!(key in props)) {
-        props[key] = void 0;
+  let isCopyingConfig = false;
+  let singletonApp;
+  let singletonCtor;
+  function createCompatVue$1(createApp, createSingletonApp) {
+    singletonApp = createSingletonApp({});
+    const Vue = singletonCtor = function Vue2(options = {}) {
+      return createCompatApp(options, Vue2);
+    };
+    function createCompatApp(options = {}, Ctor) {
+      assertCompatEnabled("GLOBAL_MOUNT", null);
+      const { data } = options;
+      if (data && !isFunction(data) && softAssertCompatEnabled("OPTIONS_DATA_FN", null)) {
+        options.data = () => data;
       }
-    }
-    {
-      validateProps(rawProps || {}, props, instance);
-    }
-    if (isStateful) {
-      instance.props = isSSR ? props : shallowReactive(props);
-    } else {
-      if (!instance.type.props) {
-        instance.props = attrs;
+      const app = createApp(options);
+      if (Ctor !== Vue) {
+        applySingletonPrototype(app, Ctor);
+      }
+      const vm = app._createRoot(options);
+      if (options.el) {
+        return vm.$mount(options.el);
       } else {
-        instance.props = props;
+        return vm;
       }
     }
-    instance.attrs = attrs;
-  }
-  function isInHmrContext(instance) {
-    while (instance) {
-      if (instance.type.__hmrId)
-        return true;
-      instance = instance.parent;
-    }
-  }
-  function updateProps(instance, rawProps, rawPrevProps, optimized) {
-    const {
-      props,
-      attrs,
-      vnode: { patchFlag }
-    } = instance;
-    const rawCurrentProps = toRaw(props);
-    const [options] = instance.propsOptions;
-    let hasAttrsChanged = false;
-    if (
-      // always force full diff in dev
-      // - #1942 if hmr is enabled with sfc component
-      // - vite#872 non-sfc component used by sfc component
-      !isInHmrContext(instance) && (optimized || patchFlag > 0) && !(patchFlag & 16)
-    ) {
-      if (patchFlag & 8) {
-        const propsToUpdate = instance.vnode.dynamicProps;
-        for (let i = 0; i < propsToUpdate.length; i++) {
-          let key = propsToUpdate[i];
-          if (isEmitListener(instance.emitsOptions, key)) {
-            continue;
-          }
-          const value = rawProps[key];
-          if (options) {
-            if (hasOwn(attrs, key)) {
-              if (value !== attrs[key]) {
-                attrs[key] = value;
-                hasAttrsChanged = true;
-              }
-            } else {
-              const camelizedKey = camelize(key);
-              props[camelizedKey] = resolvePropValue(
-                options,
-                rawCurrentProps,
-                camelizedKey,
-                value,
-                instance,
-                false
-                /* isAbsent */
-              );
-            }
-          } else {
-            {
-              if (isOn(key) && key.endsWith("Native")) {
-                key = key.slice(0, -6);
-              } else if (shouldSkipAttr(key, instance)) {
-                continue;
-              }
-            }
-            if (value !== attrs[key]) {
-              attrs[key] = value;
-              hasAttrsChanged = true;
-            }
-          }
-        }
+    Vue.version = `2.6.14-compat:${"3.3.0-alpha.9"}`;
+    Vue.config = singletonApp.config;
+    Vue.use = (p, ...options) => {
+      if (p && isFunction(p.install)) {
+        p.install(Vue, ...options);
+      } else if (isFunction(p)) {
+        p(Vue, ...options);
       }
-    } else {
-      if (setFullProps(instance, rawProps, props, attrs)) {
-        hasAttrsChanged = true;
+      return Vue;
+    };
+    Vue.mixin = (m) => {
+      singletonApp.mixin(m);
+      return Vue;
+    };
+    Vue.component = (name, comp) => {
+      if (comp) {
+        singletonApp.component(name, comp);
+        return Vue;
+      } else {
+        return singletonApp.component(name);
       }
-      let kebabKey;
-      for (const key in rawCurrentProps) {
-        if (!rawProps || // for camelCase
-        !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
-        // and converted to camelCase (#955)
-        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
-          if (options) {
-            if (rawPrevProps && // for camelCase
-            (rawPrevProps[key] !== void 0 || // for kebab-case
-            rawPrevProps[kebabKey] !== void 0)) {
-              props[key] = resolvePropValue(
-                options,
-                rawCurrentProps,
-                key,
-                void 0,
-                instance,
-                true
-                /* isAbsent */
-              );
-            }
-          } else {
-            delete props[key];
-          }
-        }
+    };
+    Vue.directive = (name, dir) => {
+      if (dir) {
+        singletonApp.directive(name, dir);
+        return Vue;
+      } else {
+        return singletonApp.directive(name);
       }
-      if (attrs !== rawCurrentProps) {
-        for (const key in attrs) {
-          if (!rawProps || !hasOwn(rawProps, key) && !hasOwn(rawProps, key + "Native")) {
-            delete attrs[key];
-            hasAttrsChanged = true;
-          }
+    };
+    Vue.options = { _base: Vue };
+    let cid = 1;
+    Vue.cid = cid;
+    Vue.nextTick = nextTick;
+    const extendCache = /* @__PURE__ */ new WeakMap();
+    function extendCtor(extendOptions = {}) {
+      assertCompatEnabled("GLOBAL_EXTEND", null);
+      if (isFunction(extendOptions)) {
+        extendOptions = extendOptions.options;
+      }
+      if (extendCache.has(extendOptions)) {
+        return extendCache.get(extendOptions);
+      }
+      const Super = this;
+      function SubVue(inlineOptions) {
+        if (!inlineOptions) {
+          return createCompatApp(SubVue.options, SubVue);
+        } else {
+          return createCompatApp(
+            mergeOptions(
+              extend({}, SubVue.options),
+              inlineOptions,
+              internalOptionMergeStrats
+            ),
+            SubVue
+          );
         }
       }
+      SubVue.super = Super;
+      SubVue.prototype = Object.create(Vue.prototype);
+      SubVue.prototype.constructor = SubVue;
+      const mergeBase = {};
+      for (const key in Super.options) {
+        const superValue = Super.options[key];
+        mergeBase[key] = isArray(superValue) ? superValue.slice() : isObject(superValue) ? extend(/* @__PURE__ */ Object.create(null), superValue) : superValue;
+      }
+      SubVue.options = mergeOptions(
+        mergeBase,
+        extendOptions,
+        internalOptionMergeStrats
+      );
+      SubVue.options._base = SubVue;
+      SubVue.extend = extendCtor.bind(SubVue);
+      SubVue.mixin = Super.mixin;
+      SubVue.use = Super.use;
+      SubVue.cid = ++cid;
+      extendCache.set(extendOptions, SubVue);
+      return SubVue;
     }
-    if (hasAttrsChanged) {
-      trigger(instance, "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) {
-        if (isReservedProp(key)) {
-          continue;
-        }
-        {
-          if (key.startsWith("onHook:")) {
-            softAssertCompatEnabled(
-              "INSTANCE_EVENT_HOOKS",
-              instance,
-              key.slice(2).toLowerCase()
-            );
-          }
-          if (key === "inline-template") {
-            continue;
-          }
-        }
-        const value = rawProps[key];
-        let camelKey;
-        if (options && hasOwn(options, camelKey = camelize(key))) {
-          if (!needCastKeys || !needCastKeys.includes(camelKey)) {
-            props[camelKey] = value;
-          } else {
-            (rawCastValues || (rawCastValues = {}))[camelKey] = value;
-          }
-        } else if (!isEmitListener(instance.emitsOptions, key)) {
-          {
-            if (isOn(key) && key.endsWith("Native")) {
-              key = key.slice(0, -6);
-            } else if (shouldSkipAttr(key, instance)) {
-              continue;
-            }
-          }
-          if (!(key in attrs) || value !== attrs[key]) {
-            attrs[key] = value;
-            hasAttrsChanged = true;
-          }
-        }
+    Vue.extend = extendCtor.bind(Vue);
+    Vue.set = (target, key, value) => {
+      assertCompatEnabled("GLOBAL_SET", null);
+      target[key] = value;
+    };
+    Vue.delete = (target, key) => {
+      assertCompatEnabled("GLOBAL_DELETE", null);
+      delete target[key];
+    };
+    Vue.observable = (target) => {
+      assertCompatEnabled("GLOBAL_OBSERVABLE", null);
+      return reactive(target);
+    };
+    Vue.filter = (name, filter) => {
+      if (filter) {
+        singletonApp.filter(name, filter);
+        return Vue;
+      } else {
+        return singletonApp.filter(name);
       }
-    }
-    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)
-        );
+    };
+    const util = {
+      warn: warn ,
+      extend,
+      mergeOptions: (parent, child, vm) => mergeOptions(
+        parent,
+        child,
+        vm ? void 0 : internalOptionMergeStrats
+      ),
+      defineReactive
+    };
+    Object.defineProperty(Vue, "util", {
+      get() {
+        assertCompatEnabled("GLOBAL_PRIVATE_UTIL", null);
+        return util;
       }
+    });
+    Vue.configureCompat = configureCompat;
+    return Vue;
+  }
+  function installAppCompatProperties(app, context, render) {
+    installFilterMethod(app, context);
+    installLegacyOptionMergeStrats(app.config);
+    if (!singletonApp) {
+      return;
     }
-    return hasAttrsChanged;
+    installCompatMount(app, context, render);
+    installLegacyAPIs(app);
+    applySingletonAppMutations(app);
+    installLegacyConfigWarnings(app.config);
   }
-  function resolvePropValue(options, props, key, value, instance, isAbsent) {
-    const opt = options[key];
-    if (opt != null) {
-      const hasDefault = hasOwn(opt, "default");
-      if (hasDefault && value === void 0) {
-        const defaultValue = opt.default;
-        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
-          const { propsDefaults } = instance;
-          if (key in propsDefaults) {
-            value = propsDefaults[key];
-          } else {
-            setCurrentInstance(instance);
-            value = propsDefaults[key] = defaultValue.call(
-              isCompatEnabled$1("PROPS_DEFAULT_THIS", instance) ? createPropsDefaultThis(instance, props, key) : null,
-              props
-            );
-            unsetCurrentInstance();
-          }
-        } else {
-          value = defaultValue;
-        }
+  function installFilterMethod(app, context) {
+    context.filters = {};
+    app.filter = (name, filter) => {
+      assertCompatEnabled("FILTERS", null);
+      if (!filter) {
+        return context.filters[name];
       }
-      if (opt[0 /* shouldCast */]) {
-        if (isAbsent && !hasDefault) {
-          value = false;
-        } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
-          value = true;
-        }
+      if (context.filters[name]) {
+        warn(`Filter "${name}" has already been registered.`);
       }
-    }
-    return value;
+      context.filters[name] = filter;
+      return app;
+    };
   }
-  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 = [];
-    let hasExtends = false;
-    if (!isFunction(comp)) {
-      const extendProps = (raw2) => {
-        if (isFunction(raw2)) {
-          raw2 = raw2.options;
+  function installLegacyAPIs(app) {
+    Object.defineProperties(app, {
+      // so that app.use() can work with legacy plugins that extend prototypes
+      prototype: {
+        get() {
+          warnDeprecation$1("GLOBAL_PROTOTYPE", null);
+          return app.config.globalProperties;
+        }
+      },
+      nextTick: { value: nextTick },
+      extend: { value: singletonCtor.extend },
+      set: { value: singletonCtor.set },
+      delete: { value: singletonCtor.delete },
+      observable: { value: singletonCtor.observable },
+      util: {
+        get() {
+          return singletonCtor.util;
         }
-        hasExtends = true;
-        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
-        extend(normalized, props);
-        if (keys)
-          needCastKeys.push(...keys);
-      };
-      if (!asMixin && appContext.mixins.length) {
-        appContext.mixins.forEach(extendProps);
       }
-      if (comp.extends) {
-        extendProps(comp.extends);
+    });
+  }
+  function applySingletonAppMutations(app) {
+    app._context.mixins = [...singletonApp._context.mixins];
+    ["components", "directives", "filters"].forEach((key) => {
+      app._context[key] = Object.create(singletonApp._context[key]);
+    });
+    isCopyingConfig = true;
+    for (const key in singletonApp.config) {
+      if (key === "isNativeTag")
+        continue;
+      if (isRuntimeOnly() && (key === "isCustomElement" || key === "compilerOptions")) {
+        continue;
       }
-      if (comp.mixins) {
-        comp.mixins.forEach(extendProps);
+      const val = singletonApp.config[key];
+      app.config[key] = isObject(val) ? Object.create(val) : val;
+      if (key === "ignoredElements" && isCompatEnabled$1("CONFIG_IGNORED_ELEMENTS", null) && !isRuntimeOnly() && isArray(val)) {
+        app.config.compilerOptions.isCustomElement = (tag) => {
+          return val.some((v) => isString(v) ? v === tag : v.test(tag));
+        };
       }
     }
-    if (!raw && !hasExtends) {
-      if (isObject(comp)) {
-        cache.set(comp, EMPTY_ARR);
-      }
-      return EMPTY_ARR;
+    isCopyingConfig = false;
+    applySingletonPrototype(app, singletonCtor);
+  }
+  function applySingletonPrototype(app, Ctor) {
+    const enabled = isCompatEnabled$1("GLOBAL_PROTOTYPE", null);
+    if (enabled) {
+      app.config.globalProperties = Object.create(Ctor.prototype);
     }
-    if (isArray(raw)) {
-      for (let i = 0; i < raw.length; i++) {
-        if (!isString(raw[i])) {
-          warn(`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(`invalid props options`, raw);
-      }
-      for (const key in raw) {
-        const normalizedKey = camelize(key);
-        if (validatePropName(normalizedKey)) {
-          const opt = raw[key];
-          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
-          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 (booleanIndex > -1 || hasOwn(prop, "default")) {
-              needCastKeys.push(normalizedKey);
-            }
-          }
+    let hasPrototypeAugmentations = false;
+    const descriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+    for (const key in descriptors) {
+      if (key !== "constructor") {
+        hasPrototypeAugmentations = true;
+        if (enabled) {
+          Object.defineProperty(
+            app.config.globalProperties,
+            key,
+            descriptors[key]
+          );
         }
       }
     }
-    const res = [normalized, needCastKeys];
-    if (isObject(comp)) {
-      cache.set(comp, res);
-    }
-    return res;
+    if (hasPrototypeAugmentations) {
+      warnDeprecation$1("GLOBAL_PROTOTYPE", null);
+    }
   }
-  function validatePropName(key) {
-    if (key[0] !== "$") {
-      return true;
+  function installCompatMount(app, context, render) {
+    let isMounted = false;
+    app._createRoot = (options) => {
+      const component = app._component;
+      const vnode = createVNode(component, options.propsData || null);
+      vnode.appContext = context;
+      const hasNoRender = !isFunction(component) && !component.render && !component.template;
+      const emptyRender = () => {
+      };
+      const instance = createComponentInstance(vnode, null, null);
+      if (hasNoRender) {
+        instance.render = emptyRender;
+      }
+      setupComponent(instance);
+      vnode.component = instance;
+      vnode.isCompatRoot = true;
+      instance.ctx._compat_mount = (selectorOrEl) => {
+        if (isMounted) {
+          warn(`Root instance is already mounted.`);
+          return;
+        }
+        let container;
+        if (typeof selectorOrEl === "string") {
+          const result = document.querySelector(selectorOrEl);
+          if (!result) {
+            warn(
+              `Failed to mount root instance: selector "${selectorOrEl}" returned null.`
+            );
+            return;
+          }
+          container = result;
+        } else {
+          container = selectorOrEl || document.createElement("div");
+        }
+        const isSVG = container instanceof SVGElement;
+        {
+          context.reload = () => {
+            const cloned = cloneVNode(vnode);
+            cloned.component = null;
+            render(cloned, container, isSVG);
+          };
+        }
+        if (hasNoRender && instance.render === emptyRender) {
+          {
+            for (let i = 0; i < container.attributes.length; i++) {
+              const attr = container.attributes[i];
+              if (attr.name !== "v-cloak" && /^(v-|:|@)/.test(attr.name)) {
+                warnDeprecation$1("GLOBAL_MOUNT_CONTAINER", null);
+                break;
+              }
+            }
+          }
+          instance.render = null;
+          component.template = container.innerHTML;
+          finishComponentSetup(
+            instance,
+            false,
+            true
+            /* skip options */
+          );
+        }
+        container.innerHTML = "";
+        render(vnode, container, isSVG);
+        if (container instanceof Element) {
+          container.removeAttribute("v-cloak");
+          container.setAttribute("data-v-app", "");
+        }
+        isMounted = true;
+        app._container = container;
+        container.__vue_app__ = app;
+        {
+          devtoolsInitApp(app, version);
+        }
+        return instance.proxy;
+      };
+      instance.ctx._compat_destroy = () => {
+        if (isMounted) {
+          render(null, app._container);
+          {
+            devtoolsUnmountApp(app);
+          }
+          delete app._container.__vue_app__;
+        } else {
+          const { bum, scope, um } = instance;
+          if (bum) {
+            invokeArrayFns(bum);
+          }
+          if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
+            instance.emit("hook:beforeDestroy");
+          }
+          if (scope) {
+            scope.stop();
+          }
+          if (um) {
+            invokeArrayFns(um);
+          }
+          if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
+            instance.emit("hook:destroyed");
+          }
+        }
+      };
+      return instance.proxy;
+    };
+  }
+  const methodsToPatch = [
+    "push",
+    "pop",
+    "shift",
+    "unshift",
+    "splice",
+    "sort",
+    "reverse"
+  ];
+  const patched = /* @__PURE__ */ new WeakSet();
+  function defineReactive(obj, key, val) {
+    if (isObject(val) && !isReactive(val) && !patched.has(val)) {
+      const reactiveVal = reactive(val);
+      if (isArray(val)) {
+        methodsToPatch.forEach((m) => {
+          val[m] = (...args) => {
+            Array.prototype[m].call(reactiveVal, ...args);
+          };
+        });
+      } else {
+        Object.keys(val).forEach((key2) => {
+          try {
+            defineReactiveSimple(val, key2, val[key2]);
+          } catch (e) {
+          }
+        });
+      }
+    }
+    const i = obj.$;
+    if (i && obj === i.proxy) {
+      defineReactiveSimple(i.ctx, key, val);
+      i.accessCache = /* @__PURE__ */ Object.create(null);
+    } else if (isReactive(obj)) {
+      obj[key] = val;
     } else {
-      warn(`Invalid prop name: "${key}" is a reserved property.`);
+      defineReactiveSimple(obj, key, val);
     }
-    return false;
-  }
-  function getType(ctor) {
-    const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
-    return match ? match[2] : ctor === null ? "null" : "";
   }
-  function isSameType(a, b) {
-    return getType(a) === getType(b);
+  function defineReactiveSimple(obj, key, val) {
+    val = isObject(val) ? reactive(val) : val;
+    Object.defineProperty(obj, key, {
+      enumerable: true,
+      configurable: true,
+      get() {
+        track(obj, "get", key);
+        return val;
+      },
+      set(newVal) {
+        val = isObject(newVal) ? reactive(newVal) : newVal;
+        trigger(obj, "set", key, newVal);
+      }
+    });
   }
-  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;
+
+  function createAppContext() {
+    return {
+      app: null,
+      config: {
+        isNativeTag: NO,
+        performance: false,
+        globalProperties: {},
+        optionMergeStrategies: {},
+        errorHandler: void 0,
+        warnHandler: void 0,
+        compilerOptions: {}
+      },
+      mixins: [],
+      components: {},
+      directives: {},
+      provides: /* @__PURE__ */ Object.create(null),
+      optionsCache: /* @__PURE__ */ new WeakMap(),
+      propsCache: /* @__PURE__ */ new WeakMap(),
+      emitsCache: /* @__PURE__ */ new WeakMap()
+    };
   }
-  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))
-      );
-    }
+  let uid$1 = 0;
+  function createAppAPI(render, hydrate) {
+    return function createApp(rootComponent, rootProps = null) {
+      if (!isFunction(rootComponent)) {
+        rootComponent = extend({}, rootComponent);
+      }
+      if (rootProps != null && !isObject(rootProps)) {
+        warn(`root props passed to app.mount() must be an object.`);
+        rootProps = null;
+      }
+      const context = createAppContext();
+      const installedPlugins = /* @__PURE__ */ new Set();
+      let isMounted = false;
+      const app = context.app = {
+        _uid: uid$1++,
+        _component: rootComponent,
+        _props: rootProps,
+        _container: null,
+        _context: context,
+        _instance: null,
+        version,
+        get config() {
+          return context.config;
+        },
+        set config(v) {
+          {
+            warn(
+              `app.config cannot be replaced. Modify individual options instead.`
+            );
+          }
+        },
+        use(plugin, ...options) {
+          if (installedPlugins.has(plugin)) {
+            warn(`Plugin has already been applied to target app.`);
+          } else if (plugin && isFunction(plugin.install)) {
+            installedPlugins.add(plugin);
+            plugin.install(app, ...options);
+          } else if (isFunction(plugin)) {
+            installedPlugins.add(plugin);
+            plugin(app, ...options);
+          } else {
+            warn(
+              `A plugin must either be a function or an object with an "install" function.`
+            );
+          }
+          return app;
+        },
+        mixin(mixin) {
+          {
+            if (!context.mixins.includes(mixin)) {
+              context.mixins.push(mixin);
+            } else {
+              warn(
+                "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
+              );
+            }
+          }
+          return app;
+        },
+        component(name, component) {
+          {
+            validateComponentName(name, context.config);
+          }
+          if (!component) {
+            return context.components[name];
+          }
+          if (context.components[name]) {
+            warn(`Component "${name}" has already been registered in target app.`);
+          }
+          context.components[name] = component;
+          return app;
+        },
+        directive(name, directive) {
+          {
+            validateDirectiveName(name);
+          }
+          if (!directive) {
+            return context.directives[name];
+          }
+          if (context.directives[name]) {
+            warn(`Directive "${name}" has already been registered in target app.`);
+          }
+          context.directives[name] = directive;
+          return app;
+        },
+        mount(rootContainer, isHydrate, isSVG) {
+          if (!isMounted) {
+            if (rootContainer.__vue_app__) {
+              warn(
+                `There is already an app instance mounted on the host container.
+ If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
+              );
+            }
+            const vnode = createVNode(
+              rootComponent,
+              rootProps
+            );
+            vnode.appContext = context;
+            {
+              context.reload = () => {
+                render(cloneVNode(vnode), rootContainer, isSVG);
+              };
+            }
+            if (isHydrate && hydrate) {
+              hydrate(vnode, rootContainer);
+            } else {
+              render(vnode, rootContainer, isSVG);
+            }
+            isMounted = true;
+            app._container = rootContainer;
+            rootContainer.__vue_app__ = app;
+            {
+              app._instance = vnode.component;
+              devtoolsInitApp(app, version);
+            }
+            return getExposeProxy(vnode.component) || vnode.component.proxy;
+          } else {
+            warn(
+              `App has already been mounted.
+If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
+            );
+          }
+        },
+        unmount() {
+          if (isMounted) {
+            render(null, app._container);
+            {
+              app._instance = null;
+              devtoolsUnmountApp(app);
+            }
+            delete app._container.__vue_app__;
+          } else {
+            warn(`Cannot unmount an app that is not mounted.`);
+          }
+        },
+        provide(key, value) {
+          if (key in context.provides) {
+            warn(
+              `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
+            );
+          }
+          context.provides[key] = value;
+          return app;
+        },
+        runWithContext(fn) {
+          currentApp = app;
+          try {
+            return fn();
+          } finally {
+            currentApp = null;
+          }
+        }
+      };
+      {
+        installAppCompatProperties(app, context, render);
+      }
+      return app;
+    };
   }
-  function validateProp(name, value, prop, isAbsent) {
-    const { type, required, validator, skipCheck } = prop;
-    if (required && isAbsent) {
-      warn('Missing required prop: "' + name + '"');
-      return;
-    }
-    if (value == null && !prop.required) {
-      return;
-    }
-    if (type != null && type !== true && !skipCheck) {
-      let isValid = false;
-      const types = isArray(type) ? type : [type];
-      const expectedTypes = [];
-      for (let i = 0; i < types.length && !isValid; i++) {
-        const { valid, expectedType } = assertType(value, types[i]);
-        expectedTypes.push(expectedType || "");
-        isValid = valid;
+  let currentApp = null;
+
+  function provide(key, value) {
+    if (!currentInstance) {
+      {
+        warn(`provide() can only be used inside setup().`);
       }
-      if (!isValid) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes));
-        return;
+    } else {
+      let provides = currentInstance.provides;
+      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+      if (parentProvides === provides) {
+        provides = currentInstance.provides = Object.create(parentProvides);
       }
-    }
-    if (validator && !validator(value)) {
-      warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+      provides[key] = value;
     }
   }
-  const isSimpleType = /* @__PURE__ */ makeMap(
-    "String,Number,Boolean,Function,Symbol,BigInt"
-  );
-  function assertType(value, type) {
-    let valid;
-    const expectedType = getType(type);
-    if (isSimpleType(expectedType)) {
-      const t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      if (!valid && t === "object") {
-        valid = value instanceof type;
+  function inject(key, defaultValue, treatDefaultAsFactory = false) {
+    const instance = currentInstance || currentRenderingInstance;
+    if (instance || currentApp) {
+      const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
+      if (provides && key in provides) {
+        return provides[key];
+      } else if (arguments.length > 1) {
+        return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
+      } else {
+        warn(`injection "${String(key)}" not found.`);
       }
-    } 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;
+      warn(`inject() can only be used inside setup() or functional components.`);
     }
-    return {
-      valid,
-      expectedType
-    };
   }
-  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);
-    if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
-      message += ` with value ${expectedValue}`;
+
+  function createPropsDefaultThis(instance, rawProps, propKey) {
+    return new Proxy(
+      {},
+      {
+        get(_, key) {
+          warnDeprecation$1("PROPS_DEFAULT_THIS", null, propKey);
+          if (key === "$options") {
+            return resolveMergedOptions(instance);
+          }
+          if (key in rawProps) {
+            return rawProps[key];
+          }
+          const injections = instance.type.inject;
+          if (injections) {
+            if (isArray(injections)) {
+              if (injections.includes(key)) {
+                return inject(key);
+              }
+            } else if (key in injections) {
+              return inject(key);
+            }
+          }
+        }
+      }
+    );
+  }
+
+  function shouldSkipAttr(key, instance) {
+    if (key === "is") {
+      return true;
     }
-    message += `, got ${receivedType} `;
-    if (isExplicable(receivedType)) {
-      message += `with value ${receivedValue}.`;
+    if ((key === "class" || key === "style") && isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance)) {
+      return true;
     }
-    return message;
-  }
-  function styleValue(value, type) {
-    if (type === "String") {
-      return `"${value}"`;
-    } else if (type === "Number") {
-      return `${Number(value)}`;
-    } else {
-      return `${value}`;
+    if (isOn(key) && isCompatEnabled$1("INSTANCE_LISTENERS", instance)) {
+      return true;
     }
-  }
-  function isExplicable(type) {
-    const explicitTypes = ["string", "number", "boolean"];
-    return explicitTypes.some((elem) => type.toLowerCase() === elem);
-  }
-  function isBoolean(...args) {
-    return args.some((elem) => elem.toLowerCase() === "boolean");
+    if (key.startsWith("routerView") || key === "registerRouteInstance") {
+      return true;
+    }
+    return false;
   }
 
-  const isInternalKey = (key) => key[0] === "_" || key === "$stable";
-  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
-  const normalizeSlot = (key, rawSlot, ctx) => {
-    if (rawSlot._n) {
-      return rawSlot;
-    }
-    const normalized = withCtx((...args) => {
-      if (currentInstance) {
-        warn(
-          `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) {
-        if (!isCompatEnabled$1("RENDER_FUNCTION", instance)) {
-          warn(
-            `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
-          );
-        }
-        const normalized = normalizeSlotValue(value);
-        slots[key] = () => normalized;
+  function initProps(instance, rawProps, isStateful, isSSR = false) {
+    const props = {};
+    const attrs = {};
+    def(attrs, InternalObjectKey, 1);
+    instance.propsDefaults = /* @__PURE__ */ Object.create(null);
+    setFullProps(instance, rawProps, props, attrs);
+    for (const key in instance.propsOptions[0]) {
+      if (!(key in props)) {
+        props[key] = void 0;
       }
     }
-  };
-  const normalizeVNodeSlots = (instance, children) => {
-    if (!isKeepAlive(instance.vnode) && !isCompatEnabled$1("RENDER_FUNCTION", instance)) {
-      warn(
-        `Non-function value encountered for default slot. Prefer function slots for better performance.`
-      );
+    {
+      validateProps(rawProps || {}, props, instance);
     }
-    const normalized = normalizeSlotValue(children);
-    instance.slots.default = () => normalized;
-  };
-  const initSlots = (instance, children) => {
-    if (instance.vnode.shapeFlag & 32) {
-      const type = children._;
-      if (type) {
-        instance.slots = toRaw(children);
-        def(children, "_", type);
+    if (isStateful) {
+      instance.props = isSSR ? props : shallowReactive(props);
+    } else {
+      if (!instance.type.props) {
+        instance.props = attrs;
       } else {
-        normalizeObjectSlots(
-          children,
-          instance.slots = {},
-          instance
-        );
+        instance.props = props;
+      }
+    }
+    instance.attrs = attrs;
+  }
+  function isInHmrContext(instance) {
+    while (instance) {
+      if (instance.type.__hmrId)
+        return true;
+      instance = instance.parent;
+    }
+  }
+  function updateProps(instance, rawProps, rawPrevProps, optimized) {
+    const {
+      props,
+      attrs,
+      vnode: { patchFlag }
+    } = instance;
+    const rawCurrentProps = toRaw(props);
+    const [options] = instance.propsOptions;
+    let hasAttrsChanged = false;
+    if (
+      // always force full diff in dev
+      // - #1942 if hmr is enabled with sfc component
+      // - vite#872 non-sfc component used by sfc component
+      !isInHmrContext(instance) && (optimized || patchFlag > 0) && !(patchFlag & 16)
+    ) {
+      if (patchFlag & 8) {
+        const propsToUpdate = instance.vnode.dynamicProps;
+        for (let i = 0; i < propsToUpdate.length; i++) {
+          let key = propsToUpdate[i];
+          if (isEmitListener(instance.emitsOptions, key)) {
+            continue;
+          }
+          const value = rawProps[key];
+          if (options) {
+            if (hasOwn(attrs, key)) {
+              if (value !== attrs[key]) {
+                attrs[key] = value;
+                hasAttrsChanged = true;
+              }
+            } else {
+              const camelizedKey = camelize(key);
+              props[camelizedKey] = resolvePropValue(
+                options,
+                rawCurrentProps,
+                camelizedKey,
+                value,
+                instance,
+                false
+                /* isAbsent */
+              );
+            }
+          } else {
+            {
+              if (isOn(key) && key.endsWith("Native")) {
+                key = key.slice(0, -6);
+              } else if (shouldSkipAttr(key, instance)) {
+                continue;
+              }
+            }
+            if (value !== attrs[key]) {
+              attrs[key] = value;
+              hasAttrsChanged = true;
+            }
+          }
+        }
       }
     } else {
-      instance.slots = {};
-      if (children) {
-        normalizeVNodeSlots(instance, children);
+      if (setFullProps(instance, rawProps, props, attrs)) {
+        hasAttrsChanged = true;
       }
-    }
-    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) {
-      const type = children._;
-      if (type) {
-        if (isHmrUpdating) {
-          extend(slots, children);
-        } else if (optimized && type === 1) {
-          needDeletionCheck = false;
-        } else {
-          extend(slots, children);
-          if (!optimized && type === 1) {
-            delete slots._;
+      let kebabKey;
+      for (const key in rawCurrentProps) {
+        if (!rawProps || // for camelCase
+        !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+        // and converted to camelCase (#955)
+        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
+          if (options) {
+            if (rawPrevProps && // for camelCase
+            (rawPrevProps[key] !== void 0 || // for kebab-case
+            rawPrevProps[kebabKey] !== void 0)) {
+              props[key] = resolvePropValue(
+                options,
+                rawCurrentProps,
+                key,
+                void 0,
+                instance,
+                true
+                /* isAbsent */
+              );
+            }
+          } else {
+            delete props[key];
           }
         }
-      } else {
-        needDeletionCheck = !children.$stable;
-        normalizeObjectSlots(children, slots, instance);
       }
-      deletionComparisonTarget = children;
-    } else if (children) {
-      normalizeVNodeSlots(instance, children);
-      deletionComparisonTarget = { default: 1 };
-    }
-    if (needDeletionCheck) {
-      for (const key in slots) {
-        if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
-          delete slots[key];
+      if (attrs !== rawCurrentProps) {
+        for (const key in attrs) {
+          if (!rawProps || !hasOwn(rawProps, key) && !hasOwn(rawProps, key + "Native")) {
+            delete attrs[key];
+            hasAttrsChanged = true;
+          }
         }
       }
     }
-  };
-
-  function installLegacyConfigWarnings(config) {
-    const legacyConfigOptions = {
-      silent: "CONFIG_SILENT",
-      devtools: "CONFIG_DEVTOOLS",
-      ignoredElements: "CONFIG_IGNORED_ELEMENTS",
-      keyCodes: "CONFIG_KEY_CODES",
-      productionTip: "CONFIG_PRODUCTION_TIP"
-    };
-    Object.keys(legacyConfigOptions).forEach((key) => {
-      let val = config[key];
-      Object.defineProperty(config, key, {
-        enumerable: true,
-        get() {
-          return val;
-        },
-        set(newVal) {
-          if (!isCopyingConfig) {
-            warnDeprecation$1(legacyConfigOptions[key], null);
-          }
-          val = newVal;
-        }
-      });
-    });
+    if (hasAttrsChanged) {
+      trigger(instance, "set", "$attrs");
+    }
+    {
+      validateProps(rawProps || {}, props, instance);
+    }
   }
-  function installLegacyOptionMergeStrats(config) {
-    config.optionMergeStrategies = new Proxy({}, {
-      get(target, key) {
-        if (key in target) {
-          return target[key];
+  function setFullProps(instance, rawProps, props, attrs) {
+    const [options, needCastKeys] = instance.propsOptions;
+    let hasAttrsChanged = false;
+    let rawCastValues;
+    if (rawProps) {
+      for (let key in rawProps) {
+        if (isReservedProp(key)) {
+          continue;
         }
-        if (key in internalOptionMergeStrats && softAssertCompatEnabled(
-          "CONFIG_OPTION_MERGE_STRATS",
-          null
-        )) {
-          return internalOptionMergeStrats[key];
+        {
+          if (key.startsWith("onHook:")) {
+            softAssertCompatEnabled(
+              "INSTANCE_EVENT_HOOKS",
+              instance,
+              key.slice(2).toLowerCase()
+            );
+          }
+          if (key === "inline-template") {
+            continue;
+          }
+        }
+        const value = rawProps[key];
+        let camelKey;
+        if (options && hasOwn(options, camelKey = camelize(key))) {
+          if (!needCastKeys || !needCastKeys.includes(camelKey)) {
+            props[camelKey] = value;
+          } else {
+            (rawCastValues || (rawCastValues = {}))[camelKey] = value;
+          }
+        } else if (!isEmitListener(instance.emitsOptions, key)) {
+          {
+            if (isOn(key) && key.endsWith("Native")) {
+              key = key.slice(0, -6);
+            } else if (shouldSkipAttr(key, instance)) {
+              continue;
+            }
+          }
+          if (!(key in attrs) || value !== attrs[key]) {
+            attrs[key] = value;
+            hasAttrsChanged = true;
+          }
         }
-      }
-    });
-  }
-
-  let isCopyingConfig = false;
-  let singletonApp;
-  let singletonCtor;
-  function createCompatVue$1(createApp, createSingletonApp) {
-    singletonApp = createSingletonApp({});
-    const Vue = singletonCtor = function Vue2(options = {}) {
-      return createCompatApp(options, Vue2);
-    };
-    function createCompatApp(options = {}, Ctor) {
-      assertCompatEnabled("GLOBAL_MOUNT", null);
-      const { data } = options;
-      if (data && !isFunction(data) && softAssertCompatEnabled("OPTIONS_DATA_FN", null)) {
-        options.data = () => data;
-      }
-      const app = createApp(options);
-      if (Ctor !== Vue) {
-        applySingletonPrototype(app, Ctor);
-      }
-      const vm = app._createRoot(options);
-      if (options.el) {
-        return vm.$mount(options.el);
-      } else {
-        return vm;
       }
     }
-    Vue.version = `2.6.14-compat:${"3.3.0-alpha.7"}`;
-    Vue.config = singletonApp.config;
-    Vue.use = (p, ...options) => {
-      if (p && isFunction(p.install)) {
-        p.install(Vue, ...options);
-      } else if (isFunction(p)) {
-        p(Vue, ...options);
-      }
-      return Vue;
-    };
-    Vue.mixin = (m) => {
-      singletonApp.mixin(m);
-      return Vue;
-    };
-    Vue.component = (name, comp) => {
-      if (comp) {
-        singletonApp.component(name, comp);
-        return Vue;
-      } else {
-        return singletonApp.component(name);
-      }
-    };
-    Vue.directive = (name, dir) => {
-      if (dir) {
-        singletonApp.directive(name, dir);
-        return Vue;
-      } else {
-        return singletonApp.directive(name);
-      }
-    };
-    Vue.options = { _base: Vue };
-    let cid = 1;
-    Vue.cid = cid;
-    Vue.nextTick = nextTick;
-    const extendCache = /* @__PURE__ */ new WeakMap();
-    function extendCtor(extendOptions = {}) {
-      assertCompatEnabled("GLOBAL_EXTEND", null);
-      if (isFunction(extendOptions)) {
-        extendOptions = extendOptions.options;
-      }
-      if (extendCache.has(extendOptions)) {
-        return extendCache.get(extendOptions);
+    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)
+        );
       }
-      const Super = this;
-      function SubVue(inlineOptions) {
-        if (!inlineOptions) {
-          return createCompatApp(SubVue.options, SubVue);
+    }
+    return hasAttrsChanged;
+  }
+  function resolvePropValue(options, props, key, value, instance, isAbsent) {
+    const opt = options[key];
+    if (opt != null) {
+      const hasDefault = hasOwn(opt, "default");
+      if (hasDefault && value === void 0) {
+        const defaultValue = opt.default;
+        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
+          const { propsDefaults } = instance;
+          if (key in propsDefaults) {
+            value = propsDefaults[key];
+          } else {
+            setCurrentInstance(instance);
+            value = propsDefaults[key] = defaultValue.call(
+              isCompatEnabled$1("PROPS_DEFAULT_THIS", instance) ? createPropsDefaultThis(instance, props, key) : null,
+              props
+            );
+            unsetCurrentInstance();
+          }
         } else {
-          return createCompatApp(
-            mergeOptions(
-              extend({}, SubVue.options),
-              inlineOptions,
-              internalOptionMergeStrats
-            ),
-            SubVue
-          );
+          value = defaultValue;
         }
       }
-      SubVue.super = Super;
-      SubVue.prototype = Object.create(Vue.prototype);
-      SubVue.prototype.constructor = SubVue;
-      const mergeBase = {};
-      for (const key in Super.options) {
-        const superValue = Super.options[key];
-        mergeBase[key] = isArray(superValue) ? superValue.slice() : isObject(superValue) ? extend(/* @__PURE__ */ Object.create(null), superValue) : superValue;
+      if (opt[0 /* shouldCast */]) {
+        if (isAbsent && !hasDefault) {
+          value = false;
+        } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
+          value = true;
+        }
       }
-      SubVue.options = mergeOptions(
-        mergeBase,
-        extendOptions,
-        internalOptionMergeStrats
-      );
-      SubVue.options._base = SubVue;
-      SubVue.extend = extendCtor.bind(SubVue);
-      SubVue.mixin = Super.mixin;
-      SubVue.use = Super.use;
-      SubVue.cid = ++cid;
-      extendCache.set(extendOptions, SubVue);
-      return SubVue;
     }
-    Vue.extend = extendCtor.bind(Vue);
-    Vue.set = (target, key, value) => {
-      assertCompatEnabled("GLOBAL_SET", null);
-      target[key] = value;
-    };
-    Vue.delete = (target, key) => {
-      assertCompatEnabled("GLOBAL_DELETE", null);
-      delete target[key];
-    };
-    Vue.observable = (target) => {
-      assertCompatEnabled("GLOBAL_OBSERVABLE", null);
-      return reactive(target);
-    };
-    Vue.filter = (name, filter) => {
-      if (filter) {
-        singletonApp.filter(name, filter);
-        return Vue;
-      } else {
-        return singletonApp.filter(name);
-      }
-    };
-    const util = {
-      warn: warn ,
-      extend,
-      mergeOptions: (parent, child, vm) => mergeOptions(
-        parent,
-        child,
-        vm ? void 0 : internalOptionMergeStrats
-      ),
-      defineReactive
-    };
-    Object.defineProperty(Vue, "util", {
-      get() {
-        assertCompatEnabled("GLOBAL_PRIVATE_UTIL", null);
-        return util;
-      }
-    });
-    Vue.configureCompat = configureCompat;
-    return Vue;
+    return value;
   }
-  function installAppCompatProperties(app, context, render) {
-    installFilterMethod(app, context);
-    installLegacyOptionMergeStrats(app.config);
-    if (!singletonApp) {
-      return;
+  function normalizePropsOptions(comp, appContext, asMixin = false) {
+    const cache = appContext.propsCache;
+    const cached = cache.get(comp);
+    if (cached) {
+      return cached;
     }
-    installCompatMount(app, context, render);
-    installLegacyAPIs(app);
-    applySingletonAppMutations(app);
-    installLegacyConfigWarnings(app.config);
-  }
-  function installFilterMethod(app, context) {
-    context.filters = {};
-    app.filter = (name, filter) => {
-      assertCompatEnabled("FILTERS", null);
-      if (!filter) {
-        return context.filters[name];
+    const raw = comp.props;
+    const normalized = {};
+    const needCastKeys = [];
+    let hasExtends = false;
+    if (!isFunction(comp)) {
+      const extendProps = (raw2) => {
+        if (isFunction(raw2)) {
+          raw2 = raw2.options;
+        }
+        hasExtends = true;
+        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
+        extend(normalized, props);
+        if (keys)
+          needCastKeys.push(...keys);
+      };
+      if (!asMixin && appContext.mixins.length) {
+        appContext.mixins.forEach(extendProps);
       }
-      if (context.filters[name]) {
-        warn(`Filter "${name}" has already been registered.`);
+      if (comp.extends) {
+        extendProps(comp.extends);
       }
-      context.filters[name] = filter;
-      return app;
-    };
-  }
-  function installLegacyAPIs(app) {
-    Object.defineProperties(app, {
-      // so that app.use() can work with legacy plugins that extend prototypes
-      prototype: {
-        get() {
-          warnDeprecation$1("GLOBAL_PROTOTYPE", null);
-          return app.config.globalProperties;
+      if (comp.mixins) {
+        comp.mixins.forEach(extendProps);
+      }
+    }
+    if (!raw && !hasExtends) {
+      if (isObject(comp)) {
+        cache.set(comp, EMPTY_ARR);
+      }
+      return EMPTY_ARR;
+    }
+    if (isArray(raw)) {
+      for (let i = 0; i < raw.length; i++) {
+        if (!isString(raw[i])) {
+          warn(`props must be strings when using array syntax.`, raw[i]);
         }
-      },
-      nextTick: { value: nextTick },
-      extend: { value: singletonCtor.extend },
-      set: { value: singletonCtor.set },
-      delete: { value: singletonCtor.delete },
-      observable: { value: singletonCtor.observable },
-      util: {
-        get() {
-          return singletonCtor.util;
+        const normalizedKey = camelize(raw[i]);
+        if (validatePropName(normalizedKey)) {
+          normalized[normalizedKey] = EMPTY_OBJ;
         }
       }
-    });
-  }
-  function applySingletonAppMutations(app) {
-    app._context.mixins = [...singletonApp._context.mixins];
-    ["components", "directives", "filters"].forEach((key) => {
-      app._context[key] = Object.create(singletonApp._context[key]);
-    });
-    isCopyingConfig = true;
-    for (const key in singletonApp.config) {
-      if (key === "isNativeTag")
-        continue;
-      if (isRuntimeOnly() && (key === "isCustomElement" || key === "compilerOptions")) {
-        continue;
+    } else if (raw) {
+      if (!isObject(raw)) {
+        warn(`invalid props options`, raw);
       }
-      const val = singletonApp.config[key];
-      app.config[key] = isObject(val) ? Object.create(val) : val;
-      if (key === "ignoredElements" && isCompatEnabled$1("CONFIG_IGNORED_ELEMENTS", null) && !isRuntimeOnly() && isArray(val)) {
-        app.config.compilerOptions.isCustomElement = (tag) => {
-          return val.some((v) => isString(v) ? v === tag : v.test(tag));
-        };
+      for (const key in raw) {
+        const normalizedKey = camelize(key);
+        if (validatePropName(normalizedKey)) {
+          const opt = raw[key];
+          const prop = normalized[normalizedKey] = isArray(opt) || isFunction(opt) ? { type: opt } : extend({}, opt);
+          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 (booleanIndex > -1 || hasOwn(prop, "default")) {
+              needCastKeys.push(normalizedKey);
+            }
+          }
+        }
       }
     }
-    isCopyingConfig = false;
-    applySingletonPrototype(app, singletonCtor);
+    const res = [normalized, needCastKeys];
+    if (isObject(comp)) {
+      cache.set(comp, res);
+    }
+    return res;
   }
-  function applySingletonPrototype(app, Ctor) {
-    const enabled = isCompatEnabled$1("GLOBAL_PROTOTYPE", null);
-    if (enabled) {
-      app.config.globalProperties = Object.create(Ctor.prototype);
+  function validatePropName(key) {
+    if (key[0] !== "$") {
+      return true;
+    } else {
+      warn(`Invalid prop name: "${key}" is a reserved property.`);
     }
-    let hasPrototypeAugmentations = false;
-    const descriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
-    for (const key in descriptors) {
-      if (key !== "constructor") {
-        hasPrototypeAugmentations = true;
-        if (enabled) {
-          Object.defineProperty(
-            app.config.globalProperties,
-            key,
-            descriptors[key]
-          );
-        }
+    return false;
+  }
+  function getType(ctor) {
+    const match = ctor && ctor.toString().match(/^\s*(function|class) (\w+)/);
+    return match ? match[2] : 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;
+  }
+  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))
+      );
+    }
+  }
+  function validateProp(name, value, prop, isAbsent) {
+    const { type, required, validator, skipCheck } = prop;
+    if (required && isAbsent) {
+      warn('Missing required prop: "' + name + '"');
+      return;
+    }
+    if (value == null && !required) {
+      return;
+    }
+    if (type != null && type !== true && !skipCheck) {
+      let isValid = false;
+      const types = isArray(type) ? type : [type];
+      const expectedTypes = [];
+      for (let i = 0; i < types.length && !isValid; i++) {
+        const { valid, expectedType } = assertType(value, types[i]);
+        expectedTypes.push(expectedType || "");
+        isValid = valid;
+      }
+      if (!isValid) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes));
+        return;
       }
     }
-    if (hasPrototypeAugmentations) {
-      warnDeprecation$1("GLOBAL_PROTOTYPE", null);
+    if (validator && !validator(value)) {
+      warn('Invalid prop: custom validator check failed for prop "' + name + '".');
     }
   }
-  function installCompatMount(app, context, render) {
-    let isMounted = false;
-    app._createRoot = (options) => {
-      const component = app._component;
-      const vnode = createVNode(component, options.propsData || null);
-      vnode.appContext = context;
-      const hasNoRender = !isFunction(component) && !component.render && !component.template;
-      const emptyRender = () => {
-      };
-      const instance = createComponentInstance(vnode, null, null);
-      if (hasNoRender) {
-        instance.render = emptyRender;
+  const isSimpleType = /* @__PURE__ */ makeMap(
+    "String,Number,Boolean,Function,Symbol,BigInt"
+  );
+  function assertType(value, type) {
+    let valid;
+    const expectedType = getType(type);
+    if (isSimpleType(expectedType)) {
+      const t = typeof value;
+      valid = t === expectedType.toLowerCase();
+      if (!valid && t === "object") {
+        valid = value instanceof type;
       }
-      setupComponent(instance);
-      vnode.component = instance;
-      vnode.isCompatRoot = true;
-      instance.ctx._compat_mount = (selectorOrEl) => {
-        if (isMounted) {
-          warn(`Root instance is already mounted.`);
-          return;
-        }
-        let container;
-        if (typeof selectorOrEl === "string") {
-          const result = document.querySelector(selectorOrEl);
-          if (!result) {
-            warn(
-              `Failed to mount root instance: selector "${selectorOrEl}" returned null.`
-            );
-            return;
-          }
-          container = result;
-        } else {
-          container = selectorOrEl || document.createElement("div");
-        }
-        const isSVG = container instanceof SVGElement;
-        {
-          context.reload = () => {
-            const cloned = cloneVNode(vnode);
-            cloned.component = null;
-            render(cloned, container, isSVG);
-          };
-        }
-        if (hasNoRender && instance.render === emptyRender) {
-          {
-            for (let i = 0; i < container.attributes.length; i++) {
-              const attr = container.attributes[i];
-              if (attr.name !== "v-cloak" && /^(v-|:|@)/.test(attr.name)) {
-                warnDeprecation$1("GLOBAL_MOUNT_CONTAINER", null);
-                break;
-              }
-            }
-          }
-          instance.render = null;
-          component.template = container.innerHTML;
-          finishComponentSetup(
-            instance,
-            false,
-            true
-            /* skip options */
-          );
-        }
-        container.innerHTML = "";
-        render(vnode, container, isSVG);
-        if (container instanceof Element) {
-          container.removeAttribute("v-cloak");
-          container.setAttribute("data-v-app", "");
-        }
-        isMounted = true;
-        app._container = container;
-        container.__vue_app__ = app;
-        {
-          devtoolsInitApp(app, version);
-        }
-        return instance.proxy;
-      };
-      instance.ctx._compat_destroy = () => {
-        if (isMounted) {
-          render(null, app._container);
-          {
-            devtoolsUnmountApp(app);
-          }
-          delete app._container.__vue_app__;
-        } else {
-          const { bum, scope, um } = instance;
-          if (bum) {
-            invokeArrayFns(bum);
-          }
-          if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
-            instance.emit("hook:beforeDestroy");
-          }
-          if (scope) {
-            scope.stop();
-          }
-          if (um) {
-            invokeArrayFns(um);
-          }
-          if (isCompatEnabled$1("INSTANCE_EVENT_HOOKS", instance)) {
-            instance.emit("hook:destroyed");
-          }
-        }
-      };
-      return instance.proxy;
+    } 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
     };
   }
-  const methodsToPatch = [
-    "push",
-    "pop",
-    "shift",
-    "unshift",
-    "splice",
-    "sort",
-    "reverse"
-  ];
-  const patched = /* @__PURE__ */ new WeakSet();
-  function defineReactive(obj, key, val) {
-    if (isObject(val) && !isReactive(val) && !patched.has(val)) {
-      const reactiveVal = reactive(val);
-      if (isArray(val)) {
-        methodsToPatch.forEach((m) => {
-          val[m] = (...args) => {
-            Array.prototype[m].call(reactiveVal, ...args);
-          };
-        });
-      } else {
-        Object.keys(val).forEach((key2) => {
-          try {
-            defineReactiveSimple(val, key2, val[key2]);
-          } catch (e) {
-          }
-        });
-      }
+  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);
+    if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
+      message += ` with value ${expectedValue}`;
     }
-    const i = obj.$;
-    if (i && obj === i.proxy) {
-      defineReactiveSimple(i.ctx, key, val);
-      i.accessCache = /* @__PURE__ */ Object.create(null);
-    } else if (isReactive(obj)) {
-      obj[key] = val;
+    message += `, got ${receivedType} `;
+    if (isExplicable(receivedType)) {
+      message += `with value ${receivedValue}.`;
+    }
+    return message;
+  }
+  function styleValue(value, type) {
+    if (type === "String") {
+      return `"${value}"`;
+    } else if (type === "Number") {
+      return `${Number(value)}`;
     } else {
-      defineReactiveSimple(obj, key, val);
+      return `${value}`;
     }
   }
-  function defineReactiveSimple(obj, key, val) {
-    val = isObject(val) ? reactive(val) : val;
-    Object.defineProperty(obj, key, {
-      enumerable: true,
-      configurable: true,
-      get() {
-        track(obj, "get", key);
-        return val;
-      },
-      set(newVal) {
-        val = isObject(newVal) ? reactive(newVal) : newVal;
-        trigger(obj, "set", key, newVal);
+  function isExplicable(type) {
+    const explicitTypes = ["string", "number", "boolean"];
+    return explicitTypes.some((elem) => type.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === "boolean");
+  }
+
+  const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+  const normalizeSlot = (key, rawSlot, ctx) => {
+    if (rawSlot._n) {
+      return rawSlot;
+    }
+    const normalized = withCtx((...args) => {
+      if (currentInstance) {
+        warn(
+          `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) {
+        if (!isCompatEnabled$1("RENDER_FUNCTION", instance)) {
+          warn(
+            `Non-function value encountered for slot "${key}". Prefer function slots for better performance.`
+          );
+        }
+        const normalized = normalizeSlotValue(value);
+        slots[key] = () => normalized;
       }
-    });
-  }
-
-  function createAppContext() {
-    return {
-      app: null,
-      config: {
-        isNativeTag: NO,
-        performance: false,
-        globalProperties: {},
-        optionMergeStrategies: {},
-        errorHandler: void 0,
-        warnHandler: void 0,
-        compilerOptions: {}
-      },
-      mixins: [],
-      components: {},
-      directives: {},
-      provides: /* @__PURE__ */ Object.create(null),
-      optionsCache: /* @__PURE__ */ new WeakMap(),
-      propsCache: /* @__PURE__ */ new WeakMap(),
-      emitsCache: /* @__PURE__ */ new WeakMap()
-    };
-  }
-  let uid$1 = 0;
-  function createAppAPI(render, hydrate) {
-    return function createApp(rootComponent, rootProps = null) {
-      if (!isFunction(rootComponent)) {
-        rootComponent = extend({}, rootComponent);
+    }
+  };
+  const normalizeVNodeSlots = (instance, children) => {
+    if (!isKeepAlive(instance.vnode) && !isCompatEnabled$1("RENDER_FUNCTION", instance)) {
+      warn(
+        `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) {
+      const type = children._;
+      if (type) {
+        instance.slots = toRaw(children);
+        def(children, "_", type);
+      } else {
+        normalizeObjectSlots(
+          children,
+          instance.slots = {},
+          instance
+        );
       }
-      if (rootProps != null && !isObject(rootProps)) {
-        warn(`root props passed to app.mount() must be an object.`);
-        rootProps = null;
+    } else {
+      instance.slots = {};
+      if (children) {
+        normalizeVNodeSlots(instance, children);
       }
-      const context = createAppContext();
-      const installedPlugins = /* @__PURE__ */ new Set();
-      let isMounted = false;
-      const app = context.app = {
-        _uid: uid$1++,
-        _component: rootComponent,
-        _props: rootProps,
-        _container: null,
-        _context: context,
-        _instance: null,
-        version,
-        get config() {
-          return context.config;
-        },
-        set config(v) {
-          {
-            warn(
-              `app.config cannot be replaced. Modify individual options instead.`
-            );
-          }
-        },
-        use(plugin, ...options) {
-          if (installedPlugins.has(plugin)) {
-            warn(`Plugin has already been applied to target app.`);
-          } else if (plugin && isFunction(plugin.install)) {
-            installedPlugins.add(plugin);
-            plugin.install(app, ...options);
-          } else if (isFunction(plugin)) {
-            installedPlugins.add(plugin);
-            plugin(app, ...options);
-          } else {
-            warn(
-              `A plugin must either be a function or an object with an "install" function.`
-            );
-          }
-          return app;
-        },
-        mixin(mixin) {
-          {
-            if (!context.mixins.includes(mixin)) {
-              context.mixins.push(mixin);
-            } else {
-              warn(
-                "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
-              );
-            }
-          }
-          return app;
-        },
-        component(name, component) {
-          {
-            validateComponentName(name, context.config);
-          }
-          if (!component) {
-            return context.components[name];
-          }
-          if (context.components[name]) {
-            warn(`Component "${name}" has already been registered in target app.`);
-          }
-          context.components[name] = component;
-          return app;
-        },
-        directive(name, directive) {
-          {
-            validateDirectiveName(name);
-          }
-          if (!directive) {
-            return context.directives[name];
-          }
-          if (context.directives[name]) {
-            warn(`Directive "${name}" has already been registered in target app.`);
-          }
-          context.directives[name] = directive;
-          return app;
-        },
-        mount(rootContainer, isHydrate, isSVG) {
-          if (!isMounted) {
-            if (rootContainer.__vue_app__) {
-              warn(
-                `There is already an app instance mounted on the host container.
- If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
-              );
-            }
-            const vnode = createVNode(
-              rootComponent,
-              rootProps
-            );
-            vnode.appContext = context;
-            {
-              context.reload = () => {
-                render(cloneVNode(vnode), rootContainer, isSVG);
-              };
-            }
-            if (isHydrate && hydrate) {
-              hydrate(vnode, rootContainer);
-            } else {
-              render(vnode, rootContainer, isSVG);
-            }
-            isMounted = true;
-            app._container = rootContainer;
-            rootContainer.__vue_app__ = app;
-            {
-              app._instance = vnode.component;
-              devtoolsInitApp(app, version);
-            }
-            return getExposeProxy(vnode.component) || vnode.component.proxy;
-          } else {
-            warn(
-              `App has already been mounted.
-If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
-            );
-          }
-        },
-        unmount() {
-          if (isMounted) {
-            render(null, app._container);
-            {
-              app._instance = null;
-              devtoolsUnmountApp(app);
-            }
-            delete app._container.__vue_app__;
-          } else {
-            warn(`Cannot unmount an app that is not mounted.`);
-          }
-        },
-        provide(key, value) {
-          if (key in context.provides) {
-            warn(
-              `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
-            );
+    }
+    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) {
+      const type = children._;
+      if (type) {
+        if (isHmrUpdating) {
+          extend(slots, children);
+        } else if (optimized && type === 1) {
+          needDeletionCheck = false;
+        } else {
+          extend(slots, children);
+          if (!optimized && type === 1) {
+            delete slots._;
           }
-          context.provides[key] = value;
-          return app;
         }
-      };
-      {
-        installAppCompatProperties(app, context, render);
+      } else {
+        needDeletionCheck = !children.$stable;
+        normalizeObjectSlots(children, slots, instance);
       }
-      return app;
-    };
-  }
+      deletionComparisonTarget = children;
+    } else if (children) {
+      normalizeVNodeSlots(instance, children);
+      deletionComparisonTarget = { default: 1 };
+    }
+    if (needDeletionCheck) {
+      for (const key in slots) {
+        if (!isInternalKey(key) && !(key in deletionComparisonTarget)) {
+          delete slots[key];
+        }
+      }
+    }
+  };
 
   function setRef(rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) {
     if (isArray(rawRef)) {
@@ -10376,6 +10385,12 @@ Component that was made reactive: `,
     {
       warnRuntimeUsage(`defineSlots`);
     }
+    return null;
+  }
+  function defineModel() {
+    {
+      warnRuntimeUsage("defineModel");
+    }
   }
   function withDefaults(props, defaults) {
     {
@@ -10389,6 +10404,40 @@ Component that was made reactive: `,
   function useAttrs() {
     return getContext().attrs;
   }
+  function useModel(props, name, options) {
+    const i = getCurrentInstance();
+    if (!i) {
+      warn(`useModel() called without active instance.`);
+      return ref();
+    }
+    if (!i.propsOptions[0][name]) {
+      warn(`useModel() called with prop "${name}" which is not declared.`);
+      return ref();
+    }
+    if (options && options.local) {
+      const proxy = ref(props[name]);
+      watch(
+        () => props[name],
+        (v) => proxy.value = v
+      );
+      watch(proxy, (value) => {
+        if (value !== props[name]) {
+          i.emit(`update:${name}`, value);
+        }
+      });
+      return proxy;
+    } else {
+      return {
+        __v_isRef: true,
+        get value() {
+          return props[name];
+        },
+        set value(value) {
+          i.emit(`update:${name}`, value);
+        }
+      };
+    }
+  }
   function getContext() {
     const i = getCurrentInstance();
     if (!i) {
@@ -10396,11 +10445,14 @@ Component that was made reactive: `,
     }
     return i.setupContext || (i.setupContext = createSetupContext(i));
   }
-  function mergeDefaults(raw, defaults) {
-    const props = isArray(raw) ? raw.reduce(
+  function normalizePropsOrEmits(props) {
+    return isArray(props) ? props.reduce(
       (normalized, p) => (normalized[p] = {}, normalized),
       {}
-    ) : raw;
+    ) : props;
+  }
+  function mergeDefaults(raw, defaults) {
+    const props = normalizePropsOrEmits(raw);
     for (const key in defaults) {
       if (key.startsWith("__skip"))
         continue;
@@ -10422,6 +10474,13 @@ Component that was made reactive: `,
     }
     return props;
   }
+  function mergeModels(a, b) {
+    if (!a || !b)
+      return a || b;
+    if (isArray(a) && isArray(b))
+      return a.concat(b);
+    return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+  }
   function createPropsRestProxy(props, excludedKeys) {
     const ret = {};
     for (const key in props) {
@@ -10681,7 +10740,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.3.0-alpha.7";
+  const version = "3.3.0-alpha.9";
   const ssrUtils = null;
   const resolveFilter = resolveFilter$1 ;
   const _compatUtils = {
@@ -12325,6 +12384,7 @@ Component that was made reactive: `,
     defineCustomElement: defineCustomElement,
     defineEmits: defineEmits,
     defineExpose: defineExpose,
+    defineModel: defineModel,
     defineOptions: defineOptions,
     defineProps: defineProps,
     defineSSRCustomElement: defineSSRCustomElement,
@@ -12352,6 +12412,7 @@ Component that was made reactive: `,
     isVNode: isVNode,
     markRaw: markRaw,
     mergeDefaults: mergeDefaults,
+    mergeModels: mergeModels,
     mergeProps: mergeProps,
     nextTick: nextTick,
     normalizeClass: normalizeClass,
@@ -12410,6 +12471,7 @@ Component that was made reactive: `,
     useAttrs: useAttrs,
     useCssModule: useCssModule,
     useCssVars: useCssVars,
+    useModel: useModel,
     useSSRContext: useSSRContext,
     useSlots: useSlots,
     useTransitionState: useTransitionState,
@@ -16605,7 +16667,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   const seen$1 = /* @__PURE__ */ new WeakSet();
   const transformOnce = (node, context) => {
     if (node.type === 1 && findDir(node, "once", true)) {
-      if (seen$1.has(node) || context.inVOnce) {
+      if (seen$1.has(node) || context.inVOnce || context.inSSR) {
         return;
       }
       seen$1.add(node);