@vue/compat 3.3.0-alpha.8 → 3.3.0-beta.1

package/dist/vue.global.js

@@ -123,7 +123,7 @@ var Vue = (function () {
     [3]: "FORWARDED"
   };
 
-  const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt";
+  const GLOBALS_WHITE_LISTED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
   const isGloballyWhitelisted = /* @__PURE__ */ makeMap(GLOBALS_WHITE_LISTED);
 
   const range = 2;
@@ -1924,6 +1924,8 @@ var Vue = (function () {
         }
         hmrDirtyComponents.add(oldComp);
       }
+      instance.appContext.propsCache.delete(instance.type);
+      instance.appContext.emitsCache.delete(instance.type);
       instance.appContext.optionsCache.delete(instance.type);
       if (instance.ceReload) {
         hmrDirtyComponents.add(oldComp);
@@ -3239,7 +3241,8 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
     }
   }
   let hasWarned = false;
-  function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+  function createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) {
+    var _a;
     if (!hasWarned) {
       hasWarned = true;
       console[console.info ? "info" : "log"](
@@ -3253,13 +3256,21 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
       n: next,
       o: { parentNode, remove }
     } = rendererInternals;
+    let parentSuspenseId;
+    const isSuspensible = ((_a = vnode.props) == null ? void 0 : _a.suspensible) != null && vnode.props.suspensible !== false;
+    if (isSuspensible) {
+      if (parentSuspense == null ? void 0 : parentSuspense.pendingBranch) {
+        parentSuspenseId = parentSuspense == null ? void 0 : parentSuspense.pendingId;
+        parentSuspense.deps++;
+      }
+    }
     const timeout = vnode.props ? toNumber(vnode.props.timeout) : void 0;
     {
       assertNumber(timeout, `Suspense timeout`);
     }
     const suspense = {
       vnode,
-      parent,
+      parent: parentSuspense,
       parentComponent,
       isSVG,
       container,
@@ -3319,20 +3330,28 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
         setActiveBranch(suspense, pendingBranch);
         suspense.pendingBranch = null;
         suspense.isInFallback = false;
-        let parent2 = suspense.parent;
+        let parent = suspense.parent;
         let hasUnresolvedAncestor = false;
-        while (parent2) {
-          if (parent2.pendingBranch) {
-            parent2.effects.push(...effects);
+        while (parent) {
+          if (parent.pendingBranch) {
+            parent.effects.push(...effects);
             hasUnresolvedAncestor = true;
             break;
           }
-          parent2 = parent2.parent;
+          parent = parent.parent;
         }
         if (!hasUnresolvedAncestor) {
           queuePostFlushCb(effects);
         }
         suspense.effects = [];
+        if (isSuspensible) {
+          if (parentSuspense && parentSuspense.pendingBranch && parentSuspenseId === parentSuspense.pendingId) {
+            parentSuspense.deps--;
+            if (parentSuspense.deps === 0) {
+              parentSuspense.resolve();
+            }
+          }
+        }
         triggerEvent(vnode2, "onResolve");
       },
       fallback(fallbackVNode) {
@@ -3432,13 +3451,13 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
           }
         });
       },
-      unmount(parentSuspense, doRemove) {
+      unmount(parentSuspense2, doRemove) {
         suspense.isUnmounted = true;
         if (suspense.activeBranch) {
           unmount(
             suspense.activeBranch,
             parentComponent,
-            parentSuspense,
+            parentSuspense2,
             doRemove
           );
         }
@@ -3446,7 +3465,7 @@ Details: https://v3-migration.vuejs.org/breaking-changes/migration-build.html`
           unmount(
             suspense.pendingBranch,
             parentComponent,
-            parentSuspense,
+            parentSuspense2,
             doRemove
           );
         }
@@ -3539,33 +3558,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 +3831,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 +4691,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";
@@ -5417,6 +5406,8 @@ If this is a native custom element, make sure to exclude it from component resol
         if (key === "$attrs") {
           track(instance, "get", key);
           markAttrsAccessed();
+        } else if (key === "$slots") {
+          track(instance, "get", key);
         }
         return publicGetter(instance);
       } else if (
@@ -5606,24 +5597,179 @@ If this is a native custom element, make sure to exclude it from component resol
     return to;
   }
 
-  function createDuplicateChecker() {
-    const cache = /* @__PURE__ */ Object.create(null);
-    return (type, key) => {
-      if (cache[key]) {
-        warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
-      } else {
-        cache[key] = type;
-      }
-    };
+  const warnRuntimeUsage = (method) => warn(
+    `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
+  );
+  function defineProps() {
+    {
+      warnRuntimeUsage(`defineProps`);
+    }
+    return null;
   }
-  let shouldCacheAccess = true;
-  function applyOptions(instance) {
-    const options = resolveMergedOptions(instance);
-    const publicThis = instance.proxy;
-    const ctx = instance.ctx;
-    shouldCacheAccess = false;
-    if (options.beforeCreate) {
-      callHook$1(options.beforeCreate, instance, "bc");
+  function defineEmits() {
+    {
+      warnRuntimeUsage(`defineEmits`);
+    }
+    return null;
+  }
+  function defineExpose(exposed) {
+    {
+      warnRuntimeUsage(`defineExpose`);
+    }
+  }
+  function defineOptions(options) {
+    {
+      warnRuntimeUsage(`defineOptions`);
+    }
+  }
+  function defineSlots() {
+    {
+      warnRuntimeUsage(`defineSlots`);
+    }
+    return null;
+  }
+  function defineModel() {
+    {
+      warnRuntimeUsage("defineModel");
+    }
+  }
+  function withDefaults(props, defaults) {
+    {
+      warnRuntimeUsage(`withDefaults`);
+    }
+    return null;
+  }
+  function useSlots() {
+    return getContext().slots;
+  }
+  function useAttrs() {
+    return getContext().attrs;
+  }
+  function 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) {
+      warn(`useContext() called without active instance.`);
+    }
+    return i.setupContext || (i.setupContext = createSetupContext(i));
+  }
+  function normalizePropsOrEmits(props) {
+    return isArray(props) ? props.reduce(
+      (normalized, p) => (normalized[p] = null, normalized),
+      {}
+    ) : props;
+  }
+  function mergeDefaults(raw, defaults) {
+    const props = normalizePropsOrEmits(raw);
+    for (const key in defaults) {
+      if (key.startsWith("__skip"))
+        continue;
+      let opt = props[key];
+      if (opt) {
+        if (isArray(opt) || isFunction(opt)) {
+          opt = props[key] = { type: opt, default: defaults[key] };
+        } else {
+          opt.default = defaults[key];
+        }
+      } else if (opt === null) {
+        opt = props[key] = { default: defaults[key] };
+      } else {
+        warn(`props default key "${key}" has no corresponding declaration.`);
+      }
+      if (opt && defaults[`__skip_${key}`]) {
+        opt.skipFactory = true;
+      }
+    }
+    return props;
+  }
+  function mergeModels(a, b) {
+    if (!a || !b)
+      return a || b;
+    if (isArray(a) && isArray(b))
+      return a.concat(b);
+    return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
+  }
+  function createPropsRestProxy(props, excludedKeys) {
+    const ret = {};
+    for (const key in props) {
+      if (!excludedKeys.includes(key)) {
+        Object.defineProperty(ret, key, {
+          enumerable: true,
+          get: () => props[key]
+        });
+      }
+    }
+    return ret;
+  }
+  function withAsyncContext(getAwaitable) {
+    const ctx = getCurrentInstance();
+    if (!ctx) {
+      warn(
+        `withAsyncContext called without active current instance. This is likely a bug.`
+      );
+    }
+    let awaitable = getAwaitable();
+    unsetCurrentInstance();
+    if (isPromise(awaitable)) {
+      awaitable = awaitable.catch((e) => {
+        setCurrentInstance(ctx);
+        throw e;
+      });
+    }
+    return [awaitable, () => setCurrentInstance(ctx)];
+  }
+
+  function createDuplicateChecker() {
+    const cache = /* @__PURE__ */ Object.create(null);
+    return (type, key) => {
+      if (cache[key]) {
+        warn(`${type} property "${key}" is already defined in ${cache[key]}.`);
+      } else {
+        cache[key] = type;
+      }
+    };
+  }
+  let shouldCacheAccess = true;
+  function applyOptions(instance) {
+    const options = resolveMergedOptions(instance);
+    const publicThis = instance.proxy;
+    const ctx = instance.ctx;
+    shouldCacheAccess = false;
+    if (options.beforeCreate) {
+      callHook$1(options.beforeCreate, instance, "bc");
     }
     const {
       // state
@@ -5668,12 +5814,7 @@ If this is a native custom element, make sure to exclude it from component resol
       }
     }
     if (injectOptions) {
-      resolveInjections(
-        injectOptions,
-        ctx,
-        checkDuplicateProperties,
-        instance.appContext.config.unwrapInjectedRef
-      );
+      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
     }
     if (methods) {
       for (const key in methods) {
@@ -5824,7 +5965,7 @@ If this is a native custom element, make sure to exclude it from component resol
       instance.filters = filters;
     }
   }
-  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
+  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
     if (isArray(injectOptions)) {
       injectOptions = normalizeInject(injectOptions);
     }
@@ -5846,21 +5987,12 @@ If this is a native custom element, make sure to exclude it from component resol
         injected = inject(opt);
       }
       if (isRef(injected)) {
-        if (unwrapRef) {
-          Object.defineProperty(ctx, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => injected.value,
-            set: (v) => injected.value = v
-          });
-        } else {
-          {
-            warn(
-              `injected property "${key}" is a ref and will be auto-unwrapped and no longer needs \`.value\` in the next minor release. To opt-in to the new behavior now, set \`app.config.unwrapInjectedRef = true\` (this config is temporary and will not be needed in the future.)`
-            );
-          }
-          ctx[key] = injected;
-        }
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => injected.value,
+          set: (v) => injected.value = v
+        });
       } else {
         ctx[key] = injected;
       }
