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

package/dist/vue.cjs.js

@@ -3609,33 +3609,41 @@ function setActiveBranch(suspense, branch) {
   }
 }
 
-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.`);
   }
 }
 
@@ -3895,6 +3903,68 @@ function traverse(value, seen) {
   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,
@@ -4699,106 +4769,6 @@ function getCompatListeners(instance) {
   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";
@@ -6139,1179 +6109,1218 @@ function mergeWatchOptions(to, from) {
   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)) {
@@ -10485,6 +10494,12 @@ function defineSlots() {
   {
     warnRuntimeUsage(`defineSlots`);
   }
+  return null;
+}
+function defineModel() {
+  {
+    warnRuntimeUsage("defineModel");
+  }
 }
 function withDefaults(props, defaults) {
   {
@@ -10498,6 +10513,40 @@ function useSlots() {
 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) {
@@ -10505,11 +10554,14 @@ function getContext() {
   }
   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;
@@ -10531,6 +10583,13 @@ function mergeDefaults(raw, defaults) {
   }
   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) {
@@ -10796,7 +10855,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.3.0-alpha.7";
+const version = "3.3.0-alpha.9";
 const _ssrUtils = {
   createComponentInstance,
   setupComponent,
@@ -12453,6 +12512,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   defineCustomElement: defineCustomElement,
   defineEmits: defineEmits,
   defineExpose: defineExpose,
+  defineModel: defineModel,
   defineOptions: defineOptions,
   defineProps: defineProps,
   defineSSRCustomElement: defineSSRCustomElement,
@@ -12480,6 +12540,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   isVNode: isVNode,
   markRaw: markRaw,
   mergeDefaults: mergeDefaults,
+  mergeModels: mergeModels,
   mergeProps: mergeProps,
   nextTick: nextTick,
   normalizeClass: normalizeClass,
@@ -12538,6 +12599,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   useAttrs: useAttrs,
   useCssModule: useCssModule,
   useCssVars: useCssVars,
+  useModel: useModel,
   useSSRContext: useSSRContext,
   useSlots: useSlots,
   useTransitionState: useTransitionState,
@@ -17458,7 +17520,7 @@ const transformText = (node, context) => {
 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);