@vue/runtime-dom 3.3.0-alpha.8 → 3.3.0-beta.1

package/dist/runtime-dom.global.js

@@ -100,7 +100,7 @@ var VueRuntimeDOM = (function (exports) {
     return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {});
   };
 
-  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);
 
   function normalizeStyle(value) {
@@ -1859,6 +1859,8 @@ var VueRuntimeDOM = (function (exports) {
         }
         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);
@@ -2701,7 +2703,8 @@ var VueRuntimeDOM = (function (exports) {
     }
   }
   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"](
@@ -2715,13 +2718,21 @@ var VueRuntimeDOM = (function (exports) {
       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,
@@ -2781,20 +2792,28 @@ var VueRuntimeDOM = (function (exports) {
         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) {
@@ -2894,13 +2913,13 @@ var VueRuntimeDOM = (function (exports) {
           }
         });
       },
-      unmount(parentSuspense, doRemove) {
+      unmount(parentSuspense2, doRemove) {
         suspense.isUnmounted = true;
         if (suspense.activeBranch) {
           unmount(
             suspense.activeBranch,
             parentComponent,
-            parentSuspense,
+            parentSuspense2,
             doRemove
           );
         }
@@ -2908,7 +2927,7 @@ var VueRuntimeDOM = (function (exports) {
           unmount(
             suspense.pendingBranch,
             parentComponent,
-            parentSuspense,
+            parentSuspense2,
             doRemove
           );
         }
@@ -3001,36 +3020,6 @@ var VueRuntimeDOM = (function (exports) {
     }
   }
 
-  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;
-      } else {
-        warn(`injection "${String(key)}" not found.`);
-      }
-    } else {
-      warn(`inject() can only be used inside setup() or functional components.`);
-    }
-  }
-
   function watchEffect(effect, options) {
     return doWatch(effect, null, options);
   }
@@ -3256,6 +3245,65 @@ var VueRuntimeDOM = (function (exports) {
     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) {
+        pauseTracking();
+        callWithAsyncErrorHandling(hook, instance, 8, [
+          vnode.el,
+          binding,
+          vnode,
+          prevVNode
+        ]);
+        resetTracking();
+      }
+    }
+  }
+
   function useTransitionState() {
     const state = {
       isMounted: false,
@@ -4013,65 +4061,6 @@ var VueRuntimeDOM = (function (exports) {
     injectHook("ec", hook, target);
   }
 
-  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) {
-        pauseTracking();
-        callWithAsyncErrorHandling(hook, instance, 8, [
-          vnode.el,
-          binding,
-          vnode,
-          prevVNode
-        ]);
-        resetTracking();
-      }
-    }
-  }
-
   const COMPONENTS = "components";
   const DIRECTIVES = "directives";
   function resolveComponent(name, maybeSelfReference) {
@@ -4320,6 +4309,8 @@ If this is a native custom element, make sure to exclude it from component resol
         if (key === "$attrs") {
           track(instance, "get", key);
           markAttrsAccessed();
+        } else if (key === "$slots") {
+          track(instance, "get", key);
         }
         return publicGetter(instance);
       } else if (
@@ -4489,96 +4480,246 @@ If this is a native custom element, make sure to exclude it from component resol
     });
   }
 