@@ -5963,10 +6095,8 @@ If this is a native custom element, make sure to exclude it from component resol
   }
   const internalOptionMergeStrats = {
     data: mergeDataFn,
-    props: mergeObjectOptions,
-    // TODO
-    emits: mergeObjectOptions,
-    // TODO
+    props: mergeEmitsOrPropsOptions,
+    emits: mergeEmitsOrPropsOptions,
     // objects
     methods: mergeObjectOptions,
     computed: mergeObjectOptions,
@@ -6028,7 +6158,21 @@ If this is a native custom element, make sure to exclude it from component resol
     return to ? [...new Set([].concat(to, from))] : from;
   }
   function mergeObjectOptions(to, from) {
-    return to ? extend(extend(/* @__PURE__ */ Object.create(null), to), from) : from;
+    return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+  }
+  function mergeEmitsOrPropsOptions(to, from) {
+    if (to) {
+      if (isArray(to) && isArray(from)) {
+        return [.../* @__PURE__ */ new Set([...to, ...from])];
+      }
+      return extend(
+        /* @__PURE__ */ Object.create(null),
+        normalizePropsOrEmits(to),
+        normalizePropsOrEmits(from != null ? from : {})
+      );
+    } else {
+      return from;
+    }
   }
   function mergeWatchOptions(to, from) {
     if (!to)
@@ -6042,1179 +6186,1234 @@ 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;
+      }
+      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;
       }
     }
