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

package/dist/vue.cjs.js

@@ -2,7 +2,7 @@
 
 var parser = require('@babel/parser');
 var estreeWalker = require('estree-walker');
-var sourceMap = require('source-map');
+var sourceMapJs = require('source-map-js');
 
 function makeMap(str, expectsLowerCase) {
   const map = /* @__PURE__ */ Object.create(null);
@@ -130,7 +130,7 @@ const slotFlagsText = {
   [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;
@@ -1994,6 +1994,8 @@ function reload(id, newComp) {
       }
       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);
@@ -3309,7 +3311,8 @@ function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotSc
   }
 }
 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"](
@@ -3323,13 +3326,21 @@ function createSuspenseBoundary(vnode, parent, parentComponent, container, hidde
     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,
@@ -3389,20 +3400,28 @@ function createSuspenseBoundary(vnode, parent, parentComponent, container, hidde
       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) {
@@ -3502,13 +3521,13 @@ function createSuspenseBoundary(vnode, parent, parentComponent, container, hidde
         }
       });
     },
-    unmount(parentSuspense, doRemove) {
+    unmount(parentSuspense2, doRemove) {
       suspense.isUnmounted = true;
       if (suspense.activeBranch) {
         unmount(
           suspense.activeBranch,
           parentComponent,
-          parentSuspense,
+          parentSuspense2,
           doRemove
         );
       }
@@ -3516,7 +3535,7 @@ function createSuspenseBoundary(vnode, parent, parentComponent, container, hidde
         unmount(
           suspense.pendingBranch,
           parentComponent,
-          parentSuspense,
+          parentSuspense2,
           doRemove
         );
       }
@@ -3609,33 +3628,41 @@ function setActiveBranch(suspense, branch) {
   }
 }
 
-function provide(key, value) {
-  if (!currentInstance) {
-    {
-      warn(`provide() can only be used inside setup().`);
-    }
-  } else {
-    let provides = currentInstance.provides;
-    const parentProvides = currentInstance.parent && currentInstance.parent.provides;
-    if (parentProvides === provides) {
-      provides = currentInstance.provides = Object.create(parentProvides);
-    }
-    provides[key] = value;
-  }
-}
-function inject(key, defaultValue, treatDefaultAsFactory = false) {
-  const instance = currentInstance || currentRenderingInstance;
-  if (instance) {
-    const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides;
-    if (provides && key in provides) {
-      return provides[key];
-    } else if (arguments.length > 1) {
-      return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue;
+const legacyDirectiveHookMap = {
+  beforeMount: "bind",
+  mounted: "inserted",
+  updated: ["update", "componentUpdated"],
+  unmounted: "unbind"
+};
+function mapCompatDirectiveHook(name, dir, instance) {
+  const mappedName = legacyDirectiveHookMap[name];
+  if (mappedName) {
+    if (isArray(mappedName)) {
+      const hook = [];
+      mappedName.forEach((mapped) => {
+        const mappedHook = dir[mapped];
+        if (mappedHook) {
+          softAssertCompatEnabled(
+            "CUSTOM_DIR",
+            instance,
+            mapped,
+            name
+          );
+          hook.push(mappedHook);
+        }
+      });
+      return hook.length ? hook : void 0;
     } else {
-      warn(`injection "${String(key)}" not found.`);
+      if (dir[mappedName]) {
+        softAssertCompatEnabled(
+          "CUSTOM_DIR",
+          instance,
+          mappedName,
+          name
+        );
+      }
+      return dir[mappedName];
     }
-  } else {
-    warn(`inject() can only be used inside setup() or functional components.`);
   }
 }
 
@@ -3895,6 +3922,68 @@ function traverse(value, seen) {
   return value;
 }
 
+function validateDirectiveName(name) {
+  if (isBuiltInDirective(name)) {
+    warn("Do not use built-in directive ids as custom directive id: " + name);
+  }
+}
+function withDirectives(vnode, directives) {
+  const internalInstance = currentRenderingInstance;
+  if (internalInstance === null) {
+    warn(`withDirectives can only be used inside render functions.`);
+    return vnode;
+  }
+  const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
+  const bindings = vnode.dirs || (vnode.dirs = []);
+  for (let i = 0; i < directives.length; i++) {
+    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
+    if (dir) {
+      if (isFunction(dir)) {
+        dir = {
+          mounted: dir,
+          updated: dir
+        };
+      }
+      if (dir.deep) {
+        traverse(value);
+      }
+      bindings.push({
+        dir,
+        instance,
+        value,
+        oldValue: void 0,
+        arg,
+        modifiers
+      });
+    }
+  }
+  return vnode;
+}
+function invokeDirectiveHook(vnode, prevVNode, instance, name) {
+  const bindings = vnode.dirs;
+  const oldBindings = prevVNode && prevVNode.dirs;
+  for (let i = 0; i < bindings.length; i++) {
+    const binding = bindings[i];
+    if (oldBindings) {
+      binding.oldValue = oldBindings[i].value;
+    }
+    let hook = binding.dir[name];
+    if (!hook) {
+      hook = mapCompatDirectiveHook(name, binding.dir, instance);
+    }
+    if (hook) {
+      pauseTracking();
+      callWithAsyncErrorHandling(hook, instance, 8, [
+        vnode.el,
+        binding,
+        vnode,
+        prevVNode
+      ]);
+      resetTracking();
+    }
+  }
+}
+
 function useTransitionState() {
   const state = {
     isMounted: false,
@@ -4699,106 +4788,6 @@ function getCompatListeners(instance) {
   return listeners;
 }
 
-const legacyDirectiveHookMap = {
-  beforeMount: "bind",
-  mounted: "inserted",
-  updated: ["update", "componentUpdated"],
-  unmounted: "unbind"
-};
-function mapCompatDirectiveHook(name, dir, instance) {
-  const mappedName = legacyDirectiveHookMap[name];
-  if (mappedName) {
-    if (isArray(mappedName)) {
-      const hook = [];
-      mappedName.forEach((mapped) => {
-        const mappedHook = dir[mapped];
-        if (mappedHook) {
-          softAssertCompatEnabled(
-            "CUSTOM_DIR",
-            instance,
-            mapped,
-            name
-          );
-          hook.push(mappedHook);
-        }
-      });
-      return hook.length ? hook : void 0;
-    } else {
-      if (dir[mappedName]) {
-        softAssertCompatEnabled(
-          "CUSTOM_DIR",
-          instance,
-          mappedName,
-          name
-        );
-      }
-      return dir[mappedName];
-    }
-  }
-}
-
-function validateDirectiveName(name) {
-  if (isBuiltInDirective(name)) {
-    warn("Do not use built-in directive ids as custom directive id: " + name);
-  }
-}
-function withDirectives(vnode, directives) {
-  const internalInstance = currentRenderingInstance;
-  if (internalInstance === null) {
-    warn(`withDirectives can only be used inside render functions.`);
-    return vnode;
-  }
-  const instance = getExposeProxy(internalInstance) || internalInstance.proxy;
-  const bindings = vnode.dirs || (vnode.dirs = []);
-  for (let i = 0; i < directives.length; i++) {
-    let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
-    if (dir) {
-      if (isFunction(dir)) {
-        dir = {
-          mounted: dir,
-          updated: dir
-        };
-      }
-      if (dir.deep) {
-        traverse(value);
-      }
-      bindings.push({
-        dir,
-        instance,
-        value,
-        oldValue: void 0,
-        arg,
-        modifiers
-      });
-    }
-  }
-  return vnode;
-}
-function invokeDirectiveHook(vnode, prevVNode, instance, name) {
-  const bindings = vnode.dirs;
-  const oldBindings = prevVNode && prevVNode.dirs;
-  for (let i = 0; i < bindings.length; i++) {
-    const binding = bindings[i];
-    if (oldBindings) {
-      binding.oldValue = oldBindings[i].value;
-    }
-    let hook = binding.dir[name];
-    if (!hook) {
-      hook = mapCompatDirectiveHook(name, binding.dir, instance);
-    }
-    if (hook) {
-      pauseTracking();
-      callWithAsyncErrorHandling(hook, instance, 8, [
-        vnode.el,
-        binding,
-        vnode,
-        prevVNode
-      ]);
-      resetTracking();
-    }
-  }
-}
-
 const COMPONENTS = "components";
 const DIRECTIVES = "directives";
 const FILTERS = "filters";
@@ -5514,6 +5503,8 @@ const PublicInstanceProxyHandlers = {
       if (key === "$attrs") {
         track(instance, "get", key);
         markAttrsAccessed();
+      } else if (key === "$slots") {
+        track(instance, "get", key);
       }
       return publicGetter(instance);
     } else if (
@@ -5703,24 +5694,179 @@ function deepMergeData(to, from) {
   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
@@ -5765,12 +5911,7 @@ function applyOptions(instance) {
     }
   }
   if (injectOptions) {
-    resolveInjections(
-      injectOptions,
-      ctx,
-      checkDuplicateProperties,
-      instance.appContext.config.unwrapInjectedRef
-    );
+    resolveInjections(injectOptions, ctx, checkDuplicateProperties);
   }
   if (methods) {
     for (const key in methods) {
@@ -5921,7 +6062,7 @@ function applyOptions(instance) {
     instance.filters = filters;
   }
 }
-function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
+function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
   if (isArray(injectOptions)) {
     injectOptions = normalizeInject(injectOptions);
   }
@@ -5943,21 +6084,12 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP,
       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;
     }
@@ -6060,10 +6192,8 @@ function mergeOptions(to, from, strats, asMixin = false) {
 }
 const internalOptionMergeStrats = {
   data: mergeDataFn,
-  props: mergeObjectOptions,
-  // TODO
-  emits: mergeObjectOptions,
-  // TODO
+  props: mergeEmitsOrPropsOptions,
+  emits: mergeEmitsOrPropsOptions,
   // objects
   methods: mergeObjectOptions,
   computed: mergeObjectOptions,
@@ -6125,7 +6255,21 @@ function mergeAsArray$1(to, from) {
   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)
@@ -6139,1179 +6283,1234 @@ function mergeWatchOptions(to, from) {
   return merged;
 }
 
-function createPropsDefaultThis(instance, rawProps, propKey) {
-  return new Proxy(
-    {},
-    {
-      get(_, key) {
-        warnDeprecation$1("PROPS_DEFAULT_THIS", null, propKey);
-        if (key === "$options") {
-          return resolveMergedOptions(instance);
-        }
-        if (key in rawProps) {
-          return rawProps[key];
-        }
-        const injections = instance.type.inject;
-        if (injections) {
-          if (isArray(injections)) {
-            if (injections.includes(key)) {
-              return inject(key);
-            }
-          } else if (key in injections) {
-            return inject(key);
-          }
+function installLegacyConfigWarnings(config) {
+  const legacyConfigOptions = {
+    silent: "CONFIG_SILENT",
+    devtools: "CONFIG_DEVTOOLS",
+    ignoredElements: "CONFIG_IGNORED_ELEMENTS",
+    keyCodes: "CONFIG_KEY_CODES",
+    productionTip: "CONFIG_PRODUCTION_TIP"
+  };
+  Object.keys(legacyConfigOptions).forEach((key) => {
+    let val = config[key];
+    Object.defineProperty(config, key, {
+      enumerable: true,
+      get() {
+        return val;
+      },
+      set(newVal) {
+        if (!isCopyingConfig) {
+          warnDeprecation$1(legacyConfigOptions[key], null);
         }
+        val = newVal;
       }
-    }
-  );
+    });
+  });
 }
-
-function shouldSkipAttr(key, instance) {
-  if (key === "is") {
-    return true;
-  }
-  if ((key === "class" || key === "style") && isCompatEnabled$1("INSTANCE_ATTRS_CLASS_STYLE", instance)) {
-    return true;
-  }
-  if (isOn(key) && isCompatEnabled$1("INSTANCE_LISTENERS", instance)) {
-    return true;
-  }
-  if (key.startsWith("routerView") || key === "registerRouteInstance") {
-    return true;
-  }
-  return false;
+function installLegacyOptionMergeStrats(config) {
+  config.optionMergeStrategies = new Proxy({}, {
+    get(target, key) {
+      if (key in target) {
+        return target[key];
+      }
+      if (key in internalOptionMergeStrats && softAssertCompatEnabled(
+        "CONFIG_OPTION_MERGE_STRATS",
+        null
+      )) {
+        return internalOptionMergeStrats[key];
+      }
+    }
+  });
 }
 
-function initProps(instance, rawProps, isStateful, isSSR = false) {
-  const props = {};
-  const attrs = {};
-  def(attrs, InternalObjectKey, 1);
-  instance.propsDefaults = /* @__PURE__ */ Object.create(null);
-  setFullProps(instance, rawProps, props, attrs);
-  for (const key in instance.propsOptions[0]) {
-    if (!(key in props)) {
-      props[key] = void 0;
+let isCopyingConfig = false;
+let singletonApp;
+let singletonCtor;
+function createCompatVue$1(createApp, createSingletonApp) {
+  singletonApp = createSingletonApp({});
+  const Vue = singletonCtor = function Vue2(options = {}) {
+    return createCompatApp(options, Vue2);
+  };
+  function createCompatApp(options = {}, Ctor) {
+    assertCompatEnabled("GLOBAL_MOUNT", null);
+    const { data } = options;
+    if (data && !isFunction(data) && softAssertCompatEnabled("OPTIONS_DATA_FN", null)) {
+      options.data = () => data;
+    }
+    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)) {
@@ -8215,7 +8414,7 @@ function baseCreateRenderer(options, createHydrationFns) {
         areChildrenSVG,
         slotScopeIds
       );
-      if (parentComponent && parentComponent.type.__hmrId) {
+      {
         traverseStaticChildren(n1, n2);
       }
     } else if (!optimized) {
@@ -8411,21 +8610,8 @@ function baseCreateRenderer(options, createHydrationFns) {
           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(
@@ -10094,6 +10280,8 @@ function createComponentInstance(vnode, parent, suspense) {
     refs: EMPTY_OBJ,
     setupState: EMPTY_OBJ,
     setupContext: null,
+    attrsProxy: null,
+    slotsProxy: null,
     // suspense related
     suspense,
     suspenseId: suspense ? suspense.pendingId : 0,
@@ -10345,8 +10533,8 @@ function finishComponentSetup(instance, isSSR, skipOptions) {
     }
   }
 }
-function createAttrsProxy(instance) {
-  return new Proxy(
+function getAttrsProxy(instance) {
+  return instance.attrsProxy || (instance.attrsProxy = new Proxy(
     instance.attrs,
     {
       get(target, key) {
@@ -10363,7 +10551,23 @@ function createAttrsProxy(instance) {
         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) => {
@@ -10389,14 +10593,13 @@ function createSetupContext(instance) {
     }
     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);
@@ -10456,111 +10659,6 @@ const computed = (getterOrOptions, debugOptions) => {
   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) {
@@ -10796,7 +10894,7 @@ function isMemoSame(cached, memo) {
   return true;
 }
 
-const version = "3.3.0-alpha.8";
+const version = "3.3.0-beta.1";
 const _ssrUtils = {
   createComponentInstance,
   setupComponent,
@@ -12453,6 +12551,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   defineCustomElement: defineCustomElement,
   defineEmits: defineEmits,
   defineExpose: defineExpose,
+  defineModel: defineModel,
   defineOptions: defineOptions,
   defineProps: defineProps,
   defineSSRCustomElement: defineSSRCustomElement,
@@ -12466,6 +12565,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   guardReactiveProps: guardReactiveProps,
   h: h,
   handleError: handleError,
+  hasInjectionContext: hasInjectionContext,
   hydrate: hydrate,
   initCustomFormatter: initCustomFormatter,
   initDirectivesForSSR: initDirectivesForSSR,
@@ -12480,6 +12580,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   isVNode: isVNode,
   markRaw: markRaw,
   mergeDefaults: mergeDefaults,
+  mergeModels: mergeModels,
   mergeProps: mergeProps,
   nextTick: nextTick,
   normalizeClass: normalizeClass,
@@ -12538,6 +12639,7 @@ var runtimeDom = /*#__PURE__*/Object.freeze({
   useAttrs: useAttrs,
   useCssModule: useCssModule,
   useCssVars: useCssVars,
+  useModel: useModel,
   useSSRContext: useSSRContext,
   useSlots: useSlots,
   useTransitionState: useTransitionState,
@@ -12650,8 +12752,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` );
@@ -14542,7 +14647,7 @@ const aliasHelper = (s) => `${helperNameMap[s]}: _${helperNameMap[s]}`;
 function createCodegenContext(ast, {
   mode = "function",
   prefixIdentifiers = mode === "module",
-  sourceMap: sourceMap$1 = false,
+  sourceMap = false,
   filename = `template.vue.html`,
   scopeId = null,
   optimizeImports = false,
@@ -14556,7 +14661,7 @@ function createCodegenContext(ast, {
   const context = {
     mode,
     prefixIdentifiers,
-    sourceMap: sourceMap$1,
+    sourceMap,
     filename,
     scopeId,
     optimizeImports,
@@ -14628,8 +14733,8 @@ function createCodegenContext(ast, {
       }
     });
   }
-  if (sourceMap$1) {
-    context.map = new sourceMap.SourceMapGenerator();
+  if (sourceMap) {
+    context.map = new sourceMapJs.SourceMapGenerator();
     context.map.setSourceContent(filename, context.source);
   }
   return context;
@@ -15613,12 +15718,10 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
         return genPropsAccessExp(bindingMetadata.__propsAliases[raw]);
       }
     } else {
-      if (type && type.startsWith("setup")) {
+      if (type && type.startsWith("setup") || type === "literal-const") {
         return `$setup.${raw}`;
       } else if (type === "props-aliased") {
         return `$props['${bindingMetadata.__propsAliases[raw]}']`;
-      } else if (type === "literal-const") {
-        return raw;
       } else if (type) {
         return `$${type}.${raw}`;
       }
@@ -16669,6 +16772,11 @@ function resolveComponentType(node, context, ssr = false) {
   }
   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
     ]);
@@ -17240,6 +17348,11 @@ const transformOn$1 = (dir, node, context, augmentor) => {
   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)}`;
       }
@@ -17458,7 +17571,7 @@ const transformText = (node, context) => {
 const seen$1 = /* @__PURE__ */ new WeakSet();
 const transformOnce = (node, context) => {
   if (node.type === 1 && findDir(node, "once", true)) {
-    if (seen$1.has(node) || context.inVOnce) {
+    if (seen$1.has(node) || context.inVOnce || context.inSSR) {
       return;
     }
     seen$1.add(node);
@@ -20261,29 +20374,29 @@ function createDOMCompilerError(code, loc) {
   );
 }
 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;
   }
@@ -20301,12 +20414,12 @@ const transformVText = (dir, node, context) => {
   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;
   }
@@ -20332,7 +20445,7 @@ const transformModel = (dir, node, context) => {
   if (dir.arg) {
     context.onError(
       createDOMCompilerError(
-        56,
+        58,
         dir.arg.loc
       )
     );
@@ -20342,7 +20455,7 @@ const transformModel = (dir, node, context) => {
     if (value) {
       context.onError(
         createDOMCompilerError(
-          58,
+          60,
           value.loc
         )
       );
@@ -20370,7 +20483,7 @@ const transformModel = (dir, node, context) => {
               isInvalidType = true;
               context.onError(
                 createDOMCompilerError(
-                  57,
+                  59,
                   dir.loc
                 )
               );
@@ -20396,7 +20509,7 @@ const transformModel = (dir, node, context) => {
   } else {
     context.onError(
       createDOMCompilerError(
-        55,
+        57,
         dir.loc
       )
     );
@@ -20508,7 +20621,7 @@ const transformShow = (dir, node, context) => {
   const { exp, loc } = dir;
   if (!exp) {
     context.onError(
-      createDOMCompilerError(59, loc)
+      createDOMCompilerError(61, loc)
     );
   }
   return {
@@ -20528,7 +20641,7 @@ const transformTransition = (node, context) => {
         if (hasMultipleChildren(node)) {
           context.onError(
             createDOMCompilerError(
-              60,
+              62,
               {
                 start: node.children[0].loc.start,
                 end: node.children[node.children.length - 1].loc.end,
@@ -20776,7 +20889,7 @@ function evaluateConstant(exp) {
 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();
   }