-  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 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`);
     }
-    const {
-      // state
-      data: dataOptions,
-      computed: computedOptions,
-      methods,
-      watch: watchOptions,
-      provide: provideOptions,
-      inject: injectOptions,
-      // lifecycle
-      created,
-      beforeMount,
-      mounted,
-      beforeUpdate,
-      updated,
-      activated,
-      deactivated,
-      beforeDestroy,
-      beforeUnmount,
-      destroyed,
-      unmounted,
-      render,
-      renderTracked,
-      renderTriggered,
-      errorCaptured,
-      serverPrefetch,
-      // public API
-      expose,
-      inheritAttrs,
-      // assets
-      components,
-      directives,
-      filters
-    } = options;
-    const checkDuplicateProperties = createDuplicateChecker() ;
+    return null;
+  }
+  function defineEmits() {
     {
-      const [propsOptions] = instance.propsOptions;
-      if (propsOptions) {
-        for (const key in propsOptions) {
-          checkDuplicateProperties("Props" /* PROPS */, key);
-        }
-      }
+      warnRuntimeUsage(`defineEmits`);
     }
-    if (injectOptions) {
-      resolveInjections(
-        injectOptions,
-        ctx,
-        checkDuplicateProperties,
-        instance.appContext.config.unwrapInjectedRef
-      );
+    return null;
+  }
+  function defineExpose(exposed) {
+    {
+      warnRuntimeUsage(`defineExpose`);
     }
-    if (methods) {
-      for (const key in methods) {
-        const methodHandler = methods[key];
-        if (isFunction(methodHandler)) {
-          {
-            Object.defineProperty(ctx, key, {
-              value: methodHandler.bind(publicThis),
-              configurable: true,
-              enumerable: true,
-              writable: true
-            });
-          }
-          {
-            checkDuplicateProperties("Methods" /* METHODS */, key);
-          }
-        } else {
-          warn(
-            `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
-          );
-        }
-      }
+  }
+  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
+      data: dataOptions,
+      computed: computedOptions,
+      methods,
+      watch: watchOptions,
+      provide: provideOptions,
+      inject: injectOptions,
+      // lifecycle
+      created,
+      beforeMount,
+      mounted,
+      beforeUpdate,
+      updated,
+      activated,
+      deactivated,
+      beforeDestroy,
+      beforeUnmount,
+      destroyed,
+      unmounted,
+      render,
+      renderTracked,
+      renderTriggered,
+      errorCaptured,
+      serverPrefetch,
+      // public API
+      expose,
+      inheritAttrs,
+      // assets
+      components,
+      directives,
+      filters
+    } = options;
+    const checkDuplicateProperties = createDuplicateChecker() ;
+    {
+      const [propsOptions] = instance.propsOptions;
+      if (propsOptions) {
+        for (const key in propsOptions) {
+          checkDuplicateProperties("Props" /* PROPS */, key);
+        }
+      }
+    }
+    if (injectOptions) {
+      resolveInjections(injectOptions, ctx, checkDuplicateProperties);
+    }
+    if (methods) {
+      for (const key in methods) {
+        const methodHandler = methods[key];
+        if (isFunction(methodHandler)) {
+          {
+            Object.defineProperty(ctx, key, {
+              value: methodHandler.bind(publicThis),
+              configurable: true,
+              enumerable: true,
+              writable: true
+            });
+          }
+          {
+            checkDuplicateProperties("Methods" /* METHODS */, key);
+          }
+        } else {
+          warn(
+            `Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
+          );
+        }
+      }
     }
     if (dataOptions) {
       if (!isFunction(dataOptions)) {
@@ -4696,7 +4837,7 @@ If this is a native custom element, make sure to exclude it from component resol
     if (directives)
       instance.directives = directives;
   }
-  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP, unwrapRef = false) {
+  function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
     if (isArray(injectOptions)) {
       injectOptions = normalizeInject(injectOptions);
     }
@@ -4718,21 +4859,12 @@ If this is a native custom element, make sure to exclude it from component resol
         injected = inject(opt);
       }
       if (isRef(injected)) {
-        if (unwrapRef) {
-          Object.defineProperty(ctx, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => injected.value,
-            set: (v) => injected.value = v
-          });
-        } else {
-          {
-            warn(
-              `injected property "${key}" is a ref and will be auto-unwrapped and no longer needs \`.value\` in the next minor release. To opt-in to the new behavior now, set \`app.config.unwrapInjectedRef = true\` (this config is temporary and will not be needed in the future.)`
-            );
-          }
-          ctx[key] = injected;
-        }
+        Object.defineProperty(ctx, key, {
+          enumerable: true,
+          configurable: true,
+          get: () => injected.value,
+          set: (v) => injected.value = v
+        });
       } else {
         ctx[key] = injected;
       }