-    {
-      validateProps(rawProps || {}, props, instance);
-    }
-    if (isStateful) {
-      instance.props = isSSR ? props : shallowReactive(props);
-    } else {
-      if (!instance.type.props) {
-        instance.props = attrs;
+    Vue.version = `2.6.14-compat:${"3.3.0-beta.1"}`;
+    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 {
-        instance.props = props;
+        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);
+      }
+      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;
     }
-    instance.attrs = attrs;
+    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;
   }
-  function isInHmrContext(instance) {
-    while (instance) {
-      if (instance.type.__hmrId)
-        return true;
-      instance = instance.parent;
+  function installAppCompatProperties(app, context, render) {
+    installFilterMethod(app, context);
+    installLegacyOptionMergeStrats(app.config);
+    if (!singletonApp) {
+      return;
     }
+    installCompatMount(app, context, render);
+    installLegacyAPIs(app);
+    applySingletonAppMutations(app);
+    installLegacyConfigWarnings(app.config);
   }
-  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;
-            }
-          }
-        }
+  function installFilterMethod(app, context) {
+    context.filters = {};
+    app.filter = (name, filter) => {
+      assertCompatEnabled("FILTERS", null);
+      if (!filter) {
+        return context.filters[name];
       }
-    } else {
-      if (setFullProps(instance, rawProps, props, attrs)) {
-        hasAttrsChanged = true;
+      if (context.filters[name]) {
+        warn(`Filter "${name}" has already been registered.`);
       }
-      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];
-          }
+      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 (attrs !== rawCurrentProps) {
-        for (const key in attrs) {
-          if (!rawProps || !hasOwn(rawProps, key) && !hasOwn(rawProps, key + "Native")) {
-            delete attrs[key];
-            hasAttrsChanged = true;
-          }
+      },
+      nextTick: { value: nextTick },
+      extend: { value: singletonCtor.extend },
+      set: { value: singletonCtor.set },
+      delete: { value: singletonCtor.delete },
+      observable: { value: singletonCtor.observable },
+      util: {
+        get() {
+          return singletonCtor.util;
         }
       }
+    });
+  }
+  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;
+      }
+      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 (hasAttrsChanged) {
-      trigger(instance, "set", "$attrs");
-    }
-    {
-      validateProps(rawProps || {}, props, instance);
+    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);
+    }
+    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]
+          );
+        }
+      }
+    }
+    if (hasPrototypeAugmentations) {
+      warnDeprecation$1("GLOBAL_PROTOTYPE", null);
     }
   }
-  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;
+  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;
         }
-        {
-          if (key.startsWith("onHook:")) {
-            softAssertCompatEnabled(
-              "INSTANCE_EVENT_HOOKS",
-              instance,
-              key.slice(2).toLowerCase()
+        let container;
+        if (typeof selectorOrEl === "string") {
+          const result = document.querySelector(selectorOrEl);
+          if (!result) {
+            warn(
+              `Failed to mount root instance: selector "${selectorOrEl}" returned null.`
             );
+            return;
           }
-          if (key === "inline-template") {
-            continue;
-          }
+          container = result;
+        } else {
+          container = selectorOrEl || document.createElement("div");
         }
-        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)) {
+        const isSVG = container instanceof SVGElement;
+        {
+          context.reload = () => {
+            const cloned = cloneVNode(vnode);
+            cloned.component = null;
+            render(cloned, container, isSVG);
+          };
+        }
+        if (hasNoRender && instance.render === emptyRender) {
           {
-            if (isOn(key) && key.endsWith("Native")) {
-              key = key.slice(0, -6);
-            } else if (shouldSkipAttr(key, instance)) {
-              continue;
+            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;
+              }
             }
           }
-          if (!(key in attrs) || value !== attrs[key]) {
-            attrs[key] = value;
-            hasAttrsChanged = true;
-          }
+          instance.render = null;
+          component.template = container.innerHTML;
+          finishComponentSetup(
+            instance,
+            false,
+            true
+            /* skip options */
+          );
         }
-      }
-    }
-    if (needCastKeys) {
-      const rawCurrentProps = toRaw(props);
-      const castValues = rawCastValues || EMPTY_OBJ;
-      for (let i = 0; i < needCastKeys.length; i++) {
-        const key = needCastKeys[i];
-        props[key] = resolvePropValue(
-          options,
-          rawCurrentProps,
-          key,
-          castValues[key],
-          instance,
-          !hasOwn(castValues, key)
-        );
-      }
-    }
-    return hasAttrsChanged;
-  }
-  function resolvePropValue(options, props, key, value, instance, isAbsent) {
-    const opt = options[key];
-    if (opt != null) {
-      const hasDefault = hasOwn(opt, "default");
-      if (hasDefault && value === void 0) {
-        const defaultValue = opt.default;
-        if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
-          const { propsDefaults } = instance;
-          if (key in propsDefaults) {
-            value = propsDefaults[key];
-          } else {
-            setCurrentInstance(instance);
-            value = propsDefaults[key] = defaultValue.call(
-              isCompatEnabled$1("PROPS_DEFAULT_THIS", instance) ? createPropsDefaultThis(instance, props, key) : null,
-              props
-            );
-            unsetCurrentInstance();
+        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 {
-          value = defaultValue;
-        }
-      }
-      if (opt[0 /* shouldCast */]) {
-        if (isAbsent && !hasDefault) {
-          value = false;
-        } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
-          value = true;
+          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) {
+          }
+        });
       }
     }
-    return value;
+    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 {
+      defineReactiveSimple(obj, key, val);
+    }
   }
-  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;
-        }
-        hasExtends = true;
-        const [props, keys] = normalizePropsOptions(raw2, appContext, true);
-        extend(normalized, props);
-        if (keys)
-          needCastKeys.push(...keys);
-      };
-      if (!asMixin && appContext.mixins.length) {
-        appContext.mixins.forEach(extendProps);
-      }
-      if (comp.extends) {
-        extendProps(comp.extends);
-      }
-      if (comp.mixins) {
-        comp.mixins.forEach(extendProps);
+  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);
       }
-    }
-    if (!raw && !hasExtends) {
-      if (isObject(comp)) {
-        cache.set(comp, EMPTY_ARR);
+    });
+  }
+
+  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);
       }
-      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]);
-        }
-        const normalizedKey = camelize(raw[i]);
-        if (validatePropName(normalizedKey)) {
-          normalized[normalizedKey] = EMPTY_OBJ;
-        }
+      if (rootProps != null && !isObject(rootProps)) {
+        warn(`root props passed to app.mount() must be an object.`);
+        rootProps = null;
       }
-    } else if (raw) {
-      if (!isObject(raw)) {
-        warn(`invalid props options`, raw);
+      const context = createAppContext();
+      {
+        Object.defineProperty(context.config, "unwrapInjectedRef", {
+          get() {
+            return true;
+          },
+          set() {
+            warn(
+              `app.config.unwrapInjectedRef has been deprecated. 3.3 now alawys unwraps injected refs in Options API.`
+            );
+          }
+        });
       }
-      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);
+      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);
       }
-    }
-    const res = [normalized, needCastKeys];
-    if (isObject(comp)) {
-      cache.set(comp, res);
-    }
-    return res;
+      return app;
+    };
   }
-  function validatePropName(key) {
-    if (key[0] !== "$") {
-      return true;
+  let currentApp = null;
+
+  function provide(key, value) {
+    if (!currentInstance) {
+      {
+        warn(`provide() can only be used inside setup().`);
+      }
     } else {
-      warn(`Invalid prop name: "${key}" is a reserved property.`);
+      let provides = currentInstance.provides;
+      const parentProvides = currentInstance.parent && currentInstance.parent.provides;
+      if (parentProvides === provides) {
+        provides = currentInstance.provides = Object.create(parentProvides);
+      }
+      provides[key] = value;
     }
-    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;
+  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 {
+      warn(`inject() can only be used inside setup() or functional components.`);
     }
-    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 hasInjectionContext() {
+    return !!(currentInstance || currentRenderingInstance || currentApp);
   }
-  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;
-      }
-      if (!isValid) {
-        warn(getInvalidTypeMessage(name, value, expectedTypes));
-        return;
+
+  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);
+            }
+          }
+        }
       }
-    }
-    if (validator && !validator(value)) {
-      warn('Invalid prop: custom validator check failed for prop "' + name + '".');
-    }
+    );
   }