@@ -4828,10 +4960,8 @@ If this is a native custom element, make sure to exclude it from component resol
   }
   const internalOptionMergeStrats = {
     data: mergeDataFn,
-    props: mergeObjectOptions,
-    // TODO
-    emits: mergeObjectOptions,
-    // TODO
+    props: mergeEmitsOrPropsOptions,
+    emits: mergeEmitsOrPropsOptions,
     // objects
     methods: mergeObjectOptions,
     computed: mergeObjectOptions,
@@ -4890,7 +5020,21 @@ If this is a native custom element, make sure to exclude it from component resol
     return to ? [...new Set([].concat(to, from))] : from;
   }
   function mergeObjectOptions(to, from) {
-    return to ? extend(extend(/* @__PURE__ */ Object.create(null), to), from) : from;
+    return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
+  }
+  function mergeEmitsOrPropsOptions(to, from) {
+    if (to) {
+      if (isArray(to) && isArray(from)) {
+        return [.../* @__PURE__ */ new Set([...to, ...from])];
+      }
+      return extend(
+        /* @__PURE__ */ Object.create(null),
+        normalizePropsOrEmits(to),
+        normalizePropsOrEmits(from != null ? from : {})
+      );
+    } else {
+      return from;
+    }
   }
   function mergeWatchOptions(to, from) {
     if (!to)
@@ -4904,30 +5048,254 @@ If this is a native custom element, make sure to exclude it from component resol
     return merged;
   }
 
-  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;
+  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);
       }
-    }
-    {
-      validateProps(rawProps || {}, props, instance);
-    }
-    if (isStateful) {
-      instance.props = isSSR ? props : shallowReactive(props);
-    } else {
-      if (!instance.type.props) {
-        instance.props = attrs;
-      } else {
-        instance.props = props;
+      if (rootProps != null && !isObject(rootProps)) {
+        warn(`root props passed to app.mount() must be an object.`);
+        rootProps = null;
       }
-    }
-    instance.attrs = attrs;
+      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.`
+            );
+          }
+        });
+      }
+      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;
+          }
+        }
+      };
+      return app;
+    };
+  }
+  let currentApp = null;
+
+  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 || 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.`);
+    }
+  }
+  function hasInjectionContext() {
+    return !!(currentInstance || currentRenderingInstance || currentApp);
+  }
+
+  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;
+      }
+    }
+    {
+      validateProps(rawProps || {}, props, instance);
+    }
+    if (isStateful) {
+      instance.props = isSSR ? props : shallowReactive(props);
+    } else {
+      if (!instance.type.props) {
+        instance.props = attrs;
+      } else {
+        instance.props = props;
+      }
+    }
+    instance.attrs = attrs;
   }
   function isInHmrContext(instance) {
     while (instance) {
@@ -5219,7 +5587,7 @@ If this is a native custom element, make sure to exclude it from component resol
       warn('Missing required prop: "' + name + '"');
       return;
     }
-    if (value == null && !prop.required) {
+    if (value == null && !required) {
       return;
     }
     if (type != null && type !== true && !skipCheck) {
@@ -5253,319 +5621,150 @@ If this is a native custom element, make sure to exclude it from component resol
         valid = value instanceof type;
       }
     } else if (expectedType === "Object") {
-      valid = isObject(value);
-    } else if (expectedType === "Array") {
-      valid = isArray(value);
-    } else if (expectedType === "null") {
-      valid = value === null;
-    } else {
-      valid = value instanceof type;
-    }
-    return {
-      valid,
-      expectedType
-    };
-  }
-  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) {
-        {
-          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) && true) {
-      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 = {});
-      }
-    } 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);
-        } else if (optimized && type === 1) {
-          needDeletionCheck = false;
-        } else {
-          extend(slots, children);
-          if (!optimized && type === 1) {
-            delete slots._;
-          }
-        }
-      } else {
-        needDeletionCheck = !children.$stable;
-        normalizeObjectSlots(children, slots);
-      }
-      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 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);
-      }
-      if (rootProps != null && !isObject(rootProps)) {
-        warn(`root props passed to app.mount() must be an object.`);
-        rootProps = null;
-      }
-      const context = createAppContext();
-      const installedPlugins = /* @__PURE__ */ new Set();
-      let isMounted = false;
-      const app = context.app = {
-        _uid: uid$1++,
-        _component: rootComponent,
-        _props: rootProps,
-        _container: null,
-        _context: context,
-        _instance: null,
-        version,
-        get config() {
-          return context.config;
-        },
-        set config(v) {
-          {
-            warn(
-              `app.config cannot be replaced. Modify individual options instead.`
-            );
-          }
-        },
-        use(plugin, ...options) {
-          if (installedPlugins.has(plugin)) {
-            warn(`Plugin has already been applied to target app.`);
-          } else if (plugin && isFunction(plugin.install)) {
-            installedPlugins.add(plugin);
-            plugin.install(app, ...options);
-          } else if (isFunction(plugin)) {
-            installedPlugins.add(plugin);
-            plugin(app, ...options);
-          } else {
-            warn(
-              `A plugin must either be a function or an object with an "install" function.`
-            );
-          }
-          return app;
-        },
-        mixin(mixin) {
-          {
-            if (!context.mixins.includes(mixin)) {
-              context.mixins.push(mixin);
-            } else {
-              warn(
-                "Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
-              );
-            }
-          }
-          return app;
-        },
-        component(name, component) {
-          {
-            validateComponentName(name, context.config);
-          }
-          if (!component) {
-            return context.components[name];
-          }
-          if (context.components[name]) {
-            warn(`Component "${name}" has already been registered in target app.`);
-          }
-          context.components[name] = component;
-          return app;
-        },
-        directive(name, directive) {
-          {
-            validateDirectiveName(name);
-          }
-          if (!directive) {
-            return context.directives[name];
-          }
-          if (context.directives[name]) {
-            warn(`Directive "${name}" has already been registered in target app.`);
-          }
-          context.directives[name] = directive;
-          return app;
-        },
-        mount(rootContainer, isHydrate, isSVG) {
-          if (!isMounted) {
-            if (rootContainer.__vue_app__) {
-              warn(
-                `There is already an app instance mounted on the host container.
- If you want to mount another app on the same host container, you need to unmount the previous app by calling \`app.unmount()\` first.`
-              );
-            }
-            const vnode = createVNode(
-              rootComponent,
-              rootProps
-            );
-            vnode.appContext = context;
-            {
-              context.reload = () => {
-                render(cloneVNode(vnode), rootContainer, isSVG);
-              };
-            }
-            if (isHydrate && hydrate) {
-              hydrate(vnode, rootContainer);
-            } else {
-              render(vnode, rootContainer, isSVG);
-            }
-            isMounted = true;
-            app._container = rootContainer;
-            rootContainer.__vue_app__ = app;
-            {
-              app._instance = vnode.component;
-              devtoolsInitApp(app, version);
-            }
-            return getExposeProxy(vnode.component) || vnode.component.proxy;
-          } else {
-            warn(
-              `App has already been mounted.
-If you want to remount the same app, move your app creation logic into a factory function and create fresh app instances for each mount - e.g. \`const createMyApp = () => createApp(App)\``
-            );
-          }
-        },
-        unmount() {
-          if (isMounted) {
-            render(null, app._container);
-            {
-              app._instance = null;
-              devtoolsUnmountApp(app);
-            }
-            delete app._container.__vue_app__;
-          } else {
-            warn(`Cannot unmount an app that is not mounted.`);
-          }
-        },
-        provide(key, value) {
-          if (key in context.provides) {
-            warn(
-              `App already provides property with key "${String(key)}". It will be overwritten with the new value.`
-            );
-          }
-          context.provides[key] = value;
-          return app;
-        }
-      };
-      return app;
+      valid = isObject(value);
+    } else if (expectedType === "Array") {
+      valid = isArray(value);
+    } else if (expectedType === "null") {
+      valid = value === null;
+    } else {
+      valid = value instanceof type;
+    }
+    return {
+      valid,
+      expectedType
     };
   }