-  const isSimpleType = /* @__PURE__ */ makeMap(
-    "String,Number,Boolean,Function,Symbol,BigInt"
-  );
-  function assertType(value, type) {
-    let valid;
-    const expectedType = getType(type);
-    if (isSimpleType(expectedType)) {
-      const t = typeof value;
-      valid = t === expectedType.toLowerCase();
-      if (!valid && t === "object") {
-        valid = value instanceof type;
-      }
-    } else if (expectedType === "Object") {
-      valid = isObject(value);
-    } else if (expectedType === "Array") {
-      valid = isArray(value);
-    } else if (expectedType === "null") {
-      valid = value === null;
-    } else {
-      valid = value instanceof type;
+
+  function shouldSkipAttr(key, instance) {
+    if (key === "is") {
+      return true;
     }
-    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}`;
+    if ((key === "class" || key === "style") && isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance)) {
+      return true;
     }
-    message += `, got ${receivedType} `;
-    if (isExplicable(receivedType)) {
-      message += `with value ${receivedValue}.`;
+    if (isOn(key) && isCompatEnabled$1("INSTANCE_LISTENERS", 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 (key.startsWith("routerView") || key === "registerRouteInstance") {
+      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");
+    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);
-      } else {
-        normalizeObjectSlots(
-          children,
-          instance.slots = {},
-          instance
-        );
-      }
+    if (isStateful) {
+      instance.props = isSSR ? props : shallowReactive(props);
     } else {
-      instance.slots = {};
-      if (children) {
-        normalizeVNodeSlots(instance, children);
+      if (!instance.type.props) {
+        instance.props = attrs;
+      } else {
+        instance.props = props;
       }
     }
-    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._;
+    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 {
-        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];
+    } else {
+      if (setFullProps(instance, rawProps, props, attrs)) {
+        hasAttrsChanged = true;
+      }
+      let kebabKey;
+      for (const key in rawCurrentProps) {
+        if (!rawProps || // for camelCase
+        !hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
+        // and converted to camelCase (#955)
+        ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
+          if (options) {
+            if (rawPrevProps && // for camelCase
+            (rawPrevProps[key] !== void 0 || // for kebab-case
+            rawPrevProps[kebabKey] !== void 0)) {
+              props[key] = resolvePropValue(
+                options,
+                rawCurrentProps,
+                key,
+                void 0,
+                instance,
+                true
+                /* isAbsent */
+              );
+            }
+          } else {
+            delete props[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);
+      if (attrs !== rawCurrentProps) {
+        for (const key in attrs) {
+          if (!rawProps || !hasOwn(rawProps, key) && !hasOwn(rawProps, key + "Native")) {
+            delete attrs[key];
+            hasAttrsChanged = true;
           }
-          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;
+          }
         }
       }
-    });
+    }
+    if (needCastKeys) {
+      const rawCurrentProps = toRaw(props);
+      const castValues = rawCastValues || EMPTY_OBJ;
+      for (let i = 0; i < needCastKeys.length; i++) {
+        const key = needCastKeys[i];
+        props[key] = resolvePropValue(
+          options,
+          rawCurrentProps,
+          key,
+          castValues[key],
+          instance,
+          !hasOwn(castValues, key)
+        );
+      }
+    }
+    return hasAttrsChanged;
   }
-
-  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;
+  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;
+        }
       }
-      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;
+      if (opt[0 /* shouldCast */]) {
+        if (isAbsent && !hasDefault) {
+          value = false;
+        } else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
+          value = true;
+        }
       }
     }
-    Vue.version = `2.6.14-compat:${"3.3.0-alpha.8"}`;
-    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);
+    return value;
+  }
+  function normalizePropsOptions(comp, appContext, asMixin = false) {
+    const cache = appContext.propsCache;
+    const cached = cache.get(comp);
+    if (cached) {
+      return cached;
+    }
+    const raw = comp.props;
+    const normalized = {};
+    const needCastKeys = [];
+    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);
       }
-    };
-    Vue.directive = (name, dir) => {
-      if (dir) {
-        singletonApp.directive(name, dir);
-        return Vue;
-      } else {
-        return singletonApp.directive(name);
+      if (comp.extends) {
+        extendProps(comp.extends);
       }
-    };
-    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 (comp.mixins) {
+        comp.mixins.forEach(extendProps);
       }
-      if (extendCache.has(extendOptions)) {
-        return extendCache.get(extendOptions);
+    }
+    if (!raw && !hasExtends) {
+      if (isObject(comp)) {
+        cache.set(comp, EMPTY_ARR);
       }
-      const Super = this;
-      function SubVue(inlineOptions) {
-        if (!inlineOptions) {
-          return createCompatApp(SubVue.options, SubVue);
-        } else {
-          return createCompatApp(
-            mergeOptions(
-              extend({}, SubVue.options),
-              inlineOptions,
-              internalOptionMergeStrats
-            ),
-            SubVue
-          );
+      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]);
+        }
+        const normalizedKey = camelize(raw[i]);
+        if (validatePropName(normalizedKey)) {
+          normalized[normalizedKey] = EMPTY_OBJ;
         }
       }
-      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;
+    } else if (raw) {
+      if (!isObject(raw)) {
+        warn(`invalid props options`, raw);
       }
-      SubVue.options = mergeOptions(
-        mergeBase,
-        extendOptions,
-        internalOptionMergeStrats
+      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);
+            }
+          }
+        }
+      }
+    }
+    const res = [normalized, needCastKeys];
+    if (isObject(comp)) {
+      cache.set(comp, res);
+    }
+    return res;
+  }
+  function validatePropName(key) {
+    if (key[0] !== "$") {
+      return true;
+    } else {
+      warn(`Invalid prop name: "${key}" is a reserved property.`);
+    }
+    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))
       );
-      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;
   }
-  function installAppCompatProperties(app, context, render) {
-    installFilterMethod(app, context);
-    installLegacyOptionMergeStrats(app.config);
-    if (!singletonApp) {
+  function validateProp(name, value, prop, isAbsent) {
+    const { type, required, validator, skipCheck } = prop;
+    if (required && isAbsent) {
+      warn('Missing required prop: "' + name + '"');
       return;
     }
-    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];
+    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 (context.filters[name]) {
-        warn(`Filter "${name}" has already been registered.`);
+      if (!isValid) {
+        warn(getInvalidTypeMessage(name, value, expectedTypes));
+        return;
       }
-      context.filters[name] = filter;
-      return app;
-    };
+    }
+    if (validator && !validator(value)) {
+      warn('Invalid prop: custom validator check failed for prop "' + name + '".');
+    }
   }
-  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;
-        }
-      }
-    });
-  }
-  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;
-      }
-      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));
-        };
-      }
-    }
-    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);
-    }
-    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]
-          );
-        }
-      }
-    }
-    if (hasPrototypeAugmentations) {
-      warnDeprecation$1("GLOBAL_PROTOTYPE", null);
-    }
-  }
-  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 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;
       }
-    }
-    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 if (expectedType === "Object") {
+      valid = isObject(value);
+    } else if (expectedType === "Array") {
+      valid = isArray(value);
+    } else if (expectedType === "null") {
+      valid = value === null;
     } else {
-      defineReactiveSimple(obj, key, val);
+      valid = value instanceof type;
     }
-  }
-  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 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()
+      valid,
+      expectedType
     };
   }
-  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.`
-            );
+  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}`;
+    }
+    message += `, got ${receivedType} `;
+    if (isExplicable(receivedType)) {
+      message += `with value ${receivedValue}.`;
+    }
+    return message;
+  }
+  function styleValue(value, type) {
+    if (type === "String") {
+      return `"${value}"`;
+    } else if (type === "Number") {
+      return `${Number(value)}`;
+    } else {
+      return `${value}`;
+    }
+  }
+  function isExplicable(type) {
+    const explicitTypes = ["string", "number", "boolean"];
+    return explicitTypes.some((elem) => type.toLowerCase() === elem);
+  }
+  function isBoolean(...args) {
+    return args.some((elem) => elem.toLowerCase() === "boolean");
+  }
+
+  const isInternalKey = (key) => key[0] === "_" || key === "$stable";
+  const normalizeSlotValue = (value) => isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)];
+  const normalizeSlot = (key, rawSlot, ctx) => {
+    if (rawSlot._n) {
+      return rawSlot;
+    }
+    const normalized = withCtx((...args) => {
+      if (currentInstance) {
+        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;
+      }
+    }
+  };
+  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
+        );
+      }
+    } else {
+      instance.slots = {};
+      if (children) {
+        normalizeVNodeSlots(instance, children);
+      }
+    }
+    def(instance.slots, InternalObjectKey, 1);
+  };
+  const updateSlots = (instance, children, optimized) => {
+    const { vnode, slots } = instance;
+    let needDeletionCheck = true;
+    let deletionComparisonTarget = EMPTY_OBJ;
+    if (vnode.shapeFlag & 32) {
+      const type = children._;
+      if (type) {
+        if (isHmrUpdating) {
+          extend(slots, children);
+          trigger(instance, "set", "$slots");
+        } 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)) {
@@ -8118,7 +8317,7 @@ If you want to remount the same app, move your app creation logic into a factory
           areChildrenSVG,
           slotScopeIds
         );
-        if (parentComponent && parentComponent.type.__hmrId) {
+        {
           traverseStaticChildren(n1, n2);
         }
       } else if (!optimized) {
@@ -8314,21 +8513,8 @@ If you want to remount the same app, move your app creation logic into a factory
             isSVG,
             slotScopeIds
           );
-          if (parentComponent && parentComponent.type.__hmrId) {
+          {
             traverseStaticChildren(n1, n2);
-          } else if (
-            // #2080 if the stable fragment has a key, it's a <template v-for> that may
-            //  get moved around. Make sure all root level vnodes inherit el.
-            // #2134 or if it's a component root, it may also get moved around
-            // as the component is being moved.
-            n2.key != null || parentComponent && n2 === parentComponent.subTree
-          ) {
-            traverseStaticChildren(
-              n1,
-              n2,
-              true
-              /* shallow */
-            );
           }
         } else {
           patchChildren(
@@ -9997,6 +10183,8 @@ Component that was made reactive: `,
       refs: EMPTY_OBJ,
       setupState: EMPTY_OBJ,
       setupContext: null,