+  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) {
+        {
+          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) && true) {
+      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 = {});
+      }
+    } 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._;
+          }
+        }
+      } else {
+        needDeletionCheck = !children.$stable;
+        normalizeObjectSlots(children, slots);
+      }
+      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)) {
@@ -6469,7 +6668,7 @@ If you want to remount the same app, move your app creation logic into a factory
           areChildrenSVG,
           slotScopeIds
         );
-        if (parentComponent && parentComponent.type.__hmrId) {
+        {
           traverseStaticChildren(n1, n2);
         }
       } else if (!optimized) {
@@ -6665,21 +6864,8 @@ If you want to remount the same app, move your app creation logic into a factory
             isSVG,
             slotScopeIds
           );
-          if (parentComponent && parentComponent.type.__hmrId) {
+          {
             traverseStaticChildren(n1, n2);
-          } else if (
-            // #2080 if the stable fragment has a key, it's a <template v-for> that may
-            //  get moved around. Make sure all root level vnodes inherit el.
-            // #2134 or if it's a component root, it may also get moved around
-            // as the component is being moved.
-            n2.key != null || parentComponent && n2 === parentComponent.subTree
-          ) {
-            traverseStaticChildren(
-              n1,
-              n2,
-              true
-              /* shallow */
-            );
           }
         } else {
           patchChildren(
@@ -8253,6 +8439,8 @@ Component that was made reactive: `,
       refs: EMPTY_OBJ,
       setupState: EMPTY_OBJ,
       setupContext: null,
+      attrsProxy: null,
+      slotsProxy: null,
       // suspense related
       suspense,
       suspenseId: suspense ? suspense.pendingId : 0,
@@ -8480,8 +8668,8 @@ Component that was made reactive: `,
       }
     }
   }
-  function createAttrsProxy(instance) {
-    return new Proxy(
+  function getAttrsProxy(instance) {
+    return instance.attrsProxy || (instance.attrsProxy = new Proxy(
       instance.attrs,
       {
         get(target, key) {
@@ -8498,7 +8686,23 @@ Component that was made reactive: `,
           return false;
         }
       } 
-    );
+    ));
+  }
+  function getSlotsProxy(instance) {
+    return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
+      get(target, key) {
+        track(instance, "get", "$slots");
+        return target[key];
+      },
+      set() {
+        warn(`setupContext.slots is readonly.`);
+        return false;
+      },
+      deleteProperty() {
+        warn(`setupContext.slots is readonly.`);
+        return false;
+      }
+    }));
   }
   function createSetupContext(instance) {
     const expose = (exposed) => {
@@ -8524,14 +8728,13 @@ Component that was made reactive: `,
       }
       instance.exposed = exposed || {};
     };
-    let attrs;
     {
       return Object.freeze({
         get attrs() {
-          return attrs || (attrs = createAttrsProxy(instance));
+          return getAttrsProxy(instance);
         },
         get slots() {
-          return shallowReadonly(instance.slots);
+          return getSlotsProxy(instance);
         },
         get emit() {
           return (event, ...args) => instance.emit(event, ...args);
@@ -8591,111 +8794,6 @@ Component that was made reactive: `,
     return computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
   };
 
-  const warnRuntimeUsage = (method) => warn(
-    `${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
-  );
-  function defineProps() {
-    {
-      warnRuntimeUsage(`defineProps`);
-    }
-    return null;
-  }
-  function defineEmits() {
-    {
-      warnRuntimeUsage(`defineEmits`);
-    }
-    return null;
-  }
-  function defineExpose(exposed) {
-    {
-      warnRuntimeUsage(`defineExpose`);
-    }
-  }
-  function defineOptions(options) {
-    {
-      warnRuntimeUsage(`defineOptions`);
-    }
-  }
-  function defineSlots() {
-    {
-      warnRuntimeUsage(`defineSlots`);
-    }
-  }
-  function withDefaults(props, defaults) {
-    {
-      warnRuntimeUsage(`withDefaults`);
-    }
-    return null;
-  }
-  function useSlots() {
-    return getContext().slots;
-  }
-  function useAttrs() {
-    return getContext().attrs;
-  }
-  function getContext() {
-    const i = getCurrentInstance();
-    if (!i) {
-      warn(`useContext() called without active instance.`);
-    }
-    return i.setupContext || (i.setupContext = createSetupContext(i));
-  }
-  function mergeDefaults(raw, defaults) {
-    const props = isArray(raw) ? raw.reduce(
-      (normalized, p) => (normalized[p] = {}, normalized),
-      {}
-    ) : raw;
-    for (const key in defaults) {
-      if (key.startsWith("__skip"))
-        continue;
-      let opt = props[key];
-      if (opt) {
-        if (isArray(opt) || isFunction(opt)) {
-          opt = props[key] = { type: opt, default: defaults[key] };
-        } else {
-          opt.default = defaults[key];
-        }
-      } else if (opt === null) {
-        opt = props[key] = { default: defaults[key] };
-      } else {
-        warn(`props default key "${key}" has no corresponding declaration.`);
-      }
-      if (opt && defaults[`__skip_${key}`]) {
-        opt.skipFactory = true;
-      }
-    }
-    return props;
-  }
-  function createPropsRestProxy(props, excludedKeys) {
-    const ret = {};
-    for (const key in props) {
-      if (!excludedKeys.includes(key)) {
-        Object.defineProperty(ret, key, {
-          enumerable: true,
-          get: () => props[key]
-        });
-      }
-    }
-    return ret;
-  }
-  function withAsyncContext(getAwaitable) {
-    const ctx = getCurrentInstance();
-    if (!ctx) {
-      warn(
-        `withAsyncContext called without active current instance. This is likely a bug.`
-      );
-    }
-    let awaitable = getAwaitable();
-    unsetCurrentInstance();
-    if (isPromise(awaitable)) {
-      awaitable = awaitable.catch((e) => {
-        setCurrentInstance(ctx);
-        throw e;
-      });
-    }
-    return [awaitable, () => setCurrentInstance(ctx)];
-  }
-
   function h(type, propsOrChildren, children) {
     const l = arguments.length;
     if (l === 2) {
@@ -8925,7 +9023,7 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.3.0-alpha.8";
+  const version = "3.3.0-beta.1";
   const ssrUtils = null;
   const resolveFilter = null;
   const compatUtils = null;
@@ -10423,6 +10521,7 @@ Component that was made reactive: `,
   exports.defineCustomElement = defineCustomElement;
   exports.defineEmits = defineEmits;
   exports.defineExpose = defineExpose;
+  exports.defineModel = defineModel;
   exports.defineOptions = defineOptions;
   exports.defineProps = defineProps;
   exports.defineSSRCustomElement = defineSSRCustomElement;
@@ -10435,6 +10534,7 @@ Component that was made reactive: `,
   exports.guardReactiveProps = guardReactiveProps;
   exports.h = h;
   exports.handleError = handleError;
+  exports.hasInjectionContext = hasInjectionContext;
   exports.hydrate = hydrate;
   exports.initCustomFormatter = initCustomFormatter;
   exports.initDirectivesForSSR = initDirectivesForSSR;
@@ -10449,6 +10549,7 @@ Component that was made reactive: `,
   exports.isVNode = isVNode;
   exports.markRaw = markRaw;
   exports.mergeDefaults = mergeDefaults;
+  exports.mergeModels = mergeModels;
   exports.mergeProps = mergeProps;
   exports.nextTick = nextTick;
   exports.normalizeClass = normalizeClass;
@@ -10507,6 +10608,7 @@ Component that was made reactive: `,
   exports.useAttrs = useAttrs;
   exports.useCssModule = useCssModule;
   exports.useCssVars = useCssVars;
+  exports.useModel = useModel;
   exports.useSSRContext = useSSRContext;
   exports.useSlots = useSlots;
   exports.useTransitionState = useTransitionState;