+      attrsProxy: null,
+      slotsProxy: null,
       // suspense related
       suspense,
       suspenseId: suspense ? suspense.pendingId : 0,
@@ -10236,8 +10424,8 @@ Component that was made reactive: `,
       }
     }
   }
-  function createAttrsProxy(instance) {
-    return new Proxy(
+  function getAttrsProxy(instance) {
+    return instance.attrsProxy || (instance.attrsProxy = new Proxy(
       instance.attrs,
       {
         get(target, key) {
@@ -10254,7 +10442,23 @@ Component that was made reactive: `,
           return false;
         }
       } 
-    );
+    ));
+  }
+  function getSlotsProxy(instance) {
+    return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+      get(target, key) {
+        track(instance, "get", "$slots");
+        return target[key];
+      },
+      set() {
+        warn(`setupContext.slots is readonly.`);
+        return false;
+      },
+      deleteProperty() {
+        warn(`setupContext.slots is readonly.`);
+        return false;
+      }
+    }));
   }
   function createSetupContext(instance) {
     const expose = (exposed) => {
@@ -10280,14 +10484,13 @@ Component that was made reactive: `,
       }
       instance.exposed = exposed || {};
     };
-    let attrs;
     {
       return Object.freeze({
         get attrs() {
-          return attrs || (attrs = createAttrsProxy(instance));
+          return getAttrsProxy(instance);
         },
         get slots() {
-          return shallowReadonly(instance.slots);
+          return getSlotsProxy(instance);
         },
         get emit() {
           return (event, ...args) => instance.emit(event, ...args);
@@ -10347,111 +10550,6 @@ Component that was made reactive: `,
     return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
   };
 
-  const warnRuntimeUsage = (method) => warn(
-    `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
-  );
-  function defineProps() {
-    {
-      warnRuntimeUsage(`defineProps`);
-    }
-    return null;
-  }
-  function defineEmits() {
-    {
-      warnRuntimeUsage(`defineEmits`);
-    }
-    return null;
-  }
-  function defineExpose(exposed) {
-    {
-      warnRuntimeUsage(`defineExpose`);
-    }
-  }
-  function defineOptions(options) {
-    {
-      warnRuntimeUsage(`defineOptions`);
-    }
-  }
-  function defineSlots() {
-    {
-      warnRuntimeUsage(`defineSlots`);
-    }
-  }
-  function withDefaults(props, defaults) {
-    {
-      warnRuntimeUsage(`withDefaults`);
-    }
-    return null;
-  }
-  function useSlots() {
-    return getContext().slots;
-  }
-  function useAttrs() {
-    return getContext().attrs;
-  }
-  function getContext() {
-    const i = getCurrentInstance();
-    if (!i) {
-      warn(`useContext() called without active instance.`);
-    }
-    return i.setupContext || (i.setupContext = createSetupContext(i));
-  }
-  function mergeDefaults(raw, defaults) {
-    const props = isArray(raw) ? raw.reduce(
-      (normalized, p) => (normalized[p] = {}, normalized),
-      {}
-    ) : raw;
-    for (const key in defaults) {
-      if (key.startsWith("__skip"))
-        continue;
-      let opt = props[key];
-      if (opt) {
-        if (isArray(opt) || isFunction(opt)) {
-          opt = props[key] = { type: opt, default: defaults[key] };
-        } else {
-          opt.default = defaults[key];
-        }
-      } else if (opt === null) {
-        opt = props[key] = { default: defaults[key] };
-      } else {
-        warn(`props default key "${key}" has no corresponding declaration.`);
-      }
-      if (opt && defaults[`__skip_${key}`]) {
-        opt.skipFactory = true;
-      }
-    }
-    return props;
-  }
-  function createPropsRestProxy(props, excludedKeys) {
-    const ret = {};
-    for (const key in props) {
-      if (!excludedKeys.includes(key)) {
-        Object.defineProperty(ret, key, {
-          enumerable: true,
-          get: () => props[key]
-        });
-      }
-    }
-    return ret;
-  }
-  function withAsyncContext(getAwaitable) {
-    const ctx = getCurrentInstance();
-    if (!ctx) {
-      warn(
-        `withAsyncContext called without active current instance. This is likely a bug.`
-      );
-    }
-    let awaitable = getAwaitable();
-    unsetCurrentInstance();
-    if (isPromise(awaitable)) {
-      awaitable = awaitable.catch((e) => {
-        setCurrentInstance(ctx);
-        throw e;
-      });
-    }
-    return [awaitable, () => setCurrentInstance(ctx)];
-  }
-
   function h(type, propsOrChildren, children) {
     const l = arguments.length;
     if (l === 2) {
@@ -10681,7 +10779,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.3.0-alpha.8";
+  const version = "3.3.0-beta.1";
   const ssrUtils = null;
   const resolveFilter = resolveFilter$1 ;
   const _compatUtils = {
@@ -12325,6 +12423,7 @@ Component that was made reactive: `,
     defineCustomElement: defineCustomElement,
     defineEmits: defineEmits,
     defineExpose: defineExpose,
+    defineModel: defineModel,
     defineOptions: defineOptions,
     defineProps: defineProps,
     defineSSRCustomElement: defineSSRCustomElement,
@@ -12338,6 +12437,7 @@ Component that was made reactive: `,
     guardReactiveProps: guardReactiveProps,
     h: h,
     handleError: handleError,
+    hasInjectionContext: hasInjectionContext,
     hydrate: hydrate,
     initCustomFormatter: initCustomFormatter,
     initDirectivesForSSR: initDirectivesForSSR,
@@ -12352,6 +12452,7 @@ Component that was made reactive: `,
     isVNode: isVNode,
     markRaw: markRaw,
     mergeDefaults: mergeDefaults,
+    mergeModels: mergeModels,
     mergeProps: mergeProps,
     nextTick: nextTick,
     normalizeClass: normalizeClass,
@@ -12410,6 +12511,7 @@ Component that was made reactive: `,
     useAttrs: useAttrs,
     useCssModule: useCssModule,
     useCssVars: useCssVars,
+    useModel: useModel,
     useSSRContext: useSSRContext,
     useSlots: useSlots,
     useTransitionState: useTransitionState,
@@ -12537,8 +12639,11 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     [48]: `ES module mode is not supported in this build of compiler.`,
     [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
     [50]: `"scopeId" option is only supported in module mode.`,
+    // deprecations
+    [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
+    [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
     // just to fulfill types
-    [51]: ``
+    [53]: ``
   };
 
   const FRAGMENT = Symbol(`Fragment` );
@@ -15904,6 +16009,11 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     }
     const isDir = !isExplicitDynamic && findDir(node, "is");
     if (isDir && isDir.exp) {
+      {
+        context.onWarn(
+          createCompilerError(52, isDir.loc)
+        );
+      }
       return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
         isDir.exp
       ]);
@@ -16409,6 +16519,11 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (arg.type === 4) {
       if (arg.isStatic) {
         let rawName = arg.content;
+        if (rawName.startsWith("vnode")) {
+          context.onWarn(
+            createCompilerError(51, arg.loc)
+          );
+        }
         if (rawName.startsWith("vue:")) {
           rawName = `vnode-${rawName.slice(4)}`;
         }
@@ -16605,7 +16720,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);
@@ -17056,29 +17171,29 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     );
   }
   const DOMErrorMessages = {
-    [51]: `v-html is missing expression.`,
-    [52]: `v-html will override element children.`,
-    [53]: `v-text is missing expression.`,
-    [54]: `v-text will override element children.`,
-    [55]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
-    [56]: `v-model argument is not supported on plain elements.`,
-    [57]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
-    [58]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
-    [59]: `v-show is missing expression.`,
-    [60]: `<Transition> expects exactly one child element or component.`,
-    [61]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
+    [53]: `v-html is missing expression.`,
+    [54]: `v-html will override element children.`,
+    [55]: `v-text is missing expression.`,
+    [56]: `v-text will override element children.`,
+    [57]: `v-model can only be used on <input>, <textarea> and <select> elements.`,
+    [58]: `v-model argument is not supported on plain elements.`,
+    [59]: `v-model cannot be used on file inputs since they are read-only. Use a v-on:change listener instead.`,
+    [60]: `Unnecessary value binding used alongside v-model. It will interfere with v-model's behavior.`,
+    [61]: `v-show is missing expression.`,
+    [62]: `<Transition> expects exactly one child element or component.`,
+    [63]: `Tags with side effect (<script> and <style>) are ignored in client component templates.`
   };
 
   const transformVHtml = (dir, node, context) => {
     const { exp, loc } = dir;
     if (!exp) {
       context.onError(
-        createDOMCompilerError(51, loc)
+        createDOMCompilerError(53, loc)
       );
     }
     if (node.children.length) {
       context.onError(
-        createDOMCompilerError(52, loc)
+        createDOMCompilerError(54, loc)
       );
       node.children.length = 0;
     }
@@ -17096,12 +17211,12 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     const { exp, loc } = dir;
     if (!exp) {
       context.onError(
-        createDOMCompilerError(53, loc)
+        createDOMCompilerError(55, loc)
       );
     }
     if (node.children.length) {
       context.onError(
-        createDOMCompilerError(54, loc)
+        createDOMCompilerError(56, loc)
       );
       node.children.length = 0;
     }
@@ -17127,7 +17242,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (dir.arg) {
       context.onError(
         createDOMCompilerError(
-          56,
+          58,
           dir.arg.loc
         )
       );
@@ -17137,7 +17252,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       if (value) {
         context.onError(
           createDOMCompilerError(
-            58,
+            60,
             value.loc
           )
         );
@@ -17165,7 +17280,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
                 isInvalidType = true;
                 context.onError(
                   createDOMCompilerError(
-                    57,
+                    59,
                     dir.loc
                   )
                 );
@@ -17191,7 +17306,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     } else {
       context.onError(
         createDOMCompilerError(
-          55,
+          57,
           dir.loc
         )
       );
@@ -17303,7 +17418,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     const { exp, loc } = dir;
     if (!exp) {
       context.onError(
-        createDOMCompilerError(59, loc)
+        createDOMCompilerError(61, loc)
       );
     }
     return {
@@ -17323,7 +17438,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
           if (hasMultipleChildren(node)) {
             context.onError(
               createDOMCompilerError(
-                60,
+                62,
                 {
                   start: node.children[0].loc.start,
                   end: node.children[node.children.length - 1].loc.end,
@@ -17360,7 +17475,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   const ignoreSideEffectTags = (node, context) => {
     if (node.type === 1 && node.tagType === 0 && (node.tag === "script" || node.tag === "style")) {
       context.onError(
-        createDOMCompilerError(61, node.loc)
+        createDOMCompilerError(63, node.loc)
       );
       context.removeNode();
     }