@vue/compat 3.2.36 → 3.2.39

package/dist/vue.runtime.global.js

@@ -641,7 +641,7 @@ var Vue = (function () {
           return;
       }
       let deps = [];
-      if (type === "clear" /* CLEAR */) {
+      if (type === "clear" /* TriggerOpTypes.CLEAR */) {
           // collection being cleared
           // trigger all effects for target
           deps = [...depsMap.values()];
@@ -660,7 +660,7 @@ var Vue = (function () {
           }
           // also run for iteration key on ADD | DELETE | Map.SET
           switch (type) {
-              case "add" /* ADD */:
+              case "add" /* TriggerOpTypes.ADD */:
                   if (!isArray(target)) {
                       deps.push(depsMap.get(ITERATE_KEY));
                       if (isMap(target)) {
@@ -672,7 +672,7 @@ var Vue = (function () {
                       deps.push(depsMap.get('length'));
                   }
                   break;
-              case "delete" /* DELETE */:
+              case "delete" /* TriggerOpTypes.DELETE */:
                   if (!isArray(target)) {
                       deps.push(depsMap.get(ITERATE_KEY));
                       if (isMap(target)) {
@@ -680,7 +680,7 @@ var Vue = (function () {
                       }
                   }
                   break;
-              case "set" /* SET */:
+              case "set" /* TriggerOpTypes.SET */:
                   if (isMap(target)) {
                       deps.push(depsMap.get(ITERATE_KEY));
                   }
@@ -757,7 +757,7 @@ var Vue = (function () {
           instrumentations[key] = function (...args) {
               const arr = toRaw(this);
               for (let i = 0, l = this.length; i < l; i++) {
-                  track(arr, "get" /* GET */, i + '');
+                  track(arr, "get" /* TrackOpTypes.GET */, i + '');
               }
               // we run the method using the original args first (which may be reactive)
               const res = arr[key](...args);
@@ -782,16 +782,16 @@ var Vue = (function () {
   }
   function createGetter(isReadonly = false, shallow = false) {
       return function get(target, key, receiver) {
-          if (key === "__v_isReactive" /* IS_REACTIVE */) {
+          if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
               return !isReadonly;
           }
-          else if (key === "__v_isReadonly" /* IS_READONLY */) {
+          else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
               return isReadonly;
           }
-          else if (key === "__v_isShallow" /* IS_SHALLOW */) {
+          else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
               return shallow;
           }
-          else if (key === "__v_raw" /* RAW */ &&
+          else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
               receiver ===
                   (isReadonly
                       ? shallow
@@ -811,7 +811,7 @@ var Vue = (function () {
               return res;
           }
           if (!isReadonly) {
-              track(target, "get" /* GET */, key);
+              track(target, "get" /* TrackOpTypes.GET */, key);
           }
           if (shallow) {
               return res;
@@ -837,10 +837,10 @@ var Vue = (function () {
           if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
               return false;
           }
-          if (!shallow && !isReadonly(value)) {
-              if (!isShallow(value)) {
-                  value = toRaw(value);
+          if (!shallow) {
+              if (!isShallow(value) && !isReadonly(value)) {
                   oldValue = toRaw(oldValue);
+                  value = toRaw(value);
               }
               if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
                   oldValue.value = value;
@@ -854,10 +854,10 @@ var Vue = (function () {
           // don't trigger if target is something up in the prototype chain of original
           if (target === toRaw(receiver)) {
               if (!hadKey) {
-                  trigger(target, "add" /* ADD */, key, value);
+                  trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
               }
               else if (hasChanged(value, oldValue)) {
-                  trigger(target, "set" /* SET */, key, value, oldValue);
+                  trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
               }
           }
           return result;
@@ -868,19 +868,19 @@ var Vue = (function () {
       const oldValue = target[key];
       const result = Reflect.deleteProperty(target, key);
       if (result && hadKey) {
-          trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+          trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
       }
       return result;
   }
   function has(target, key) {
       const result = Reflect.has(target, key);
       if (!isSymbol(key) || !builtInSymbols.has(key)) {
-          track(target, "has" /* HAS */, key);
+          track(target, "has" /* TrackOpTypes.HAS */, key);
       }
       return result;
   }
   function ownKeys(target) {
-      track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
+      track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
       return Reflect.ownKeys(target);
   }
   const mutableHandlers = {
@@ -921,14 +921,14 @@ var Vue = (function () {
   function get$1(target, key, isReadonly = false, isShallow = false) {
       // #1772: readonly(reactive(Map)) should return readonly + reactive version
       // of the value
-      target = target["__v_raw" /* RAW */];
+      target = target["__v_raw" /* ReactiveFlags.RAW */];
       const rawTarget = toRaw(target);
       const rawKey = toRaw(key);
       if (!isReadonly) {
           if (key !== rawKey) {
-              track(rawTarget, "get" /* GET */, key);
+              track(rawTarget, "get" /* TrackOpTypes.GET */, key);
           }
-          track(rawTarget, "get" /* GET */, rawKey);
+          track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
       }
       const { has } = getProto(rawTarget);
       const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
@@ -945,22 +945,22 @@ var Vue = (function () {
       }
   }
   function has$1(key, isReadonly = false) {
-      const target = this["__v_raw" /* RAW */];
+      const target = this["__v_raw" /* ReactiveFlags.RAW */];
       const rawTarget = toRaw(target);
       const rawKey = toRaw(key);
       if (!isReadonly) {
           if (key !== rawKey) {
-              track(rawTarget, "has" /* HAS */, key);
+              track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
           }
-          track(rawTarget, "has" /* HAS */, rawKey);
+          track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
       }
       return key === rawKey
           ? target.has(key)
           : target.has(key) || target.has(rawKey);
   }
   function size(target, isReadonly = false) {
-      target = target["__v_raw" /* RAW */];
-      !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY);
+      target = target["__v_raw" /* ReactiveFlags.RAW */];
+      !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
       return Reflect.get(target, 'size', target);
   }
   function add(value) {
@@ -970,7 +970,7 @@ var Vue = (function () {
       const hadKey = proto.has.call(target, value);
       if (!hadKey) {
           target.add(value);
-          trigger(target, "add" /* ADD */, value, value);
+          trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
       }
       return this;
   }
@@ -989,10 +989,10 @@ var Vue = (function () {
       const oldValue = get.call(target, key);
       target.set(key, value);
       if (!hadKey) {
-          trigger(target, "add" /* ADD */, key, value);
+          trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
       }
       else if (hasChanged(value, oldValue)) {
-          trigger(target, "set" /* SET */, key, value, oldValue);
+          trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
       }
       return this;
   }
@@ -1011,7 +1011,7 @@ var Vue = (function () {
       // forward the operation before queueing reactions
       const result = target.delete(key);
       if (hadKey) {
-          trigger(target, "delete" /* DELETE */, key, undefined, oldValue);
+          trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
       }
       return result;
   }
@@ -1025,17 +1025,17 @@ var Vue = (function () {
       // forward the operation before queueing reactions
       const result = target.clear();
       if (hadItems) {
-          trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget);
+          trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
       }
       return result;
   }
   function createForEach(isReadonly, isShallow) {
       return function forEach(callback, thisArg) {
           const observed = this;
-          const target = observed["__v_raw" /* RAW */];
+          const target = observed["__v_raw" /* ReactiveFlags.RAW */];
           const rawTarget = toRaw(target);
           const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
-          !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY);
+          !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
           return target.forEach((value, key) => {
               // important: make sure the callback is
               // 1. invoked with the reactive map as `this` and 3rd arg
@@ -1046,7 +1046,7 @@ var Vue = (function () {
   }
   function createIterableMethod(method, isReadonly, isShallow) {
       return function (...args) {
-          const target = this["__v_raw" /* RAW */];
+          const target = this["__v_raw" /* ReactiveFlags.RAW */];
           const rawTarget = toRaw(target);
           const targetIsMap = isMap(rawTarget);
           const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
@@ -1054,7 +1054,7 @@ var Vue = (function () {
           const innerIterator = target[method](...args);
           const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
           !isReadonly &&
-              track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
+              track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
           // return a wrapped iterator which returns observed versions of the
           // values emitted from the real iterator
           return {
@@ -1081,7 +1081,7 @@ var Vue = (function () {
               const key = args[0] ? `on key "${args[0]}" ` : ``;
               console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
           }
-          return type === "delete" /* DELETE */ ? false : this;
+          return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
       };
   }
   function createInstrumentations() {
@@ -1123,10 +1123,10 @@ var Vue = (function () {
           has(key) {
               return has$1.call(this, key, true);
           },
-          add: createReadonlyMethod("add" /* ADD */),
-          set: createReadonlyMethod("set" /* SET */),
-          delete: createReadonlyMethod("delete" /* DELETE */),
-          clear: createReadonlyMethod("clear" /* CLEAR */),
+          add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
+          set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
+          delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
+          clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
           forEach: createForEach(true, false)
       };
       const shallowReadonlyInstrumentations = {
@@ -1139,10 +1139,10 @@ var Vue = (function () {
           has(key) {
               return has$1.call(this, key, true);
           },
-          add: createReadonlyMethod("add" /* ADD */),
-          set: createReadonlyMethod("set" /* SET */),
-          delete: createReadonlyMethod("delete" /* DELETE */),
-          clear: createReadonlyMethod("clear" /* CLEAR */),
+          add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
+          set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
+          delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
+          clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
           forEach: createForEach(true, true)
       };
       const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
@@ -1169,13 +1169,13 @@ var Vue = (function () {
               ? readonlyInstrumentations
               : mutableInstrumentations;
       return (target, key, receiver) => {
-          if (key === "__v_isReactive" /* IS_REACTIVE */) {
+          if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
               return !isReadonly;
           }
-          else if (key === "__v_isReadonly" /* IS_READONLY */) {
+          else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
               return isReadonly;
           }
-          else if (key === "__v_raw" /* RAW */) {
+          else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
               return target;
           }
           return Reflect.get(hasOwn(instrumentations, key) && key in target
@@ -1215,19 +1215,19 @@ var Vue = (function () {
       switch (rawType) {
           case 'Object':
           case 'Array':
-              return 1 /* COMMON */;
+              return 1 /* TargetType.COMMON */;
           case 'Map':
           case 'Set':
           case 'WeakMap':
           case 'WeakSet':
-              return 2 /* COLLECTION */;
+              return 2 /* TargetType.COLLECTION */;
           default:
-              return 0 /* INVALID */;
+              return 0 /* TargetType.INVALID */;
       }
   }
   function getTargetType(value) {
-      return value["__v_skip" /* SKIP */] || !Object.isExtensible(value)
-          ? 0 /* INVALID */
+      return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
+          ? 0 /* TargetType.INVALID */
           : targetTypeMap(toRawType(value));
   }
   function reactive(target) {
@@ -1270,8 +1270,8 @@ var Vue = (function () {
       }
       // target is already a Proxy, return it.
       // exception: calling readonly() on a reactive object
-      if (target["__v_raw" /* RAW */] &&
-          !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) {
+      if (target["__v_raw" /* ReactiveFlags.RAW */] &&
+          !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
           return target;
       }
       // target already has corresponding Proxy
@@ -1281,34 +1281,34 @@ var Vue = (function () {
       }
       // only specific value types can be observed.
       const targetType = getTargetType(target);
-      if (targetType === 0 /* INVALID */) {
+      if (targetType === 0 /* TargetType.INVALID */) {
           return target;
       }
-      const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers);
+      const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
       proxyMap.set(target, proxy);
       return proxy;
   }
   function isReactive(value) {
       if (isReadonly(value)) {
-          return isReactive(value["__v_raw" /* RAW */]);
+          return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
       }
-      return !!(value && value["__v_isReactive" /* IS_REACTIVE */]);
+      return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
   }
   function isReadonly(value) {
-      return !!(value && value["__v_isReadonly" /* IS_READONLY */]);
+      return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
   }
   function isShallow(value) {
-      return !!(value && value["__v_isShallow" /* IS_SHALLOW */]);
+      return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
   }
   function isProxy(value) {
       return isReactive(value) || isReadonly(value);
   }
   function toRaw(observed) {
-      const raw = observed && observed["__v_raw" /* RAW */];
+      const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
       return raw ? toRaw(raw) : observed;
   }
   function markRaw(value) {
-      def(value, "__v_skip" /* SKIP */, true);
+      def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
       return value;
   }
   const toReactive = (value) => isObject(value) ? reactive(value) : value;
@@ -1320,7 +1320,7 @@ var Vue = (function () {
           {
               trackEffects(ref.dep || (ref.dep = createDep()), {
                   target: ref,
-                  type: "get" /* GET */,
+                  type: "get" /* TrackOpTypes.GET */,
                   key: 'value'
               });
           }
@@ -1332,7 +1332,7 @@ var Vue = (function () {
           {
               triggerEffects(ref.dep, {
                   target: ref,
-                  type: "set" /* SET */,
+                  type: "set" /* TriggerOpTypes.SET */,
                   key: 'value',
                   newValue: newVal
               });
@@ -1367,10 +1367,11 @@ var Vue = (function () {
           return this._value;
       }
       set value(newVal) {
-          newVal = this.__v_isShallow ? newVal : toRaw(newVal);
+          const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
+          newVal = useDirectValue ? newVal : toRaw(newVal);
           if (hasChanged(newVal, this._rawValue)) {
               this._rawValue = newVal;
-              this._value = this.__v_isShallow ? newVal : toReactive(newVal);
+              this._value = useDirectValue ? newVal : toReactive(newVal);
               triggerRefValue(this, newVal);
           }
       }
@@ -1449,11 +1450,13 @@ var Vue = (function () {
           : new ObjectRefImpl(object, key, defaultValue);
   }
 
+  var _a;
   class ComputedRefImpl {
       constructor(getter, _setter, isReadonly, isSSR) {
           this._setter = _setter;
           this.dep = undefined;
           this.__v_isRef = true;
+          this[_a] = false;
           this._dirty = true;
           this.effect = new ReactiveEffect(getter, () => {
               if (!this._dirty) {
@@ -1463,7 +1466,7 @@ var Vue = (function () {
           });
           this.effect.computed = this;
           this.effect.active = this._cacheable = !isSSR;
-          this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
+          this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
       }
       get value() {
           // the computed ref may get wrapped by other proxies e.g. readonly() #3376
@@ -1479,6 +1482,7 @@ var Vue = (function () {
           this._setter(newValue);
       }
   }
+  _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
   function computed(getterOrOptions, debugOptions, isSSR = false) {
       let getter;
       let setter;
@@ -1517,7 +1521,7 @@ var Vue = (function () {
       const appWarnHandler = instance && instance.appContext.config.warnHandler;
       const trace = getComponentTrace();
       if (appWarnHandler) {
-          callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [
+          callWithErrorHandling(appWarnHandler, instance, 11 /* ErrorCodes.APP_WARN_HANDLER */, [
               msg + args.join(''),
               instance && instance.proxy,
               trace
@@ -1617,35 +1621,35 @@ var Vue = (function () {
   }
 
   const ErrorTypeStrings = {
-      ["sp" /* SERVER_PREFETCH */]: 'serverPrefetch hook',
-      ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook',
-      ["c" /* CREATED */]: 'created hook',
-      ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook',
-      ["m" /* MOUNTED */]: 'mounted hook',
-      ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook',
-      ["u" /* UPDATED */]: 'updated',
-      ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook',
-      ["um" /* UNMOUNTED */]: 'unmounted hook',
-      ["a" /* ACTIVATED */]: 'activated hook',
-      ["da" /* DEACTIVATED */]: 'deactivated hook',
-      ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook',
-      ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook',
-      ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook',
-      [0 /* SETUP_FUNCTION */]: 'setup function',
-      [1 /* RENDER_FUNCTION */]: 'render function',
-      [2 /* WATCH_GETTER */]: 'watcher getter',
-      [3 /* WATCH_CALLBACK */]: 'watcher callback',
-      [4 /* WATCH_CLEANUP */]: 'watcher cleanup function',
-      [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler',
-      [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler',
-      [7 /* VNODE_HOOK */]: 'vnode hook',
-      [8 /* DIRECTIVE_HOOK */]: 'directive hook',
-      [9 /* TRANSITION_HOOK */]: 'transition hook',
-      [10 /* APP_ERROR_HANDLER */]: 'app errorHandler',
-      [11 /* APP_WARN_HANDLER */]: 'app warnHandler',
-      [12 /* FUNCTION_REF */]: 'ref function',
-      [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader',
-      [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
+      ["sp" /* LifecycleHooks.SERVER_PREFETCH */]: 'serverPrefetch hook',
+      ["bc" /* LifecycleHooks.BEFORE_CREATE */]: 'beforeCreate hook',
+      ["c" /* LifecycleHooks.CREATED */]: 'created hook',
+      ["bm" /* LifecycleHooks.BEFORE_MOUNT */]: 'beforeMount hook',
+      ["m" /* LifecycleHooks.MOUNTED */]: 'mounted hook',
+      ["bu" /* LifecycleHooks.BEFORE_UPDATE */]: 'beforeUpdate hook',
+      ["u" /* LifecycleHooks.UPDATED */]: 'updated',
+      ["bum" /* LifecycleHooks.BEFORE_UNMOUNT */]: 'beforeUnmount hook',
+      ["um" /* LifecycleHooks.UNMOUNTED */]: 'unmounted hook',
+      ["a" /* LifecycleHooks.ACTIVATED */]: 'activated hook',
+      ["da" /* LifecycleHooks.DEACTIVATED */]: 'deactivated hook',
+      ["ec" /* LifecycleHooks.ERROR_CAPTURED */]: 'errorCaptured hook',
+      ["rtc" /* LifecycleHooks.RENDER_TRACKED */]: 'renderTracked hook',
+      ["rtg" /* LifecycleHooks.RENDER_TRIGGERED */]: 'renderTriggered hook',
+      [0 /* ErrorCodes.SETUP_FUNCTION */]: 'setup function',
+      [1 /* ErrorCodes.RENDER_FUNCTION */]: 'render function',
+      [2 /* ErrorCodes.WATCH_GETTER */]: 'watcher getter',
+      [3 /* ErrorCodes.WATCH_CALLBACK */]: 'watcher callback',
+      [4 /* ErrorCodes.WATCH_CLEANUP */]: 'watcher cleanup function',
+      [5 /* ErrorCodes.NATIVE_EVENT_HANDLER */]: 'native event handler',
+      [6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */]: 'component event handler',
+      [7 /* ErrorCodes.VNODE_HOOK */]: 'vnode hook',
+      [8 /* ErrorCodes.DIRECTIVE_HOOK */]: 'directive hook',
+      [9 /* ErrorCodes.TRANSITION_HOOK */]: 'transition hook',
+      [10 /* ErrorCodes.APP_ERROR_HANDLER */]: 'app errorHandler',
+      [11 /* ErrorCodes.APP_WARN_HANDLER */]: 'app warnHandler',
+      [12 /* ErrorCodes.FUNCTION_REF */]: 'ref function',
+      [13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */]: 'async component loader',
+      [14 /* ErrorCodes.SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' +
           'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core'
   };
   function callWithErrorHandling(fn, instance, type, args) {
@@ -1696,7 +1700,7 @@ var Vue = (function () {
           // app-level handling
           const appErrorHandler = instance.appContext.config.errorHandler;
           if (appErrorHandler) {
-              callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
+              callWithErrorHandling(appErrorHandler, null, 10 /* ErrorCodes.APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]);
               return;
           }
       }
@@ -1726,15 +1730,11 @@ var Vue = (function () {
   let isFlushPending = false;
   const queue = [];
   let flushIndex = 0;
-  const pendingPreFlushCbs = [];
-  let activePreFlushCbs = null;
-  let preFlushIndex = 0;
   const pendingPostFlushCbs = [];
   let activePostFlushCbs = null;
   let postFlushIndex = 0;
   const resolvedPromise = /*#__PURE__*/ Promise.resolve();
   let currentFlushPromise = null;
-  let currentPreFlushParentJob = null;
   const RECURSION_LIMIT = 100;
   function nextTick(fn) {
       const p = currentFlushPromise || resolvedPromise;
@@ -1762,9 +1762,8 @@ var Vue = (function () {
       // if the job is a watch() callback, the search will start with a +1 index to
       // allow it recursively trigger itself - it is the user's responsibility to
       // ensure it doesn't end up in an infinite loop.
-      if ((!queue.length ||
-          !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) &&
-          job !== currentPreFlushParentJob) {
+      if (!queue.length ||
+          !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) {
           if (job.id == null) {
               queue.push(job);
           }
@@ -1786,51 +1785,40 @@ var Vue = (function () {
           queue.splice(i, 1);
       }
   }
-  function queueCb(cb, activeQueue, pendingQueue, index) {
+  function queuePostFlushCb(cb) {
       if (!isArray(cb)) {
-          if (!activeQueue ||
-              !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) {
-              pendingQueue.push(cb);
+          if (!activePostFlushCbs ||
+              !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) {
+              pendingPostFlushCbs.push(cb);
           }
       }
       else {
           // if cb is an array, it is a component lifecycle hook which can only be
           // triggered by a job, which is already deduped in the main queue, so
           // we can skip duplicate check here to improve perf
-          pendingQueue.push(...cb);
+          pendingPostFlushCbs.push(...cb);
       }
       queueFlush();
   }
-  function queuePreFlushCb(cb) {
-      queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex);
-  }
-  function queuePostFlushCb(cb) {
-      queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex);
-  }
-  function flushPreFlushCbs(seen, parentJob = null) {
-      if (pendingPreFlushCbs.length) {
-          currentPreFlushParentJob = parentJob;
-          activePreFlushCbs = [...new Set(pendingPreFlushCbs)];
-          pendingPreFlushCbs.length = 0;
-          {
-              seen = seen || new Map();
-          }
-          for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {
-              if (checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) {
+  function flushPreFlushCbs(seen, 
+  // if currently flushing, skip the current job itself
+  i = isFlushing ? flushIndex + 1 : 0) {
+      {
+          seen = seen || new Map();
+      }
+      for (; i < queue.length; i++) {
+          const cb = queue[i];
+          if (cb && cb.pre) {
+              if (checkRecursiveUpdates(seen, cb)) {
                   continue;
               }
-              activePreFlushCbs[preFlushIndex]();
+              queue.splice(i, 1);
+              i--;
+              cb();
           }
-          activePreFlushCbs = null;
-          preFlushIndex = 0;
-          currentPreFlushParentJob = null;
-          // recursively flush until it drains
-          flushPreFlushCbs(seen, parentJob);
       }
   }
   function flushPostFlushCbs(seen) {
-      // flush any pre cbs queued during the flush (e.g. pre watchers)
-      flushPreFlushCbs();
       if (pendingPostFlushCbs.length) {
           const deduped = [...new Set(pendingPostFlushCbs)];
           pendingPostFlushCbs.length = 0;
@@ -1855,13 +1843,22 @@ var Vue = (function () {
       }
   }
   const getId = (job) => job.id == null ? Infinity : job.id;
+  const comparator = (a, b) => {
+      const diff = getId(a) - getId(b);
+      if (diff === 0) {
+          if (a.pre && !b.pre)
+              return -1;
+          if (b.pre && !a.pre)
+              return 1;
+      }
+      return diff;
+  };
   function flushJobs(seen) {
       isFlushPending = false;
       isFlushing = true;
       {
           seen = seen || new Map();
       }
-      flushPreFlushCbs(seen);
       // Sort queue before flush.
       // This ensures that:
       // 1. Components are updated from parent to child. (because parent is always
@@ -1869,7 +1866,7 @@ var Vue = (function () {
       //    priority number)
       // 2. If a component is unmounted during a parent component's update,
       //    its update can be skipped.
-      queue.sort((a, b) => getId(a) - getId(b));
+      queue.sort(comparator);
       // conditional usage of checkRecursiveUpdate must be determined out of
       // try ... catch block since Rollup by default de-optimizes treeshaking
       // inside try-catch. This can leave all warning code unshaked. Although
@@ -1885,7 +1882,7 @@ var Vue = (function () {
                       continue;
                   }
                   // console.log(`running:`, job.id)
-                  callWithErrorHandling(job, null, 14 /* SCHEDULER */);
+                  callWithErrorHandling(job, null, 14 /* ErrorCodes.SCHEDULER */);
               }
           }
       }
@@ -1897,9 +1894,7 @@ var Vue = (function () {
           currentFlushPromise = null;
           // some postFlushCb queued jobs!
           // keep flushing until it drains.
-          if (queue.length ||
-              pendingPreFlushCbs.length ||
-              pendingPostFlushCbs.length) {
+          if (queue.length || pendingPostFlushCbs.length) {
               flushJobs(seen);
           }
       }
@@ -2117,7 +2112,7 @@ var Vue = (function () {
       }
   }
   function devtoolsInitApp(app, version) {
-      emit("app:init" /* APP_INIT */, app, version, {
+      emit("app:init" /* DevtoolsHooks.APP_INIT */, app, version, {
           Fragment,
           Text,
           Comment,
@@ -2125,88 +2120,88 @@ var Vue = (function () {
       });
   }
   function devtoolsUnmountApp(app) {
-      emit("app:unmount" /* APP_UNMOUNT */, app);
+      emit("app:unmount" /* DevtoolsHooks.APP_UNMOUNT */, app);
   }
-  const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */);
+  const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* DevtoolsHooks.COMPONENT_ADDED */);
   const devtoolsComponentUpdated = 
-  /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
+  /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* DevtoolsHooks.COMPONENT_UPDATED */);
   const devtoolsComponentRemoved = 
-  /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* COMPONENT_REMOVED */);
+  /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* DevtoolsHooks.COMPONENT_REMOVED */);
   function createDevtoolsComponentHook(hook) {
       return (component) => {
           emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component);
       };
   }
-  const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */);
-  const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */);
+  const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* DevtoolsHooks.PERFORMANCE_START */);
+  const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* DevtoolsHooks.PERFORMANCE_END */);
   function createDevtoolsPerformanceHook(hook) {
       return (component, type, time) => {
           emit(hook, component.appContext.app, component.uid, component, type, time);
       };
   }
   function devtoolsComponentEmit(component, event, params) {
-      emit("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params);
+      emit("component:emit" /* DevtoolsHooks.COMPONENT_EMIT */, component.appContext.app, component, event, params);
   }
 
   const deprecationData = {
-      ["GLOBAL_MOUNT" /* GLOBAL_MOUNT */]: {
+      ["GLOBAL_MOUNT" /* DeprecationTypes.GLOBAL_MOUNT */]: {
           message: `The global app bootstrapping API has changed: vm.$mount() and the "el" ` +
               `option have been removed. Use createApp(RootComponent).mount() instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/global-api.html#mounting-app-instance`
       },
-      ["GLOBAL_MOUNT_CONTAINER" /* GLOBAL_MOUNT_CONTAINER */]: {
+      ["GLOBAL_MOUNT_CONTAINER" /* DeprecationTypes.GLOBAL_MOUNT_CONTAINER */]: {
           message: `Vue detected directives on the mount container. ` +
               `In Vue 3, the container is no longer considered part of the template ` +
               `and will not be processed/replaced.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/mount-changes.html`
       },
-      ["GLOBAL_EXTEND" /* GLOBAL_EXTEND */]: {
+      ["GLOBAL_EXTEND" /* DeprecationTypes.GLOBAL_EXTEND */]: {
           message: `Vue.extend() has been removed in Vue 3. ` +
               `Use defineComponent() instead.`,
           link: `https://vuejs.org/api/general.html#definecomponent`
       },
-      ["GLOBAL_PROTOTYPE" /* GLOBAL_PROTOTYPE */]: {
+      ["GLOBAL_PROTOTYPE" /* DeprecationTypes.GLOBAL_PROTOTYPE */]: {
           message: `Vue.prototype is no longer available in Vue 3. ` +
               `Use app.config.globalProperties instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/global-api.html#vue-prototype-replaced-by-config-globalproperties`
       },
-      ["GLOBAL_SET" /* GLOBAL_SET */]: {
+      ["GLOBAL_SET" /* DeprecationTypes.GLOBAL_SET */]: {
           message: `Vue.set() has been removed as it is no longer needed in Vue 3. ` +
               `Simply use native JavaScript mutations.`
       },
-      ["GLOBAL_DELETE" /* GLOBAL_DELETE */]: {
+      ["GLOBAL_DELETE" /* DeprecationTypes.GLOBAL_DELETE */]: {
           message: `Vue.delete() has been removed as it is no longer needed in Vue 3. ` +
               `Simply use native JavaScript mutations.`
       },
-      ["GLOBAL_OBSERVABLE" /* GLOBAL_OBSERVABLE */]: {
+      ["GLOBAL_OBSERVABLE" /* DeprecationTypes.GLOBAL_OBSERVABLE */]: {
           message: `Vue.observable() has been removed. ` +
               `Use \`import { reactive } from "vue"\` from Composition API instead.`,
           link: `https://vuejs.org/api/reactivity-core.html#reactive`
       },
-      ["GLOBAL_PRIVATE_UTIL" /* GLOBAL_PRIVATE_UTIL */]: {
+      ["GLOBAL_PRIVATE_UTIL" /* DeprecationTypes.GLOBAL_PRIVATE_UTIL */]: {
           message: `Vue.util has been removed. Please refactor to avoid its usage ` +
               `since it was an internal API even in Vue 2.`
       },
-      ["CONFIG_SILENT" /* CONFIG_SILENT */]: {
+      ["CONFIG_SILENT" /* DeprecationTypes.CONFIG_SILENT */]: {
           message: `config.silent has been removed because it is not good practice to ` +
               `intentionally suppress warnings. You can use your browser console's ` +
               `filter features to focus on relevant messages.`
       },
-      ["CONFIG_DEVTOOLS" /* CONFIG_DEVTOOLS */]: {
+      ["CONFIG_DEVTOOLS" /* DeprecationTypes.CONFIG_DEVTOOLS */]: {
           message: `config.devtools has been removed. To enable devtools for ` +
               `production, configure the __VUE_PROD_DEVTOOLS__ compile-time flag.`,
           link: `https://github.com/vuejs/core/tree/main/packages/vue#bundler-build-feature-flags`
       },
-      ["CONFIG_KEY_CODES" /* CONFIG_KEY_CODES */]: {
+      ["CONFIG_KEY_CODES" /* DeprecationTypes.CONFIG_KEY_CODES */]: {
           message: `config.keyCodes has been removed. ` +
               `In Vue 3, you can directly use the kebab-case key names as v-on modifiers.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/keycode-modifiers.html`
       },
-      ["CONFIG_PRODUCTION_TIP" /* CONFIG_PRODUCTION_TIP */]: {
+      ["CONFIG_PRODUCTION_TIP" /* DeprecationTypes.CONFIG_PRODUCTION_TIP */]: {
           message: `config.productionTip has been removed.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-productiontip-removed`
       },
-      ["CONFIG_IGNORED_ELEMENTS" /* CONFIG_IGNORED_ELEMENTS */]: {
+      ["CONFIG_IGNORED_ELEMENTS" /* DeprecationTypes.CONFIG_IGNORED_ELEMENTS */]: {
           message: () => {
               let msg = `config.ignoredElements has been removed.`;
               if (isRuntimeOnly()) {
@@ -2219,35 +2214,35 @@ var Vue = (function () {
           },
           link: `https://v3-migration.vuejs.org/breaking-changes/global-api.html#config-ignoredelements-is-now-config-iscustomelement`
       },
-      ["CONFIG_WHITESPACE" /* CONFIG_WHITESPACE */]: {
+      ["CONFIG_WHITESPACE" /* DeprecationTypes.CONFIG_WHITESPACE */]: {
           // this warning is only relevant in the full build when using runtime
           // compilation, so it's put in the runtime compatConfig list.
           message: `Vue 3 compiler's whitespace option will default to "condense" instead of ` +
               `"preserve". To suppress this warning, provide an explicit value for ` +
               `\`config.compilerOptions.whitespace\`.`
       },
-      ["CONFIG_OPTION_MERGE_STRATS" /* CONFIG_OPTION_MERGE_STRATS */]: {
+      ["CONFIG_OPTION_MERGE_STRATS" /* DeprecationTypes.CONFIG_OPTION_MERGE_STRATS */]: {
           message: `config.optionMergeStrategies no longer exposes internal strategies. ` +
               `Use custom merge functions instead.`
       },
-      ["INSTANCE_SET" /* INSTANCE_SET */]: {
+      ["INSTANCE_SET" /* DeprecationTypes.INSTANCE_SET */]: {
           message: `vm.$set() has been removed as it is no longer needed in Vue 3. ` +
               `Simply use native JavaScript mutations.`
       },
-      ["INSTANCE_DELETE" /* INSTANCE_DELETE */]: {
+      ["INSTANCE_DELETE" /* DeprecationTypes.INSTANCE_DELETE */]: {
           message: `vm.$delete() has been removed as it is no longer needed in Vue 3. ` +
               `Simply use native JavaScript mutations.`
       },
-      ["INSTANCE_DESTROY" /* INSTANCE_DESTROY */]: {
+      ["INSTANCE_DESTROY" /* DeprecationTypes.INSTANCE_DESTROY */]: {
           message: `vm.$destroy() has been removed. Use app.unmount() instead.`,
           link: `https://vuejs.org/api/application.html#app-unmount`
       },
-      ["INSTANCE_EVENT_EMITTER" /* INSTANCE_EVENT_EMITTER */]: {
+      ["INSTANCE_EVENT_EMITTER" /* DeprecationTypes.INSTANCE_EVENT_EMITTER */]: {
           message: `vm.$on/$once/$off() have been removed. ` +
               `Use an external event emitter library instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/events-api.html`
       },
-      ["INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */]: {
+      ["INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */]: {
           message: event => `"${event}" lifecycle events are no longer supported. From templates, ` +
               `use the "vnode" prefix instead of "hook:". For example, @${event} ` +
               `should be changed to @vnode-${event.slice(5)}. ` +
@@ -2255,23 +2250,23 @@ var Vue = (function () {
               `hooks.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/vnode-lifecycle-events.html`
       },
-      ["INSTANCE_CHILDREN" /* INSTANCE_CHILDREN */]: {
+      ["INSTANCE_CHILDREN" /* DeprecationTypes.INSTANCE_CHILDREN */]: {
           message: `vm.$children has been removed. Consider refactoring your logic ` +
               `to avoid relying on direct access to child components.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/children.html`
       },
-      ["INSTANCE_LISTENERS" /* INSTANCE_LISTENERS */]: {
+      ["INSTANCE_LISTENERS" /* DeprecationTypes.INSTANCE_LISTENERS */]: {
           message: `vm.$listeners has been removed. In Vue 3, parent v-on listeners are ` +
               `included in vm.$attrs and it is no longer necessary to separately use ` +
               `v-on="$listeners" if you are already using v-bind="$attrs". ` +
               `(Note: the Vue 3 behavior only applies if this compat config is disabled)`,
           link: `https://v3-migration.vuejs.org/breaking-changes/listeners-removed.html`
       },
-      ["INSTANCE_SCOPED_SLOTS" /* INSTANCE_SCOPED_SLOTS */]: {
+      ["INSTANCE_SCOPED_SLOTS" /* DeprecationTypes.INSTANCE_SCOPED_SLOTS */]: {
           message: `vm.$scopedSlots has been removed. Use vm.$slots instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/slots-unification.html`
       },
-      ["INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */]: {
+      ["INSTANCE_ATTRS_CLASS_STYLE" /* DeprecationTypes.INSTANCE_ATTRS_CLASS_STYLE */]: {
           message: componentName => `Component <${componentName || 'Anonymous'}> has \`inheritAttrs: false\` but is ` +
               `relying on class/style fallthrough from parent. In Vue 3, class/style ` +
               `are now included in $attrs and will no longer fallthrough when ` +
@@ -2282,75 +2277,75 @@ var Vue = (function () {
               `them on root via :class="$attrs.class".`,
           link: `https://v3-migration.vuejs.org/breaking-changes/attrs-includes-class-style.html`
       },
-      ["OPTIONS_DATA_FN" /* OPTIONS_DATA_FN */]: {
+      ["OPTIONS_DATA_FN" /* DeprecationTypes.OPTIONS_DATA_FN */]: {
           message: `The "data" option can no longer be a plain object. ` +
               `Always use a function.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/data-option.html`
       },
-      ["OPTIONS_DATA_MERGE" /* OPTIONS_DATA_MERGE */]: {
+      ["OPTIONS_DATA_MERGE" /* DeprecationTypes.OPTIONS_DATA_MERGE */]: {
           message: (key) => `Detected conflicting key "${key}" when merging data option values. ` +
               `In Vue 3, data keys are merged shallowly and will override one another.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/data-option.html#mixin-merge-behavior-change`
       },
-      ["OPTIONS_BEFORE_DESTROY" /* OPTIONS_BEFORE_DESTROY */]: {
+      ["OPTIONS_BEFORE_DESTROY" /* DeprecationTypes.OPTIONS_BEFORE_DESTROY */]: {
           message: `\`beforeDestroy\` has been renamed to \`beforeUnmount\`.`
       },
-      ["OPTIONS_DESTROYED" /* OPTIONS_DESTROYED */]: {
+      ["OPTIONS_DESTROYED" /* DeprecationTypes.OPTIONS_DESTROYED */]: {
           message: `\`destroyed\` has been renamed to \`unmounted\`.`
       },
-      ["WATCH_ARRAY" /* WATCH_ARRAY */]: {
+      ["WATCH_ARRAY" /* DeprecationTypes.WATCH_ARRAY */]: {
           message: `"watch" option or vm.$watch on an array value will no longer ` +
               `trigger on array mutation unless the "deep" option is specified. ` +
               `If current usage is intended, you can disable the compat behavior and ` +
               `suppress this warning with:` +
-              `\n\n  configureCompat({ ${"WATCH_ARRAY" /* WATCH_ARRAY */}: false })\n`,
+              `\n\n  configureCompat({ ${"WATCH_ARRAY" /* DeprecationTypes.WATCH_ARRAY */}: false })\n`,
           link: `https://v3-migration.vuejs.org/breaking-changes/watch.html`
       },
-      ["PROPS_DEFAULT_THIS" /* PROPS_DEFAULT_THIS */]: {
+      ["PROPS_DEFAULT_THIS" /* DeprecationTypes.PROPS_DEFAULT_THIS */]: {
           message: (key) => `props default value function no longer has access to "this". The compat ` +
               `build only offers access to this.$options.` +
               `(found in prop "${key}")`,
           link: `https://v3-migration.vuejs.org/breaking-changes/props-default-this.html`
       },
-      ["CUSTOM_DIR" /* CUSTOM_DIR */]: {
+      ["CUSTOM_DIR" /* DeprecationTypes.CUSTOM_DIR */]: {
           message: (legacyHook, newHook) => `Custom directive hook "${legacyHook}" has been removed. ` +
               `Use "${newHook}" instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/custom-directives.html`
       },
-      ["V_ON_KEYCODE_MODIFIER" /* V_ON_KEYCODE_MODIFIER */]: {
+      ["V_ON_KEYCODE_MODIFIER" /* DeprecationTypes.V_ON_KEYCODE_MODIFIER */]: {
           message: `Using keyCode as v-on modifier is no longer supported. ` +
               `Use kebab-case key name modifiers instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/keycode-modifiers.html`
       },
-      ["ATTR_FALSE_VALUE" /* ATTR_FALSE_VALUE */]: {
+      ["ATTR_FALSE_VALUE" /* DeprecationTypes.ATTR_FALSE_VALUE */]: {
           message: (name) => `Attribute "${name}" with v-bind value \`false\` will render ` +
               `${name}="false" instead of removing it in Vue 3. To remove the attribute, ` +
               `use \`null\` or \`undefined\` instead. If the usage is intended, ` +
               `you can disable the compat behavior and suppress this warning with:` +
-              `\n\n  configureCompat({ ${"ATTR_FALSE_VALUE" /* ATTR_FALSE_VALUE */}: false })\n`,
+              `\n\n  configureCompat({ ${"ATTR_FALSE_VALUE" /* DeprecationTypes.ATTR_FALSE_VALUE */}: false })\n`,
           link: `https://v3-migration.vuejs.org/breaking-changes/attribute-coercion.html`
       },
-      ["ATTR_ENUMERATED_COERCION" /* ATTR_ENUMERATED_COERCION */]: {
+      ["ATTR_ENUMERATED_COERCION" /* DeprecationTypes.ATTR_ENUMERATED_COERCION */]: {
           message: (name, value, coerced) => `Enumerated attribute "${name}" with v-bind value \`${value}\` will ` +
               `${value === null ? `be removed` : `render the value as-is`} instead of coercing the value to "${coerced}" in Vue 3. ` +
               `Always use explicit "true" or "false" values for enumerated attributes. ` +
               `If the usage is intended, ` +
               `you can disable the compat behavior and suppress this warning with:` +
-              `\n\n  configureCompat({ ${"ATTR_ENUMERATED_COERCION" /* ATTR_ENUMERATED_COERCION */}: false })\n`,
+              `\n\n  configureCompat({ ${"ATTR_ENUMERATED_COERCION" /* DeprecationTypes.ATTR_ENUMERATED_COERCION */}: false })\n`,
           link: `https://v3-migration.vuejs.org/breaking-changes/attribute-coercion.html`
       },
-      ["TRANSITION_CLASSES" /* TRANSITION_CLASSES */]: {
+      ["TRANSITION_CLASSES" /* DeprecationTypes.TRANSITION_CLASSES */]: {
           message: `` // this feature cannot be runtime-detected
       },
-      ["TRANSITION_GROUP_ROOT" /* TRANSITION_GROUP_ROOT */]: {
+      ["TRANSITION_GROUP_ROOT" /* DeprecationTypes.TRANSITION_GROUP_ROOT */]: {
           message: `<TransitionGroup> no longer renders a root <span> element by ` +
               `default if no "tag" prop is specified. If you do not rely on the span ` +
               `for styling, you can disable the compat behavior and suppress this ` +
               `warning with:` +
-              `\n\n  configureCompat({ ${"TRANSITION_GROUP_ROOT" /* TRANSITION_GROUP_ROOT */}: false })\n`,
+              `\n\n  configureCompat({ ${"TRANSITION_GROUP_ROOT" /* DeprecationTypes.TRANSITION_GROUP_ROOT */}: false })\n`,
           link: `https://v3-migration.vuejs.org/breaking-changes/transition-group.html`
       },
-      ["COMPONENT_ASYNC" /* COMPONENT_ASYNC */]: {
+      ["COMPONENT_ASYNC" /* DeprecationTypes.COMPONENT_ASYNC */]: {
           message: (comp) => {
               const name = getComponentName(comp);
               return (`Async component${name ? ` <${name}>` : `s`} should be explicitly created via \`defineAsyncComponent()\` ` +
@@ -2359,11 +2354,11 @@ var Vue = (function () {
                   `usage and intend to use plain functions for functional components, ` +
                   `you can disable the compat behavior and suppress this ` +
                   `warning with:` +
-                  `\n\n  configureCompat({ ${"COMPONENT_ASYNC" /* COMPONENT_ASYNC */}: false })\n`);
+                  `\n\n  configureCompat({ ${"COMPONENT_ASYNC" /* DeprecationTypes.COMPONENT_ASYNC */}: false })\n`);
           },
           link: `https://v3-migration.vuejs.org/breaking-changes/async-components.html`
       },
-      ["COMPONENT_FUNCTIONAL" /* COMPONENT_FUNCTIONAL */]: {
+      ["COMPONENT_FUNCTIONAL" /* DeprecationTypes.COMPONENT_FUNCTIONAL */]: {
           message: (comp) => {
               const name = getComponentName(comp);
               return (`Functional component${name ? ` <${name}>` : `s`} should be defined as a plain function in Vue 3. The "functional" ` +
@@ -2374,10 +2369,10 @@ var Vue = (function () {
           },
           link: `https://v3-migration.vuejs.org/breaking-changes/functional-components.html`
       },
-      ["COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */]: {
+      ["COMPONENT_V_MODEL" /* DeprecationTypes.COMPONENT_V_MODEL */]: {
           message: (comp) => {
               const configMsg = `opt-in to ` +
-                  `Vue 3 behavior on a per-component basis with \`compatConfig: { ${"COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */}: false }\`.`;
+                  `Vue 3 behavior on a per-component basis with \`compatConfig: { ${"COMPONENT_V_MODEL" /* DeprecationTypes.COMPONENT_V_MODEL */}: false }\`.`;
               if (comp.props &&
                   (isArray(comp.props)
                       ? comp.props.includes('modelValue')
@@ -2391,20 +2386,20 @@ var Vue = (function () {
           },
           link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
       },
-      ["RENDER_FUNCTION" /* RENDER_FUNCTION */]: {
+      ["RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */]: {
           message: `Vue 3's render function API has changed. ` +
               `You can opt-in to the new API with:` +
-              `\n\n  configureCompat({ ${"RENDER_FUNCTION" /* RENDER_FUNCTION */}: false })\n` +
+              `\n\n  configureCompat({ ${"RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */}: false })\n` +
               `\n  (This can also be done per-component via the "compatConfig" option.)`,
           link: `https://v3-migration.vuejs.org/breaking-changes/render-function-api.html`
       },
-      ["FILTERS" /* FILTERS */]: {
+      ["FILTERS" /* DeprecationTypes.FILTERS */]: {
           message: `filters have been removed in Vue 3. ` +
               `The "|" symbol will be treated as native JavaScript bitwise OR operator. ` +
               `Use method calls or computed properties instead.`,
           link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
       },
-      ["PRIVATE_APIS" /* PRIVATE_APIS */]: {
+      ["PRIVATE_APIS" /* DeprecationTypes.PRIVATE_APIS */]: {
           message: name => `"${name}" is a Vue 2 private API that no longer exists in Vue 3. ` +
               `If you are seeing this warning only due to a dependency, you can ` +
               `suppress this warning via { PRIVATE_APIS: 'suppress-warning' }.`
@@ -2479,8 +2474,8 @@ var Vue = (function () {
               warnedInvalidKeys[key] = true;
           }
       }
-      if (instance && config["OPTIONS_DATA_MERGE" /* OPTIONS_DATA_MERGE */] != null) {
-          warn$1(`Deprecation config "${"OPTIONS_DATA_MERGE" /* OPTIONS_DATA_MERGE */}" can only be configured globally.`);
+      if (instance && config["OPTIONS_DATA_MERGE" /* DeprecationTypes.OPTIONS_DATA_MERGE */] != null) {
+          warn$1(`Deprecation config "${"OPTIONS_DATA_MERGE" /* DeprecationTypes.OPTIONS_DATA_MERGE */}" can only be configured globally.`);
       }
   }
   function getCompatConfigForKey(key, instance) {
@@ -2555,10 +2550,10 @@ var Vue = (function () {
       }
       else {
           if (event.startsWith('hook:')) {
-              assertCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance, event);
+              assertCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance, event);
           }
           else {
-              assertCompatEnabled("INSTANCE_EVENT_EMITTER" /* INSTANCE_EVENT_EMITTER */, instance);
+              assertCompatEnabled("INSTANCE_EVENT_EMITTER" /* DeprecationTypes.INSTANCE_EVENT_EMITTER */, instance);
           }
           const events = getRegistry(instance);
           (events[event] || (events[event] = [])).push(fn);
@@ -2575,7 +2570,7 @@ var Vue = (function () {
       return instance.proxy;
   }
   function off(instance, event, fn) {
-      assertCompatEnabled("INSTANCE_EVENT_EMITTER" /* INSTANCE_EVENT_EMITTER */, instance);
+      assertCompatEnabled("INSTANCE_EVENT_EMITTER" /* DeprecationTypes.INSTANCE_EVENT_EMITTER */, instance);
       const vm = instance.proxy;
       // all
       if (!event) {
@@ -2603,7 +2598,7 @@ var Vue = (function () {
   function emit$1(instance, event, args) {
       const cbs = getRegistry(instance)[event];
       if (cbs) {
-          callWithAsyncErrorHandling(cbs.map(cb => cb.bind(instance.proxy)), instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+          callWithAsyncErrorHandling(cbs.map(cb => cb.bind(instance.proxy)), instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
       }
       return instance.proxy;
   }
@@ -2613,8 +2608,8 @@ var Vue = (function () {
   function convertLegacyVModelProps(vnode) {
       const { type, shapeFlag, props, dynamicProps } = vnode;
       const comp = type;
-      if (shapeFlag & 6 /* COMPONENT */ && props && 'modelValue' in props) {
-          if (!isCompatEnabled("COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */, 
+      if (shapeFlag & 6 /* ShapeFlags.COMPONENT */ && props && 'modelValue' in props) {
+          if (!isCompatEnabled("COMPONENT_V_MODEL" /* DeprecationTypes.COMPONENT_V_MODEL */, 
           // this is a special case where we want to use the vnode component's
           // compat config instead of the current rendering instance (which is the
           // parent of the component that exposes v-model)
@@ -2623,7 +2618,7 @@ var Vue = (function () {
           }
           if (!warnedTypes.has(comp)) {
               pushWarningContext(vnode);
-              warnDeprecation("COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */, { type }, comp);
+              warnDeprecation("COMPONENT_V_MODEL" /* DeprecationTypes.COMPONENT_V_MODEL */, { type }, comp);
               popWarningContext();
               warnedTypes.add(comp);
           }
@@ -2656,13 +2651,13 @@ var Vue = (function () {
       }
   }
   function compatModelEmit(instance, event, args) {
-      if (!isCompatEnabled("COMPONENT_V_MODEL" /* COMPONENT_V_MODEL */, instance)) {
+      if (!isCompatEnabled("COMPONENT_V_MODEL" /* DeprecationTypes.COMPONENT_V_MODEL */, instance)) {
           return;
       }
       const props = instance.vnode.props;
       const modelHandler = props && props[compatModelEventPrefix + event];
       if (modelHandler) {
-          callWithErrorHandling(modelHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+          callWithErrorHandling(modelHandler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
       }
   }
 
@@ -2729,7 +2724,7 @@ var Vue = (function () {
           handler = props[(handlerName = toHandlerKey(hyphenate(event)))];
       }
       if (handler) {
-          callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+          callWithAsyncErrorHandling(handler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
       }
       const onceHandler = props[handlerName + `Once`];
       if (onceHandler) {
@@ -2740,7 +2735,7 @@ var Vue = (function () {
               return;
           }
           instance.emitted[handlerName] = true;
-          callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+          callWithAsyncErrorHandling(onceHandler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
       }
       {
           compatModelEmit(instance, event, args);
@@ -2776,7 +2771,9 @@ var Vue = (function () {
           }
       }
       if (!raw && !hasExtends) {
-          cache.set(comp, null);
+          if (isObject(comp)) {
+              cache.set(comp, null);
+          }
           return null;
       }
       if (isArray(raw)) {
@@ -2785,7 +2782,9 @@ var Vue = (function () {
       else {
           extend(normalized, raw);
       }
-      cache.set(comp, normalized);
+      if (isObject(comp)) {
+          cache.set(comp, normalized);
+      }
       return normalized;
   }
   // Check if an incoming prop key is a declared emit event listener.
@@ -2915,7 +2914,7 @@ var Vue = (function () {
           accessedAttrs = false;
       }
       try {
-          if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
+          if (vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) {
               // withProxy is a proxy with a different `has` trap only for
               // runtime-compiled render functions using `with` block.
               const proxyToUse = withProxy || proxy;
@@ -2948,7 +2947,7 @@ var Vue = (function () {
       }
       catch (err) {
           blockStack.length = 0;
-          handleError(err, instance, 1 /* RENDER_FUNCTION */);
+          handleError(err, instance, 1 /* ErrorCodes.RENDER_FUNCTION */);
           result = createVNode(Comment);
       }
       // attr merging
@@ -2957,14 +2956,14 @@ var Vue = (function () {
       let root = result;
       let setRoot = undefined;
       if (result.patchFlag > 0 &&
-          result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {
+          result.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */) {
           [root, setRoot] = getChildRoot(result);
       }
       if (fallthroughAttrs && inheritAttrs !== false) {
           const keys = Object.keys(fallthroughAttrs);
           const { shapeFlag } = root;
           if (keys.length) {
-              if (shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
+              if (shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 6 /* ShapeFlags.COMPONENT */)) {
                   if (propsOptions && keys.some(isModelListener)) {
                       // If a v-model listener (onUpdate:xxx) has a corresponding declared
                       // prop, it indicates this component expects to handle v-model and
@@ -3009,13 +3008,13 @@ var Vue = (function () {
               }
           }
       }
-      if (isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) &&
-          vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ &&
-          root.shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
+      if (isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* DeprecationTypes.INSTANCE_ATTRS_CLASS_STYLE */, instance) &&
+          vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */ &&
+          root.shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 6 /* ShapeFlags.COMPONENT */)) {
           const { class: cls, style } = vnode.props || {};
           if (cls || style) {
               if (inheritAttrs === false) {
-                  warnDeprecation("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance, getComponentName(instance.type));
+                  warnDeprecation("INSTANCE_ATTRS_CLASS_STYLE" /* DeprecationTypes.INSTANCE_ATTRS_CLASS_STYLE */, instance, getComponentName(instance.type));
               }
               root = cloneVNode(root, {
                   class: cls,
@@ -3119,7 +3118,7 @@ var Vue = (function () {
       return res;
   };
   const isElementRoot = (vnode) => {
-      return (vnode.shapeFlag & (6 /* COMPONENT */ | 1 /* ELEMENT */) ||
+      return (vnode.shapeFlag & (6 /* ShapeFlags.COMPONENT */ | 1 /* ShapeFlags.ELEMENT */) ||
           vnode.type === Comment // potential v-if branch switch
       );
   };
@@ -3138,19 +3137,19 @@ var Vue = (function () {
           return true;
       }
       if (optimized && patchFlag >= 0) {
-          if (patchFlag & 1024 /* DYNAMIC_SLOTS */) {
+          if (patchFlag & 1024 /* PatchFlags.DYNAMIC_SLOTS */) {
               // slot content that references values that might have changed,
               // e.g. in a v-for
               return true;
           }
-          if (patchFlag & 16 /* FULL_PROPS */) {
+          if (patchFlag & 16 /* PatchFlags.FULL_PROPS */) {
               if (!prevProps) {
                   return !!nextProps;
               }
               // presence of this flag indicates props are always non-null
               return hasPropsChanged(prevProps, nextProps, emits);
           }
-          else if (patchFlag & 8 /* PROPS */) {
+          else if (patchFlag & 8 /* PatchFlags.PROPS */) {
               const dynamicProps = nextVNode.dynamicProps;
               for (let i = 0; i < dynamicProps.length; i++) {
                   const key = dynamicProps[i];
@@ -3408,7 +3407,7 @@ var Vue = (function () {
                   if (delayEnter) {
                       activeBranch.transition.afterLeave = () => {
                           if (pendingId === suspense.pendingId) {
-                              move(pendingBranch, container, anchor, 0 /* ENTER */);
+                              move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */);
                           }
                       };
                   }
@@ -3423,7 +3422,7 @@ var Vue = (function () {
                   }
                   if (!delayEnter) {
                       // move content from off-dom container to actual container
-                      move(pendingBranch, container, anchor, 0 /* ENTER */);
+                      move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */);
                   }
               }
               setActiveBranch(suspense, pendingBranch);
@@ -3497,7 +3496,7 @@ var Vue = (function () {
               const hydratedEl = instance.vnode.el;
               instance
                   .asyncDep.catch(err => {
-                  handleError(err, instance, 0 /* SETUP_FUNCTION */);
+                  handleError(err, instance, 0 /* ErrorCodes.SETUP_FUNCTION */);
               })
                   .then(asyncSetupResult => {
                   // retry when the setup() promise resolves.
@@ -3571,7 +3570,7 @@ var Vue = (function () {
   }
   function normalizeSuspenseChildren(vnode) {
       const { shapeFlag, children } = vnode;
-      const isSlotChildren = shapeFlag & 32 /* SLOTS_CHILDREN */;
+      const isSlotChildren = shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */;
       vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children);
       vnode.ssFallback = isSlotChildren
           ? normalizeSuspenseSlot(children.fallback)
@@ -3742,7 +3741,7 @@ var Vue = (function () {
                   return traverse(s);
               }
               else if (isFunction(s)) {
-                  return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */);
+                  return callWithErrorHandling(s, instance, 2 /* ErrorCodes.WATCH_GETTER */);
               }
               else {
                   warnInvalidSource(s);
@@ -3752,7 +3751,7 @@ var Vue = (function () {
       else if (isFunction(source)) {
           if (cb) {
               // getter with cb
-              getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */);
+              getter = () => callWithErrorHandling(source, instance, 2 /* ErrorCodes.WATCH_GETTER */);
           }
           else {
               // no cb -> simple effect
@@ -3763,7 +3762,7 @@ var Vue = (function () {
                   if (cleanup) {
                       cleanup();
                   }
-                  return callWithAsyncErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onCleanup]);
+                  return callWithAsyncErrorHandling(source, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [onCleanup]);
               };
           }
       }
@@ -3777,7 +3776,7 @@ var Vue = (function () {
           getter = () => {
               const val = baseGetter();
               if (isArray(val) &&
-                  checkCompatEnabled("WATCH_ARRAY" /* WATCH_ARRAY */, instance)) {
+                  checkCompatEnabled("WATCH_ARRAY" /* DeprecationTypes.WATCH_ARRAY */, instance)) {
                   traverse(val);
               }
               return val;
@@ -3790,7 +3789,7 @@ var Vue = (function () {
       let cleanup;
       let onCleanup = (fn) => {
           cleanup = effect.onStop = () => {
-              callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */);
+              callWithErrorHandling(fn, instance, 4 /* ErrorCodes.WATCH_CLEANUP */);
           };
       };
       let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE;
@@ -3807,12 +3806,12 @@ var Vue = (function () {
                       ? newValue.some((v, i) => hasChanged(v, oldValue[i]))
                       : hasChanged(newValue, oldValue)) ||
                   (isArray(newValue) &&
-                      isCompatEnabled("WATCH_ARRAY" /* WATCH_ARRAY */, instance))) {
+                      isCompatEnabled("WATCH_ARRAY" /* DeprecationTypes.WATCH_ARRAY */, instance))) {
                   // cleanup before running cb again
                   if (cleanup) {
                       cleanup();
                   }
-                  callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [
+                  callWithAsyncErrorHandling(cb, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [
                       newValue,
                       // pass undefined as the old value when it's changed for the first time
                       oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue,
@@ -3838,7 +3837,10 @@ var Vue = (function () {
       }
       else {
           // default: 'pre'
-          scheduler = () => queuePreFlushCb(job);
+          job.pre = true;
+          if (instance)
+              job.id = instance.uid;
+          scheduler = () => queueJob(job);
       }
       const effect = new ReactiveEffect(getter, scheduler);
       {
@@ -3905,7 +3907,7 @@ var Vue = (function () {
       };
   }
   function traverse(value, seen) {
-      if (!isObject(value) || value["__v_skip" /* SKIP */]) {
+      if (!isObject(value) || value["__v_skip" /* ReactiveFlags.SKIP */]) {
           return value;
       }
       seen = seen || new Set();
@@ -4092,7 +4094,7 @@ var Vue = (function () {
       const leavingVNodesCache = getLeavingNodesForType(state, vnode);
       const callHook = (hook, args) => {
           hook &&
-              callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args);
+              callWithAsyncErrorHandling(hook, instance, 9 /* ErrorCodes.TRANSITION_HOOK */, args);
       };
       const callAsyncHook = (hook, args) => {
           const done = args[1];
@@ -4228,10 +4230,10 @@ var Vue = (function () {
           : vnode;
   }
   function setTransitionHooks(vnode, hooks) {
-      if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) {
+      if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */ && vnode.component) {
           setTransitionHooks(vnode.component.subTree, hooks);
       }
-      else if (vnode.shapeFlag & 128 /* SUSPENSE */) {
+      else if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
           vnode.ssContent.transition = hooks.clone(vnode.ssContent);
           vnode.ssFallback.transition = hooks.clone(vnode.ssFallback);
       }
@@ -4250,7 +4252,7 @@ var Vue = (function () {
               : String(parentKey) + String(child.key != null ? child.key : i);
           // handle fragment children case, e.g. v-for
           if (child.type === Fragment) {
-              if (child.patchFlag & 128 /* KEYED_FRAGMENT */)
+              if (child.patchFlag & 128 /* PatchFlags.KEYED_FRAGMENT */)
                   keyedFragmentCount++;
               ret = ret.concat(getTransitionRawChildren(child.children, keepComment, key));
           }
@@ -4265,7 +4267,7 @@ var Vue = (function () {
       // these children to force full diffs to ensure correct behavior.
       if (keyedFragmentCount > 1) {
           for (let i = 0; i < ret.length; i++) {
-              ret[i].patchFlag = -2 /* BAIL */;
+              ret[i].patchFlag = -2 /* PatchFlags.BAIL */;
           }
       }
       return ret;
@@ -4343,7 +4345,7 @@ var Vue = (function () {
               }
               const onError = (err) => {
                   pendingRequest = null;
-                  handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */);
+                  handleError(err, instance, 13 /* ErrorCodes.ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */);
               };
               // suspense-controlled or SSR.
               if ((suspensible && instance.suspense) ||
@@ -4445,7 +4447,7 @@ var Vue = (function () {
           const storageContainer = createElement('div');
           sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => {
               const instance = vnode.component;
-              move(vnode, container, anchor, 0 /* ENTER */, parentSuspense);
+              move(vnode, container, anchor, 0 /* MoveType.ENTER */, parentSuspense);
               // in case props have changed
               patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized);
               queuePostRenderEffect(() => {
@@ -4465,7 +4467,7 @@ var Vue = (function () {
           };
           sharedContext.deactivate = (vnode) => {
               const instance = vnode.component;
-              move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense);
+              move(vnode, storageContainer, null, 1 /* MoveType.LEAVE */, parentSuspense);
               queuePostRenderEffect(() => {
                   if (instance.da) {
                       invokeArrayFns(instance.da);
@@ -4554,8 +4556,8 @@ var Vue = (function () {
                   return children;
               }
               else if (!isVNode(rawVNode) ||
-                  (!(rawVNode.shapeFlag & 4 /* STATEFUL_COMPONENT */) &&
-                      !(rawVNode.shapeFlag & 128 /* SUSPENSE */))) {
+                  (!(rawVNode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) &&
+                      !(rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */))) {
                   current = null;
                   return rawVNode;
               }
@@ -4577,7 +4579,7 @@ var Vue = (function () {
               // clone vnode if it's reused because we are going to mutate it
               if (vnode.el) {
                   vnode = cloneVNode(vnode);
-                  if (rawVNode.shapeFlag & 128 /* SUSPENSE */) {
+                  if (rawVNode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
                       rawVNode.ssContent = vnode;
                   }
               }
@@ -4596,7 +4598,7 @@ var Vue = (function () {
                       setTransitionHooks(vnode, vnode.transition);
                   }
                   // avoid vnode being mounted as fresh
-                  vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */;
+                  vnode.shapeFlag |= 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
                   // make this key the freshest
                   keys.delete(key);
                   keys.add(key);
@@ -4609,7 +4611,7 @@ var Vue = (function () {
                   }
               }
               // avoid vnode being unmounted
-              vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
+              vnode.shapeFlag |= 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
               current = vnode;
               return isSuspense(rawVNode.type) ? rawVNode : vnode;
           };
@@ -4635,10 +4637,10 @@ var Vue = (function () {
       return false;
   }
   function onActivated(hook, target) {
-      registerKeepAliveHook(hook, "a" /* ACTIVATED */, target);
+      registerKeepAliveHook(hook, "a" /* LifecycleHooks.ACTIVATED */, target);
   }
   function onDeactivated(hook, target) {
-      registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target);
+      registerKeepAliveHook(hook, "da" /* LifecycleHooks.DEACTIVATED */, target);
   }
   function registerKeepAliveHook(hook, type, target = currentInstance) {
       // cache the deactivate branch check wrapper for injected hooks so the same
@@ -4682,16 +4684,16 @@ var Vue = (function () {
   }
   function resetShapeFlag(vnode) {
       let shapeFlag = vnode.shapeFlag;
-      if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
-          shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */;
+      if (shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */) {
+          shapeFlag -= 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */;
       }
-      if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {
-          shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */;
+      if (shapeFlag & 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */) {
+          shapeFlag -= 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */;
       }
       vnode.shapeFlag = shapeFlag;
   }
   function getInnerChild(vnode) {
-      return vnode.shapeFlag & 128 /* SUSPENSE */ ? vnode.ssContent : vnode;
+      return vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */ ? vnode.ssContent : vnode;
   }
 
   function injectHook(type, hook, target = currentInstance, prepend = false) {
@@ -4737,23 +4739,23 @@ var Vue = (function () {
   }
   const createHook = (lifecycle) => (hook, target = currentInstance) => 
   // post-create lifecycle registrations are noops during SSR (except for serverPrefetch)
-  (!isInSSRComponentSetup || lifecycle === "sp" /* SERVER_PREFETCH */) &&
+  (!isInSSRComponentSetup || lifecycle === "sp" /* LifecycleHooks.SERVER_PREFETCH */) &&
       injectHook(lifecycle, hook, target);
-  const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */);
-  const onMounted = createHook("m" /* MOUNTED */);
-  const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */);
-  const onUpdated = createHook("u" /* UPDATED */);
-  const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */);
-  const onUnmounted = createHook("um" /* UNMOUNTED */);
-  const onServerPrefetch = createHook("sp" /* SERVER_PREFETCH */);
-  const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */);
-  const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */);
+  const onBeforeMount = createHook("bm" /* LifecycleHooks.BEFORE_MOUNT */);
+  const onMounted = createHook("m" /* LifecycleHooks.MOUNTED */);
+  const onBeforeUpdate = createHook("bu" /* LifecycleHooks.BEFORE_UPDATE */);
+  const onUpdated = createHook("u" /* LifecycleHooks.UPDATED */);
+  const onBeforeUnmount = createHook("bum" /* LifecycleHooks.BEFORE_UNMOUNT */);
+  const onUnmounted = createHook("um" /* LifecycleHooks.UNMOUNTED */);
+  const onServerPrefetch = createHook("sp" /* LifecycleHooks.SERVER_PREFETCH */);
+  const onRenderTriggered = createHook("rtg" /* LifecycleHooks.RENDER_TRIGGERED */);
+  const onRenderTracked = createHook("rtc" /* LifecycleHooks.RENDER_TRACKED */);
   function onErrorCaptured(hook, target = currentInstance) {
-      injectHook("ec" /* ERROR_CAPTURED */, hook, target);
+      injectHook("ec" /* LifecycleHooks.ERROR_CAPTURED */, hook, target);
   }
 
   function getCompatChildren(instance) {
-      assertCompatEnabled("INSTANCE_CHILDREN" /* INSTANCE_CHILDREN */, instance);
+      assertCompatEnabled("INSTANCE_CHILDREN" /* DeprecationTypes.INSTANCE_CHILDREN */, instance);
       const root = instance.subTree;
       const children = [];
       if (root) {
@@ -4765,7 +4767,7 @@ var Vue = (function () {
       if (vnode.component) {
           children.push(vnode.component.proxy);
       }
-      else if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
+      else if (vnode.shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
           const vnodes = vnode.children;
           for (let i = 0; i < vnodes.length; i++) {
               walk(vnodes[i], children);
@@ -4774,7 +4776,7 @@ var Vue = (function () {
   }
 
   function getCompatListeners(instance) {
-      assertCompatEnabled("INSTANCE_LISTENERS" /* INSTANCE_LISTENERS */, instance);
+      assertCompatEnabled("INSTANCE_LISTENERS" /* DeprecationTypes.INSTANCE_LISTENERS */, instance);
       const listeners = {};
       const rawProps = instance.vnode.props;
       if (!rawProps) {
@@ -4802,7 +4804,7 @@ var Vue = (function () {
               mappedName.forEach(mapped => {
                   const mappedHook = dir[mapped];
                   if (mappedHook) {
-                      softAssertCompatEnabled("CUSTOM_DIR" /* CUSTOM_DIR */, instance, mapped, name);
+                      softAssertCompatEnabled("CUSTOM_DIR" /* DeprecationTypes.CUSTOM_DIR */, instance, mapped, name);
                       hook.push(mappedHook);
                   }
               });
@@ -4810,7 +4812,7 @@ var Vue = (function () {
           }
           else {
               if (dir[mappedName]) {
-                  softAssertCompatEnabled("CUSTOM_DIR" /* CUSTOM_DIR */, instance, mappedName, name);
+                  softAssertCompatEnabled("CUSTOM_DIR" /* DeprecationTypes.CUSTOM_DIR */, instance, mappedName, name);
               }
               return dir[mappedName];
           }
@@ -4884,7 +4886,7 @@ var Vue = (function () {
               // disable tracking inside all lifecycle hooks
               // since they can potentially be called inside effects.
               pauseTracking();
-              callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [
+              callWithAsyncErrorHandling(hook, instance, 8 /* ErrorCodes.DIRECTIVE_HOOK */, [
                   vnode.el,
                   binding,
                   vnode,
@@ -4937,7 +4939,7 @@ var Vue = (function () {
           const Component = instance.type;
           // explicit self name has highest priority
           if (type === COMPONENTS) {
-              const selfName = getComponentName(Component);
+              const selfName = getComponentName(Component, false /* do not include inferred name to avoid breaking existing code */);
               if (selfName &&
                   (selfName === name ||
                       selfName === camelize(name) ||
@@ -4991,7 +4993,7 @@ var Vue = (function () {
           return;
       }
       // v2 render function, try to provide compat
-      if (checkCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, instance)) {
+      if (checkCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, instance)) {
           const wrapped = (Component.render = function compatRender() {
               // @ts-ignore
               return render.call(this, compatH);
@@ -5113,7 +5115,7 @@ var Vue = (function () {
   function convertLegacySlots(vnode) {
       const { props, children } = vnode;
       let slots;
-      if (vnode.shapeFlag & 6 /* COMPONENT */ && isArray(children)) {
+      if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */ && isArray(children)) {
           slots = {};
           // check "slot" property on vnodes and turn them into v3 function slots
           for (let i = 0; i < children.length; i++) {
@@ -5152,8 +5154,8 @@ var Vue = (function () {
   }
   function defineLegacyVNodeProperties(vnode) {
       /* istanbul ignore if */
-      if (isCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, currentRenderingInstance, true /* enable for built-ins */) &&
-          isCompatEnabled("PRIVATE_APIS" /* PRIVATE_APIS */, currentRenderingInstance, true /* enable for built-ins */)) {
+      if (isCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, currentRenderingInstance, true /* enable for built-ins */) &&
+          isCompatEnabled("PRIVATE_APIS" /* DeprecationTypes.PRIVATE_APIS */, currentRenderingInstance, true /* enable for built-ins */)) {
           const context = currentRenderingInstance;
           const getInstance = () => vnode.component && vnode.component.proxy;
           let componentOptions;
@@ -5167,7 +5169,7 @@ var Vue = (function () {
               context: { get: () => context && context.proxy },
               componentOptions: {
                   get: () => {
-                      if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
+                      if (vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */) {
                           if (componentOptions) {
                               return componentOptions;
                           }
@@ -5287,7 +5289,13 @@ var Vue = (function () {
           }
           else if (slot) {
               // conditional single slot generated by <template v-if="..." #foo>
-              slots[slot.name] = slot.fn;
+              slots[slot.name] = slot.key
+                  ? (...args) => {
+                      const res = slot.fn(...args);
+                      res.key = slot.key;
+                      return res;
+                  }
+                  : slot.fn;
           }
       }
       return slots;
@@ -5323,9 +5331,15 @@ var Vue = (function () {
       }
       openBlock();
       const validSlotContent = slot && ensureValidVNode(slot(props));
-      const rendered = createBlock(Fragment, { key: props.key || `_${name}` }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* STABLE */
-          ? 64 /* STABLE_FRAGMENT */
-          : -2 /* BAIL */);
+      const rendered = createBlock(Fragment, {
+          key: props.key ||
+              // slot content array of a dynamic conditional slot may have a branch
+              // key attached in the `createSlots` helper, respect that
+              (validSlotContent && validSlotContent.key) ||
+              `_${name}`
+      }, validSlotContent || (fallback ? fallback() : []), validSlotContent && slots._ === 1 /* SlotFlags.STABLE */
+          ? 64 /* PatchFlags.STABLE_FRAGMENT */
+          : -2 /* PatchFlags.BAIL */);
       if (!noSlotted && rendered.scopeId) {
           rendered.slotScopeIds = [rendered.scopeId + '-s'];
       }
@@ -5353,14 +5367,16 @@ var Vue = (function () {
    * For prefixing keys in v-on="obj" with "on"
    * @private
    */
-  function toHandlers(obj) {
+  function toHandlers(obj, preserveCaseIfNecessary) {
       const ret = {};
       if (!isObject(obj)) {
           warn$1(`v-on with no argument expects an object value.`);
           return ret;
       }
       for (const key in obj) {
-          ret[toHandlerKey(key)] = obj[key];
+          ret[preserveCaseIfNecessary && /[A-Z]/.test(key)
+              ? `on:${key}`
+              : toHandlerKey(key)] = obj[key];
       }
       return ret;
   }
@@ -5496,26 +5512,26 @@ var Vue = (function () {
       };
       extend(map, {
           $set: i => {
-              assertCompatEnabled("INSTANCE_SET" /* INSTANCE_SET */, i);
+              assertCompatEnabled("INSTANCE_SET" /* DeprecationTypes.INSTANCE_SET */, i);
               return set;
           },
           $delete: i => {
-              assertCompatEnabled("INSTANCE_DELETE" /* INSTANCE_DELETE */, i);
+              assertCompatEnabled("INSTANCE_DELETE" /* DeprecationTypes.INSTANCE_DELETE */, i);
               return del;
           },
           $mount: i => {
-              assertCompatEnabled("GLOBAL_MOUNT" /* GLOBAL_MOUNT */, null /* this warning is global */);
+              assertCompatEnabled("GLOBAL_MOUNT" /* DeprecationTypes.GLOBAL_MOUNT */, null /* this warning is global */);
               // root mount override from ./global.ts in installCompatMount
               return i.ctx._compat_mount || NOOP;
           },
           $destroy: i => {
-              assertCompatEnabled("INSTANCE_DESTROY" /* INSTANCE_DESTROY */, i);
+              assertCompatEnabled("INSTANCE_DESTROY" /* DeprecationTypes.INSTANCE_DESTROY */, i);
               // root destroy override from ./global.ts in installCompatMount
               return i.ctx._compat_destroy || NOOP;
           },
           // overrides existing accessor
           $slots: i => {
-              if (isCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, i) &&
+              if (isCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, i) &&
                   i.render &&
                   i.render._compatWrapped) {
                   return new Proxy(i.slots, legacySlotProxyHandlers);
@@ -5523,7 +5539,7 @@ var Vue = (function () {
               return shallowReadonly(i.slots) ;
           },
           $scopedSlots: i => {
-              assertCompatEnabled("INSTANCE_SCOPED_SLOTS" /* INSTANCE_SCOPED_SLOTS */, i);
+              assertCompatEnabled("INSTANCE_SCOPED_SLOTS" /* DeprecationTypes.INSTANCE_SCOPED_SLOTS */, i);
               const res = {};
               for (const key in i.slots) {
                   const fn = i.slots[key];
@@ -5540,7 +5556,7 @@ var Vue = (function () {
           $listeners: getCompatListeners
       });
       /* istanbul ignore if */
-      if (isCompatEnabled("PRIVATE_APIS" /* PRIVATE_APIS */, null)) {
+      if (isCompatEnabled("PRIVATE_APIS" /* DeprecationTypes.PRIVATE_APIS */, null)) {
           extend(map, {
               // needed by many libs / render fns
               $vnode: i => i.vnode,
@@ -5644,23 +5660,23 @@ var Vue = (function () {
               const n = accessCache[key];
               if (n !== undefined) {
                   switch (n) {
-                      case 1 /* SETUP */:
+                      case 1 /* AccessTypes.SETUP */:
                           return setupState[key];
-                      case 2 /* DATA */:
+                      case 2 /* AccessTypes.DATA */:
                           return data[key];
-                      case 4 /* CONTEXT */:
+                      case 4 /* AccessTypes.CONTEXT */:
                           return ctx[key];
-                      case 3 /* PROPS */:
+                      case 3 /* AccessTypes.PROPS */:
                           return props[key];
                       // default: just fallthrough
                   }
               }
               else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) {
-                  accessCache[key] = 1 /* SETUP */;
+                  accessCache[key] = 1 /* AccessTypes.SETUP */;
                   return setupState[key];
               }
               else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
-                  accessCache[key] = 2 /* DATA */;
+                  accessCache[key] = 2 /* AccessTypes.DATA */;
                   return data[key];
               }
               else if (
@@ -5668,15 +5684,15 @@ var Vue = (function () {
               // props
               (normalizedProps = instance.propsOptions[0]) &&
                   hasOwn(normalizedProps, key)) {
-                  accessCache[key] = 3 /* PROPS */;
+                  accessCache[key] = 3 /* AccessTypes.PROPS */;
                   return props[key];
               }
               else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
-                  accessCache[key] = 4 /* CONTEXT */;
+                  accessCache[key] = 4 /* AccessTypes.CONTEXT */;
                   return ctx[key];
               }
               else if (shouldCacheAccess) {
-                  accessCache[key] = 0 /* OTHER */;
+                  accessCache[key] = 0 /* AccessTypes.OTHER */;
               }
           }
           const publicGetter = publicPropertiesMap[key];
@@ -5684,7 +5700,7 @@ var Vue = (function () {
           // public $xxx properties
           if (publicGetter) {
               if (key === '$attrs') {
-                  track(instance, "get" /* GET */, key);
+                  track(instance, "get" /* TrackOpTypes.GET */, key);
                   markAttrsAccessed();
               }
               return publicGetter(instance);
@@ -5697,7 +5713,7 @@ var Vue = (function () {
           }
           else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
               // user may set custom properties to `this` that start with `$`
-              accessCache[key] = 4 /* CONTEXT */;
+              accessCache[key] = 4 /* AccessTypes.CONTEXT */;
               return ctx[key];
           }
           else if (
@@ -5873,7 +5889,7 @@ var Vue = (function () {
           const toVal = to[key];
           const fromVal = from[key];
           if (key in to && isPlainObject(toVal) && isPlainObject(fromVal)) {
-              warnDeprecation("OPTIONS_DATA_MERGE" /* OPTIONS_DATA_MERGE */, null, key);
+              warnDeprecation("OPTIONS_DATA_MERGE" /* DeprecationTypes.OPTIONS_DATA_MERGE */, null, key);
               deepMergeData(toVal, fromVal);
           }
           else {
@@ -5904,7 +5920,7 @@ var Vue = (function () {
       // call beforeCreate first before accessing other options since
       // the hook may mutate resolved options (#2791)
       if (options.beforeCreate) {
-          callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */);
+          callHook(options.beforeCreate, instance, "bc" /* LifecycleHooks.BEFORE_CREATE */);
       }
       const { 
       // state
@@ -5920,7 +5936,7 @@ var Vue = (function () {
           const [propsOptions] = instance.propsOptions;
           if (propsOptions) {
               for (const key in propsOptions) {
-                  checkDuplicateProperties("Props" /* PROPS */, key);
+                  checkDuplicateProperties("Props" /* OptionTypes.PROPS */, key);
               }
           }
       }
@@ -5950,7 +5966,7 @@ var Vue = (function () {
                       });
                   }
                   {
-                      checkDuplicateProperties("Methods" /* METHODS */, key);
+                      checkDuplicateProperties("Methods" /* OptionTypes.METHODS */, key);
                   }
               }
               else {
@@ -5977,7 +5993,7 @@ var Vue = (function () {
               instance.data = reactive(data);
               {
                   for (const key in data) {
-                      checkDuplicateProperties("Data" /* DATA */, key);
+                      checkDuplicateProperties("Data" /* OptionTypes.DATA */, key);
                       // expose data on ctx during dev
                       if (!isReservedPrefix(key[0])) {
                           Object.defineProperty(ctx, key, {
@@ -6021,7 +6037,7 @@ var Vue = (function () {
                   set: v => (c.value = v)
               });
               {
-                  checkDuplicateProperties("Computed" /* COMPUTED */, key);
+                  checkDuplicateProperties("Computed" /* OptionTypes.COMPUTED */, key);
               }
           }
       }
@@ -6039,7 +6055,7 @@ var Vue = (function () {
           });
       }
       if (created) {
-          callHook(created, instance, "c" /* CREATED */);
+          callHook(created, instance, "c" /* LifecycleHooks.CREATED */);
       }
       function registerLifecycleHook(register, hook) {
           if (isArray(hook)) {
@@ -6063,11 +6079,11 @@ var Vue = (function () {
       registerLifecycleHook(onServerPrefetch, serverPrefetch);
       {
           if (beforeDestroy &&
-              softAssertCompatEnabled("OPTIONS_BEFORE_DESTROY" /* OPTIONS_BEFORE_DESTROY */, instance)) {
+              softAssertCompatEnabled("OPTIONS_BEFORE_DESTROY" /* DeprecationTypes.OPTIONS_BEFORE_DESTROY */, instance)) {
               registerLifecycleHook(onBeforeUnmount, beforeDestroy);
           }
           if (destroyed &&
-              softAssertCompatEnabled("OPTIONS_DESTROYED" /* OPTIONS_DESTROYED */, instance)) {
+              softAssertCompatEnabled("OPTIONS_DESTROYED" /* DeprecationTypes.OPTIONS_DESTROYED */, instance)) {
               registerLifecycleHook(onUnmounted, destroyed);
           }
       }
@@ -6099,7 +6115,7 @@ var Vue = (function () {
       if (directives)
           instance.directives = directives;
       if (filters &&
-          isCompatEnabled("FILTERS" /* FILTERS */, instance)) {
+          isCompatEnabled("FILTERS" /* DeprecationTypes.FILTERS */, instance)) {
           instance.filters = filters;
       }
   }
@@ -6146,7 +6162,7 @@ var Vue = (function () {
               ctx[key] = injected;
           }
           {
-              checkDuplicateProperties("Inject" /* INJECT */, key);
+              checkDuplicateProperties("Inject" /* OptionTypes.INJECT */, key);
           }
       }
   }
@@ -6206,7 +6222,7 @@ var Vue = (function () {
           resolved = cached;
       }
       else if (!globalMixins.length && !mixins && !extendsOptions) {
-          if (isCompatEnabled("PRIVATE_APIS" /* PRIVATE_APIS */, instance)) {
+          if (isCompatEnabled("PRIVATE_APIS" /* DeprecationTypes.PRIVATE_APIS */, instance)) {
               resolved = extend({}, base);
               resolved.parent = instance.parent && instance.parent.proxy;
               resolved.propsData = instance.vnode.props;
@@ -6222,7 +6238,9 @@ var Vue = (function () {
           }
           mergeOptions(resolved, base, optionMergeStrategies);
       }
-      cache.set(base, resolved);
+      if (isObject(base)) {
+          cache.set(base, resolved);
+      }
       return resolved;
   }
   function mergeOptions(to, from, strats, asMixin = false) {
@@ -6290,7 +6308,7 @@ var Vue = (function () {
           return from;
       }
       return function mergedDataFn() {
-          return (isCompatEnabled("OPTIONS_DATA_MERGE" /* OPTIONS_DATA_MERGE */, null)
+          return (isCompatEnabled("OPTIONS_DATA_MERGE" /* DeprecationTypes.OPTIONS_DATA_MERGE */, null)
               ? deepMergeData
               : extend)(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from);
       };
@@ -6329,7 +6347,7 @@ var Vue = (function () {
   function createPropsDefaultThis(instance, rawProps, propKey) {
       return new Proxy({}, {
           get(_, key) {
-              warnDeprecation("PROPS_DEFAULT_THIS" /* PROPS_DEFAULT_THIS */, null, propKey);
+              warnDeprecation("PROPS_DEFAULT_THIS" /* DeprecationTypes.PROPS_DEFAULT_THIS */, null, propKey);
               // $options
               if (key === '$options') {
                   return resolveMergedOptions(instance);
@@ -6359,11 +6377,11 @@ var Vue = (function () {
           return true;
       }
       if ((key === 'class' || key === 'style') &&
-          isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance)) {
+          isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* DeprecationTypes.INSTANCE_ATTRS_CLASS_STYLE */, instance)) {
           return true;
       }
       if (isOn(key) &&
-          isCompatEnabled("INSTANCE_LISTENERS" /* INSTANCE_LISTENERS */, instance)) {
+          isCompatEnabled("INSTANCE_LISTENERS" /* DeprecationTypes.INSTANCE_LISTENERS */, instance)) {
           return true;
       }
       // vue-router
@@ -6406,6 +6424,13 @@ var Vue = (function () {
       }
       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);
@@ -6415,11 +6440,10 @@ var Vue = (function () {
       // always force full diff in dev
       // - #1942 if hmr is enabled with sfc component
       // - vite#872 non-sfc component used by sfc component
-      !((instance.type.__hmrId ||
-              (instance.parent && instance.parent.type.__hmrId))) &&
+      !(isInHmrContext(instance)) &&
           (optimized || patchFlag > 0) &&
-          !(patchFlag & 16 /* FULL_PROPS */)) {
-          if (patchFlag & 8 /* PROPS */) {
+          !(patchFlag & 16 /* PatchFlags.FULL_PROPS */)) {
+          if (patchFlag & 8 /* PatchFlags.PROPS */) {
               // Compiler-generated props & no keys change, just set the updated
               // the props.
               const propsToUpdate = instance.vnode.dynamicProps;
@@ -6506,7 +6530,7 @@ var Vue = (function () {
       }
       // trigger updates for $attrs in case it's used in component slots
       if (hasAttrsChanged) {
-          trigger(instance, "set" /* SET */, '$attrs');
+          trigger(instance, "set" /* TriggerOpTypes.SET */, '$attrs');
       }
       {
           validateProps(rawProps || {}, props, instance);
@@ -6524,7 +6548,7 @@ var Vue = (function () {
               }
               {
                   if (key.startsWith('onHook:')) {
-                      softAssertCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance, key.slice(2).toLowerCase());
+                      softAssertCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance, key.slice(2).toLowerCase());
                   }
                   if (key === 'inline-template') {
                       continue;
@@ -6585,7 +6609,7 @@ var Vue = (function () {
                   }
                   else {
                       setCurrentInstance(instance);
-                      value = propsDefaults[key] = defaultValue.call(isCompatEnabled("PROPS_DEFAULT_THIS" /* PROPS_DEFAULT_THIS */, instance)
+                      value = propsDefaults[key] = defaultValue.call(isCompatEnabled("PROPS_DEFAULT_THIS" /* DeprecationTypes.PROPS_DEFAULT_THIS */, instance)
                           ? createPropsDefaultThis(instance, props, key)
                           : null, props);
                       unsetCurrentInstance();
@@ -6596,11 +6620,11 @@ var Vue = (function () {
               }
           }
           // boolean casting
-          if (opt[0 /* shouldCast */]) {
+          if (opt[0 /* BooleanFlags.shouldCast */]) {
               if (isAbsent && !hasDefault) {
                   value = false;
               }
-              else if (opt[1 /* shouldCastTrue */] &&
+              else if (opt[1 /* BooleanFlags.shouldCastTrue */] &&
                   (value === '' || value === hyphenate(key))) {
                   value = true;
               }
@@ -6641,7 +6665,9 @@ var Vue = (function () {
           }
       }
       if (!raw && !hasExtends) {
-          cache.set(comp, EMPTY_ARR);
+          if (isObject(comp)) {
+              cache.set(comp, EMPTY_ARR);
+          }
           return EMPTY_ARR;
       }
       if (isArray(raw)) {
@@ -6668,8 +6694,8 @@ var Vue = (function () {
                   if (prop) {
                       const booleanIndex = getTypeIndex(Boolean, prop.type);
                       const stringIndex = getTypeIndex(String, prop.type);
-                      prop[0 /* shouldCast */] = booleanIndex > -1;
-                      prop[1 /* shouldCastTrue */] =
+                      prop[0 /* BooleanFlags.shouldCast */] = booleanIndex > -1;
+                      prop[1 /* BooleanFlags.shouldCastTrue */] =
                           stringIndex < 0 || booleanIndex < stringIndex;
                       // if the prop needs boolean casting or default value
                       if (booleanIndex > -1 || hasOwn(prop, 'default')) {
@@ -6680,7 +6706,9 @@ var Vue = (function () {
           }
       }
       const res = [normalized, needCastKeys];
-      cache.set(comp, res);
+      if (isObject(comp)) {
+          cache.set(comp, res);
+      }
       return res;
   }
   function validatePropName(key) {
@@ -6871,7 +6899,7 @@ var Vue = (function () {
               slots[key] = normalizeSlot(key, value, ctx);
           }
           else if (value != null) {
-              if (!(isCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, instance))) {
+              if (!(isCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, instance))) {
                   warn$1(`Non-function value encountered for slot "${key}". ` +
                       `Prefer function slots for better performance.`);
               }
@@ -6882,7 +6910,7 @@ var Vue = (function () {
   };
   const normalizeVNodeSlots = (instance, children) => {
       if (!isKeepAlive(instance.vnode) &&
-          !(isCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, instance))) {
+          !(isCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, instance))) {
           warn$1(`Non-function value encountered for default slot. ` +
               `Prefer function slots for better performance.`);
       }
@@ -6890,7 +6918,7 @@ var Vue = (function () {
       instance.slots.default = () => normalized;
   };
   const initSlots = (instance, children) => {
-      if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
+      if (instance.vnode.shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */) {
           const type = children._;
           if (type) {
               // users can get the shallow readonly version of the slots object through `this.$slots`,
@@ -6915,7 +6943,7 @@ var Vue = (function () {
       const { vnode, slots } = instance;
       let needDeletionCheck = true;
       let deletionComparisonTarget = EMPTY_OBJ;
-      if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) {
+      if (vnode.shapeFlag & 32 /* ShapeFlags.SLOTS_CHILDREN */) {
           const type = children._;
           if (type) {
               // compiled slots.
@@ -6924,7 +6952,7 @@ var Vue = (function () {
                   // force update slots and mark instance for hmr as well
                   extend(slots, children);
               }
-              else if (optimized && type === 1 /* STABLE */) {
+              else if (optimized && type === 1 /* SlotFlags.STABLE */) {
                   // compiled AND stable.
                   // no need to update, and skip stale slots removal.
                   needDeletionCheck = false;
@@ -6937,7 +6965,7 @@ var Vue = (function () {
                   // when rendering the optimized slots by manually written render function,
                   // we need to delete the `slots._` flag if necessary to make subsequent updates reliable,
                   // i.e. let the `renderSlot` create the bailed Fragment
-                  if (!optimized && type === 1 /* STABLE */) {
+                  if (!optimized && type === 1 /* SlotFlags.STABLE */) {
                       delete slots._;
                   }
               }
@@ -6966,11 +6994,11 @@ var Vue = (function () {
   // dev only
   function installLegacyConfigWarnings(config) {
       const legacyConfigOptions = {
-          silent: "CONFIG_SILENT" /* CONFIG_SILENT */,
-          devtools: "CONFIG_DEVTOOLS" /* CONFIG_DEVTOOLS */,
-          ignoredElements: "CONFIG_IGNORED_ELEMENTS" /* CONFIG_IGNORED_ELEMENTS */,
-          keyCodes: "CONFIG_KEY_CODES" /* CONFIG_KEY_CODES */,
-          productionTip: "CONFIG_PRODUCTION_TIP" /* CONFIG_PRODUCTION_TIP */
+          silent: "CONFIG_SILENT" /* DeprecationTypes.CONFIG_SILENT */,
+          devtools: "CONFIG_DEVTOOLS" /* DeprecationTypes.CONFIG_DEVTOOLS */,
+          ignoredElements: "CONFIG_IGNORED_ELEMENTS" /* DeprecationTypes.CONFIG_IGNORED_ELEMENTS */,
+          keyCodes: "CONFIG_KEY_CODES" /* DeprecationTypes.CONFIG_KEY_CODES */,
+          productionTip: "CONFIG_PRODUCTION_TIP" /* DeprecationTypes.CONFIG_PRODUCTION_TIP */
       };
       Object.keys(legacyConfigOptions).forEach(key => {
           let val = config[key];
@@ -6995,7 +7023,7 @@ var Vue = (function () {
                   return target[key];
               }
               if (key in internalOptionMergeStrats &&
-                  softAssertCompatEnabled("CONFIG_OPTION_MERGE_STRATS" /* CONFIG_OPTION_MERGE_STRATS */, null)) {
+                  softAssertCompatEnabled("CONFIG_OPTION_MERGE_STRATS" /* DeprecationTypes.CONFIG_OPTION_MERGE_STRATS */, null)) {
                   return internalOptionMergeStrats[key];
               }
           }
@@ -7013,11 +7041,11 @@ var Vue = (function () {
           return createCompatApp(options, Vue);
       });
       function createCompatApp(options = {}, Ctor) {
-          assertCompatEnabled("GLOBAL_MOUNT" /* GLOBAL_MOUNT */, null);
+          assertCompatEnabled("GLOBAL_MOUNT" /* DeprecationTypes.GLOBAL_MOUNT */, null);
           const { data } = options;
           if (data &&
               !isFunction(data) &&
-              softAssertCompatEnabled("OPTIONS_DATA_FN" /* OPTIONS_DATA_FN */, null)) {
+              softAssertCompatEnabled("OPTIONS_DATA_FN" /* DeprecationTypes.OPTIONS_DATA_FN */, null)) {
               options.data = () => data;
           }
           const app = createApp(options);
@@ -7032,7 +7060,7 @@ var Vue = (function () {
               return vm;
           }
       }
-      Vue.version = `2.6.14-compat:${"3.2.36"}`;
+      Vue.version = `2.6.14-compat:${"3.2.39"}`;
       Vue.config = singletonApp.config;
       Vue.use = (p, ...options) => {
           if (p && isFunction(p.install)) {
@@ -7071,7 +7099,7 @@ var Vue = (function () {
       Vue.nextTick = nextTick;
       const extendCache = new WeakMap();
       function extendCtor(extendOptions = {}) {
-          assertCompatEnabled("GLOBAL_EXTEND" /* GLOBAL_EXTEND */, null);
+          assertCompatEnabled("GLOBAL_EXTEND" /* DeprecationTypes.GLOBAL_EXTEND */, null);
           if (isFunction(extendOptions)) {
               extendOptions = extendOptions.options;
           }
@@ -7112,15 +7140,15 @@ var Vue = (function () {
       }
       Vue.extend = extendCtor.bind(Vue);
       Vue.set = (target, key, value) => {
-          assertCompatEnabled("GLOBAL_SET" /* GLOBAL_SET */, null);
+          assertCompatEnabled("GLOBAL_SET" /* DeprecationTypes.GLOBAL_SET */, null);
           target[key] = value;
       };
       Vue.delete = (target, key) => {
-          assertCompatEnabled("GLOBAL_DELETE" /* GLOBAL_DELETE */, null);
+          assertCompatEnabled("GLOBAL_DELETE" /* DeprecationTypes.GLOBAL_DELETE */, null);
           delete target[key];
       };
       Vue.observable = (target) => {
-          assertCompatEnabled("GLOBAL_OBSERVABLE" /* GLOBAL_OBSERVABLE */, null);
+          assertCompatEnabled("GLOBAL_OBSERVABLE" /* DeprecationTypes.GLOBAL_OBSERVABLE */, null);
           return reactive(target);
       };
       Vue.filter = ((name, filter) => {
@@ -7141,7 +7169,7 @@ var Vue = (function () {
       };
       Object.defineProperty(Vue, 'util', {
           get() {
-              assertCompatEnabled("GLOBAL_PRIVATE_UTIL" /* GLOBAL_PRIVATE_UTIL */, null);
+              assertCompatEnabled("GLOBAL_PRIVATE_UTIL" /* DeprecationTypes.GLOBAL_PRIVATE_UTIL */, null);
               return util;
           }
       });
@@ -7164,7 +7192,7 @@ var Vue = (function () {
   function installFilterMethod(app, context) {
       context.filters = {};
       app.filter = (name, filter) => {
-          assertCompatEnabled("FILTERS" /* FILTERS */, null);
+          assertCompatEnabled("FILTERS" /* DeprecationTypes.FILTERS */, null);
           if (!filter) {
               return context.filters[name];
           }
@@ -7181,7 +7209,7 @@ var Vue = (function () {
           // so that app.use() can work with legacy plugins that extend prototypes
           prototype: {
               get() {
-                  warnDeprecation("GLOBAL_PROTOTYPE" /* GLOBAL_PROTOTYPE */, null);
+                  warnDeprecation("GLOBAL_PROTOTYPE" /* DeprecationTypes.GLOBAL_PROTOTYPE */, null);
                   return app.config.globalProperties;
               }
           },
@@ -7218,7 +7246,7 @@ var Vue = (function () {
           app.config[key] = isObject(val) ? Object.create(val) : val;
           // compat for runtime ignoredElements -> isCustomElement
           if (key === 'ignoredElements' &&
-              isCompatEnabled("CONFIG_IGNORED_ELEMENTS" /* CONFIG_IGNORED_ELEMENTS */, null) &&
+              isCompatEnabled("CONFIG_IGNORED_ELEMENTS" /* DeprecationTypes.CONFIG_IGNORED_ELEMENTS */, null) &&
               !isRuntimeOnly() &&
               isArray(val)) {
               app.config.compilerOptions.isCustomElement = tag => {
@@ -7231,7 +7259,7 @@ var Vue = (function () {
   }
   function applySingletonPrototype(app, Ctor) {
       // copy prototype augmentations as config.globalProperties
-      const enabled = isCompatEnabled("GLOBAL_PROTOTYPE" /* GLOBAL_PROTOTYPE */, null);
+      const enabled = isCompatEnabled("GLOBAL_PROTOTYPE" /* DeprecationTypes.GLOBAL_PROTOTYPE */, null);
       if (enabled) {
           app.config.globalProperties = Object.create(Ctor.prototype);
       }
@@ -7246,7 +7274,7 @@ var Vue = (function () {
           }
       }
       if (hasPrototypeAugmentations) {
-          warnDeprecation("GLOBAL_PROTOTYPE" /* GLOBAL_PROTOTYPE */, null);
+          warnDeprecation("GLOBAL_PROTOTYPE" /* DeprecationTypes.GLOBAL_PROTOTYPE */, null);
       }
   }
   function installCompatMount(app, context, render) {
@@ -7316,7 +7344,7 @@ var Vue = (function () {
                       for (let i = 0; i < container.attributes.length; i++) {
                           const attr = container.attributes[i];
                           if (attr.name !== 'v-cloak' && /^(v-|:|@)/.test(attr.name)) {
-                              warnDeprecation("GLOBAL_MOUNT_CONTAINER" /* GLOBAL_MOUNT_CONTAINER */, null);
+                              warnDeprecation("GLOBAL_MOUNT_CONTAINER" /* DeprecationTypes.GLOBAL_MOUNT_CONTAINER */, null);
                               break;
                           }
                       }
@@ -7355,7 +7383,7 @@ var Vue = (function () {
                   if (bum) {
                       invokeArrayFns(bum);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       instance.emit('hook:beforeDestroy');
                   }
                   // stop effects
@@ -7366,7 +7394,7 @@ var Vue = (function () {
                   if (um) {
                       invokeArrayFns(um);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       instance.emit('hook:destroyed');
                   }
               }
@@ -7427,12 +7455,12 @@ var Vue = (function () {
           enumerable: true,
           configurable: true,
           get() {
-              track(obj, "get" /* GET */, key);
+              track(obj, "get" /* TrackOpTypes.GET */, key);
               return val;
           },
           set(newVal) {
               val = isObject(newVal) ? reactive(newVal) : newVal;
-              trigger(obj, "set" /* SET */, key, newVal);
+              trigger(obj, "set" /* TriggerOpTypes.SET */, key, newVal);
           }
       });
   }
@@ -7625,7 +7653,7 @@ var Vue = (function () {
           // because the template ref is forwarded to inner component
           return;
       }
-      const refValue = vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */
+      const refValue = vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */
           ? getExposeProxy(vnode.component) || vnode.component.proxy
           : vnode.el;
       const value = isUnmount ? null : refValue;
@@ -7651,7 +7679,7 @@ var Vue = (function () {
           }
       }
       if (isFunction(ref)) {
-          callWithErrorHandling(ref, owner, 12 /* FUNCTION_REF */, [value, refs]);
+          callWithErrorHandling(ref, owner, 12 /* ErrorCodes.FUNCTION_REF */, [value, refs]);
       }
       else {
           const _isString = isString(ref);
@@ -7688,7 +7716,7 @@ var Vue = (function () {
                           setupState[ref] = value;
                       }
                   }
-                  else if (isRef(ref)) {
+                  else if (_isRef) {
                       ref.value = value;
                       if (rawRef.k)
                           refs[rawRef.k] = value;
@@ -7713,7 +7741,7 @@ var Vue = (function () {
 
   let hasMismatch = false;
   const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject';
-  const isComment = (node) => node.nodeType === 8 /* COMMENT */;
+  const isComment = (node) => node.nodeType === 8 /* DOMNodeTypes.COMMENT */;
   // Note: hydration is DOM-specific
   // But we have to place it in core due to tight coupling with core - splitting
   // it out creates a ton of unnecessary complexity.
@@ -7727,11 +7755,13 @@ var Vue = (function () {
                       `Performing full mount instead.`);
               patch(null, vnode, container);
               flushPostFlushCbs();
+              container._vnode = vnode;
               return;
           }
           hasMismatch = false;
           hydrateNode(container.firstChild, vnode, null, null, null);
           flushPostFlushCbs();
+          container._vnode = vnode;
           if (hasMismatch && !false) {
               // this error should show up in production
               console.error(`Hydration completed but contains mismatches.`);
@@ -7743,14 +7773,14 @@ var Vue = (function () {
           const { type, ref, shapeFlag, patchFlag } = vnode;
           const domType = node.nodeType;
           vnode.el = node;
-          if (patchFlag === -2 /* BAIL */) {
+          if (patchFlag === -2 /* PatchFlags.BAIL */) {
               optimized = false;
               vnode.dynamicChildren = null;
           }
           let nextNode = null;
           switch (type) {
               case Text:
-                  if (domType !== 3 /* TEXT */) {
+                  if (domType !== 3 /* DOMNodeTypes.TEXT */) {
                       // #5728 empty text node inside a slot can cause hydration failure
                       // because the server rendered HTML won't contain a text node
                       if (vnode.children === '') {
@@ -7773,7 +7803,7 @@ var Vue = (function () {
                   }
                   break;
               case Comment:
-                  if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+                  if (domType !== 8 /* DOMNodeTypes.COMMENT */ || isFragmentStart) {
                       nextNode = onMismatch();
                   }
                   else {
@@ -7781,7 +7811,7 @@ var Vue = (function () {
                   }
                   break;
               case Static:
-                  if (domType !== 1 /* ELEMENT */) {
+                  if (domType !== 1 /* DOMNodeTypes.ELEMENT */ && domType !== 3 /* DOMNodeTypes.TEXT */) {
                       nextNode = onMismatch();
                   }
                   else {
@@ -7792,7 +7822,10 @@ var Vue = (function () {
                       const needToAdoptContent = !vnode.children.length;
                       for (let i = 0; i < vnode.staticCount; i++) {
                           if (needToAdoptContent)
-                              vnode.children += nextNode.outerHTML;
+                              vnode.children +=
+                                  nextNode.nodeType === 1 /* DOMNodeTypes.ELEMENT */
+                                      ? nextNode.outerHTML
+                                      : nextNode.data;
                           if (i === vnode.staticCount - 1) {
                               vnode.anchor = nextNode;
                           }
@@ -7810,8 +7843,8 @@ var Vue = (function () {
                   }
                   break;
               default:
-                  if (shapeFlag & 1 /* ELEMENT */) {
-                      if (domType !== 1 /* ELEMENT */ ||
+                  if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) {
+                      if (domType !== 1 /* DOMNodeTypes.ELEMENT */ ||
                           vnode.type.toLowerCase() !==
                               node.tagName.toLowerCase()) {
                           nextNode = onMismatch();
@@ -7820,7 +7853,7 @@ var Vue = (function () {
                           nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized);
                       }
                   }
-                  else if (shapeFlag & 6 /* COMPONENT */) {
+                  else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
                       // when setting up the render effect, if the initial vnode already
                       // has .el set, the component will perform hydration instead of mount
                       // on its sub-tree.
@@ -7859,15 +7892,15 @@ var Vue = (function () {
                           vnode.component.subTree = subTree;
                       }
                   }
-                  else if (shapeFlag & 64 /* TELEPORT */) {
-                      if (domType !== 8 /* COMMENT */) {
+                  else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
+                      if (domType !== 8 /* DOMNodeTypes.COMMENT */) {
                           nextNode = onMismatch();
                       }
                       else {
                           nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren);
                       }
                   }
-                  else if (shapeFlag & 128 /* SUSPENSE */) {
+                  else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
                       nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode);
                   }
                   else {
@@ -7895,7 +7928,7 @@ var Vue = (function () {
               if (props) {
                   if (forcePatchValue ||
                       !optimized ||
-                      patchFlag & (16 /* FULL_PROPS */ | 32 /* HYDRATE_EVENTS */)) {
+                      patchFlag & (16 /* PatchFlags.FULL_PROPS */ | 32 /* PatchFlags.HYDRATE_EVENTS */)) {
                       for (const key in props) {
                           if ((forcePatchValue && key.endsWith('value')) ||
                               (isOn(key) && !isReservedProp(key))) {
@@ -7924,7 +7957,7 @@ var Vue = (function () {
                   }, parentSuspense);
               }
               // children
-              if (shapeFlag & 16 /* ARRAY_CHILDREN */ &&
+              if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */ &&
                   // skip if element has innerHTML / textContent
                   !(props && (props.innerHTML || props.textContent))) {
                   let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized);
@@ -7942,7 +7975,7 @@ var Vue = (function () {
                       remove(cur);
                   }
               }
-              else if (shapeFlag & 8 /* TEXT_CHILDREN */) {
+              else if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
                   if (el.textContent !== vnode.children) {
                       hasMismatch = true;
                       warn$1(`Hydration text content mismatch in <${vnode.type}>:\n` +
@@ -8005,7 +8038,7 @@ var Vue = (function () {
       };
       const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => {
           hasMismatch = true;
-          warn$1(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */
+          warn$1(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* DOMNodeTypes.TEXT */
                   ? `(text)`
                   : isComment(node) && node.data === '['
                       ? `(start of fragment)`
@@ -8136,7 +8169,7 @@ var Vue = (function () {
               unmount(n1, parentComponent, parentSuspense, true);
               n1 = null;
           }
-          if (n2.patchFlag === -2 /* BAIL */) {
+          if (n2.patchFlag === -2 /* PatchFlags.BAIL */) {
               optimized = false;
               n2.dynamicChildren = null;
           }
@@ -8160,16 +8193,16 @@ var Vue = (function () {
                   processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   break;
               default:
-                  if (shapeFlag & 1 /* ELEMENT */) {
+                  if (shapeFlag & 1 /* ShapeFlags.ELEMENT */) {
                       processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   }
-                  else if (shapeFlag & 6 /* COMPONENT */) {
+                  else if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
                       processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   }
-                  else if (shapeFlag & 64 /* TELEPORT */) {
+                  else if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
                       type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);
                   }
-                  else if (shapeFlag & 128 /* SUSPENSE */) {
+                  else if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
                       type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals);
                   }
                   else {
@@ -8255,10 +8288,10 @@ var Vue = (function () {
               el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is, props);
               // mount children first, since some props may rely on child content
               // being already rendered, e.g. `<select value>`
-              if (shapeFlag & 8 /* TEXT_CHILDREN */) {
+              if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
                   hostSetElementText(el, vnode.children);
               }
-              else if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+              else if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                   mountChildren(vnode.children, el, null, parentComponent, parentSuspense, isSVG && type !== 'foreignObject', slotScopeIds, optimized);
               }
               if (dirs) {
@@ -8334,7 +8367,7 @@ var Vue = (function () {
           if (parentComponent) {
               let subTree = parentComponent.subTree;
               if (subTree.patchFlag > 0 &&
-                  subTree.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {
+                  subTree.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */) {
                   subTree =
                       filterSingleRoot(subTree.children) || subTree;
               }
@@ -8357,7 +8390,7 @@ var Vue = (function () {
           let { patchFlag, dynamicChildren, dirs } = n2;
           // #1426 take the old vnode's patch flag into account since user may clone a
           // compiler-generated vnode, which de-opts to FULL_PROPS
-          patchFlag |= n1.patchFlag & 16 /* FULL_PROPS */;
+          patchFlag |= n1.patchFlag & 16 /* PatchFlags.FULL_PROPS */;
           const oldProps = n1.props || EMPTY_OBJ;
           const newProps = n2.props || EMPTY_OBJ;
           let vnodeHook;
@@ -8392,21 +8425,21 @@ var Vue = (function () {
               // generated by the compiler and can take the fast path.
               // in this path old node and new node are guaranteed to have the same shape
               // (i.e. at the exact same position in the source template)
-              if (patchFlag & 16 /* FULL_PROPS */) {
+              if (patchFlag & 16 /* PatchFlags.FULL_PROPS */) {
                   // element props contain dynamic keys, full diff needed
                   patchProps(el, n2, oldProps, newProps, parentComponent, parentSuspense, isSVG);
               }
               else {
                   // class
                   // this flag is matched when the element has dynamic class bindings.
-                  if (patchFlag & 2 /* CLASS */) {
+                  if (patchFlag & 2 /* PatchFlags.CLASS */) {
                       if (oldProps.class !== newProps.class) {
                           hostPatchProp(el, 'class', null, newProps.class, isSVG);
                       }
                   }
                   // style
                   // this flag is matched when the element has dynamic style bindings
-                  if (patchFlag & 4 /* STYLE */) {
+                  if (patchFlag & 4 /* PatchFlags.STYLE */) {
                       hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG);
                   }
                   // props
@@ -8415,7 +8448,7 @@ var Vue = (function () {
                   // faster iteration.
                   // Note dynamic keys like :[foo]="bar" will cause this optimization to
                   // bail out and go through a full diff because we need to unset the old key
-                  if (patchFlag & 8 /* PROPS */) {
+                  if (patchFlag & 8 /* PatchFlags.PROPS */) {
                       // if the flag is present then dynamicProps must be non-null
                       const propsToUpdate = n2.dynamicProps;
                       for (let i = 0; i < propsToUpdate.length; i++) {
@@ -8431,7 +8464,7 @@ var Vue = (function () {
               }
               // text
               // This flag is matched when the element has only dynamic text children.
-              if (patchFlag & 1 /* TEXT */) {
+              if (patchFlag & 1 /* PatchFlags.TEXT */) {
                   if (n1.children !== n2.children) {
                       hostSetElementText(el, n2.children);
                   }
@@ -8465,7 +8498,7 @@ var Vue = (function () {
                       // which also requires the correct parent container
                       !isSameVNodeType(oldVNode, newVNode) ||
                       // - In the case of a component, it could contain anything.
-                      oldVNode.shapeFlag & (6 /* COMPONENT */ | 64 /* TELEPORT */))
+                      oldVNode.shapeFlag & (6 /* ShapeFlags.COMPONENT */ | 64 /* ShapeFlags.TELEPORT */))
                   ? hostParentNode(oldVNode.el)
                   : // In other cases, the parent container is not actually used so we
                       // just pass the block element here to avoid a DOM parentNode call.
@@ -8503,7 +8536,7 @@ var Vue = (function () {
           const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText(''));
           let { patchFlag, dynamicChildren, slotScopeIds: fragmentSlotScopeIds } = n2;
           if (// #5523 dev root fragment may inherit directives
-              (isHmrUpdating || patchFlag & 2048 /* DEV_ROOT_FRAGMENT */)) {
+              (isHmrUpdating || patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */)) {
               // HMR updated / Dev root fragment (w/ comments), force full diff
               patchFlag = 0;
               optimized = false;
@@ -8525,7 +8558,7 @@ var Vue = (function () {
           }
           else {
               if (patchFlag > 0 &&
-                  patchFlag & 64 /* STABLE_FRAGMENT */ &&
+                  patchFlag & 64 /* PatchFlags.STABLE_FRAGMENT */ &&
                   dynamicChildren &&
                   // #2715 the previous fragment could've been a BAILed one as a result
                   // of renderSlot() with no valid children
@@ -8558,7 +8591,7 @@ var Vue = (function () {
       const processComponent = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => {
           n2.slotScopeIds = slotScopeIds;
           if (n1 == null) {
-              if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) {
+              if (n2.shapeFlag & 512 /* ShapeFlags.COMPONENT_KEPT_ALIVE */) {
                   parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized);
               }
               else {
@@ -8663,7 +8696,7 @@ var Vue = (function () {
                       (vnodeHook = props && props.onVnodeBeforeMount)) {
                       invokeVNodeHook(vnodeHook, parent, initialVNode);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       instance.emit('hook:beforeMount');
                   }
                   toggleRecurse(instance, true);
@@ -8724,18 +8757,18 @@ var Vue = (function () {
                       const scopedInitialVNode = initialVNode;
                       queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, scopedInitialVNode), parentSuspense);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       queuePostRenderEffect(() => instance.emit('hook:mounted'), parentSuspense);
                   }
                   // activated hook for keep-alive roots.
                   // #1742 activated hook must be accessed after first render
                   // since the hook may be injected by a child keep-alive
-                  if (initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ ||
+                  if (initialVNode.shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */ ||
                       (parent &&
                           isAsyncWrapper(parent.vnode) &&
-                          parent.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */)) {
+                          parent.vnode.shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */)) {
                       instance.a && queuePostRenderEffect(instance.a, parentSuspense);
-                      if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                      if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                           queuePostRenderEffect(() => instance.emit('hook:activated'), parentSuspense);
                       }
                   }
@@ -8773,7 +8806,7 @@ var Vue = (function () {
                   if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) {
                       invokeVNodeHook(vnodeHook, parent, next, vnode);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       instance.emit('hook:beforeUpdate');
                   }
                   toggleRecurse(instance, true);
@@ -8813,7 +8846,7 @@ var Vue = (function () {
                   if ((vnodeHook = next.props && next.props.onVnodeUpdated)) {
                       queuePostRenderEffect(() => invokeVNodeHook(vnodeHook, parent, next, vnode), parentSuspense);
                   }
-                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+                  if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
                       queuePostRenderEffect(() => instance.emit('hook:updated'), parentSuspense);
                   }
                   {
@@ -8853,7 +8886,7 @@ var Vue = (function () {
           pauseTracking();
           // props update may have triggered pre-flush watchers.
           // flush them before the render update.
-          flushPreFlushCbs(undefined, instance.update);
+          flushPreFlushCbs();
           resetTracking();
       };
       const patchChildren = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized = false) => {
@@ -8863,22 +8896,22 @@ var Vue = (function () {
           const { patchFlag, shapeFlag } = n2;
           // fast path
           if (patchFlag > 0) {
-              if (patchFlag & 128 /* KEYED_FRAGMENT */) {
+              if (patchFlag & 128 /* PatchFlags.KEYED_FRAGMENT */) {
                   // this could be either fully-keyed or mixed (some keyed some not)
                   // presence of patchFlag means children are guaranteed to be arrays
                   patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   return;
               }
-              else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) {
+              else if (patchFlag & 256 /* PatchFlags.UNKEYED_FRAGMENT */) {
                   // unkeyed
                   patchUnkeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   return;
               }
           }
           // children has 3 possibilities: text, array or no children.
-          if (shapeFlag & 8 /* TEXT_CHILDREN */) {
+          if (shapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
               // text children fast path
-              if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
+              if (prevShapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                   unmountChildren(c1, parentComponent, parentSuspense);
               }
               if (c2 !== c1) {
@@ -8886,9 +8919,9 @@ var Vue = (function () {
               }
           }
           else {
-              if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) {
+              if (prevShapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                   // prev children was array
-                  if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+                  if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                       // two arrays, cannot assume anything, do full diff
                       patchKeyedChildren(c1, c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   }
@@ -8900,11 +8933,11 @@ var Vue = (function () {
               else {
                   // prev children was text OR null
                   // new children is array OR null
-                  if (prevShapeFlag & 8 /* TEXT_CHILDREN */) {
+                  if (prevShapeFlag & 8 /* ShapeFlags.TEXT_CHILDREN */) {
                       hostSetElementText(container, '');
                   }
                   // mount new if array
-                  if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+                  if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                       mountChildren(c2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   }
               }
@@ -9095,7 +9128,7 @@ var Vue = (function () {
                       // There is no stable subsequence (e.g. a reverse)
                       // OR current node is not among the stable sequence
                       if (j < 0 || i !== increasingNewIndexSequence[j]) {
-                          move(nextChild, container, anchor, 2 /* REORDER */);
+                          move(nextChild, container, anchor, 2 /* MoveType.REORDER */);
                       }
                       else {
                           j--;
@@ -9106,15 +9139,15 @@ var Vue = (function () {
       };
       const move = (vnode, container, anchor, moveType, parentSuspense = null) => {
           const { el, type, transition, children, shapeFlag } = vnode;
-          if (shapeFlag & 6 /* COMPONENT */) {
+          if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
               move(vnode.component.subTree, container, anchor, moveType);
               return;
           }
-          if (shapeFlag & 128 /* SUSPENSE */) {
+          if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
               vnode.suspense.move(container, anchor, moveType);
               return;
           }
-          if (shapeFlag & 64 /* TELEPORT */) {
+          if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
               type.move(vnode, container, anchor, internals);
               return;
           }
@@ -9131,11 +9164,11 @@ var Vue = (function () {
               return;
           }
           // single nodes
-          const needTransition = moveType !== 2 /* REORDER */ &&
-              shapeFlag & 1 /* ELEMENT */ &&
+          const needTransition = moveType !== 2 /* MoveType.REORDER */ &&
+              shapeFlag & 1 /* ShapeFlags.ELEMENT */ &&
               transition;
           if (needTransition) {
-              if (moveType === 0 /* ENTER */) {
+              if (moveType === 0 /* MoveType.ENTER */) {
                   transition.beforeEnter(el);
                   hostInsert(el, container, anchor);
                   queuePostRenderEffect(() => transition.enter(el), parentSuspense);
@@ -9167,42 +9200,42 @@ var Vue = (function () {
           if (ref != null) {
               setRef(ref, null, parentSuspense, vnode, true);
           }
-          if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) {
+          if (shapeFlag & 256 /* ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE */) {
               parentComponent.ctx.deactivate(vnode);
               return;
           }
-          const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs;
+          const shouldInvokeDirs = shapeFlag & 1 /* ShapeFlags.ELEMENT */ && dirs;
           const shouldInvokeVnodeHook = !isAsyncWrapper(vnode);
           let vnodeHook;
           if (shouldInvokeVnodeHook &&
               (vnodeHook = props && props.onVnodeBeforeUnmount)) {
               invokeVNodeHook(vnodeHook, parentComponent, vnode);
           }
-          if (shapeFlag & 6 /* COMPONENT */) {
+          if (shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
               unmountComponent(vnode.component, parentSuspense, doRemove);
           }
           else {
-              if (shapeFlag & 128 /* SUSPENSE */) {
+              if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
                   vnode.suspense.unmount(parentSuspense, doRemove);
                   return;
               }
               if (shouldInvokeDirs) {
                   invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount');
               }
-              if (shapeFlag & 64 /* TELEPORT */) {
+              if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
                   vnode.type.remove(vnode, parentComponent, parentSuspense, optimized, internals, doRemove);
               }
               else if (dynamicChildren &&
                   // #1153: fast path should not be taken for non-stable (v-for) fragments
                   (type !== Fragment ||
-                      (patchFlag > 0 && patchFlag & 64 /* STABLE_FRAGMENT */))) {
+                      (patchFlag > 0 && patchFlag & 64 /* PatchFlags.STABLE_FRAGMENT */))) {
                   // fast path for block nodes: only need to unmount dynamic children.
                   unmountChildren(dynamicChildren, parentComponent, parentSuspense, false, true);
               }
               else if ((type === Fragment &&
                   patchFlag &
-                      (128 /* KEYED_FRAGMENT */ | 256 /* UNKEYED_FRAGMENT */)) ||
-                  (!optimized && shapeFlag & 16 /* ARRAY_CHILDREN */)) {
+                      (128 /* PatchFlags.KEYED_FRAGMENT */ | 256 /* PatchFlags.UNKEYED_FRAGMENT */)) ||
+                  (!optimized && shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */)) {
                   unmountChildren(children, parentComponent, parentSuspense);
               }
               if (doRemove) {
@@ -9223,7 +9256,7 @@ var Vue = (function () {
           const { type, el, anchor, transition } = vnode;
           if (type === Fragment) {
               if (vnode.patchFlag > 0 &&
-                  vnode.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */ &&
+                  vnode.patchFlag & 2048 /* PatchFlags.DEV_ROOT_FRAGMENT */ &&
                   transition &&
                   !transition.persisted) {
                   vnode.children.forEach(child => {
@@ -9250,7 +9283,7 @@ var Vue = (function () {
                   transition.afterLeave();
               }
           };
-          if (vnode.shapeFlag & 1 /* ELEMENT */ &&
+          if (vnode.shapeFlag & 1 /* ShapeFlags.ELEMENT */ &&
               transition &&
               !transition.persisted) {
               const { leave, delayLeave } = transition;
@@ -9286,7 +9319,7 @@ var Vue = (function () {
           if (bum) {
               invokeArrayFns(bum);
           }
-          if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+          if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
               instance.emit('hook:beforeDestroy');
           }
           // stop effects in component scope
@@ -9302,7 +9335,7 @@ var Vue = (function () {
           if (um) {
               queuePostRenderEffect(um, parentSuspense);
           }
-          if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* INSTANCE_EVENT_HOOKS */, instance)) {
+          if (isCompatEnabled("INSTANCE_EVENT_HOOKS" /* DeprecationTypes.INSTANCE_EVENT_HOOKS */, instance)) {
               queuePostRenderEffect(() => instance.emit('hook:destroyed'), parentSuspense);
           }
           queuePostRenderEffect(() => {
@@ -9332,10 +9365,10 @@ var Vue = (function () {
           }
       };
       const getNextHostNode = vnode => {
-          if (vnode.shapeFlag & 6 /* COMPONENT */) {
+          if (vnode.shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
               return getNextHostNode(vnode.component.subTree);
           }
-          if (vnode.shapeFlag & 128 /* SUSPENSE */) {
+          if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
               return vnode.suspense.next();
           }
           return hostNextSibling((vnode.anchor || vnode.el));
@@ -9349,6 +9382,7 @@ var Vue = (function () {
           else {
               patch(container._vnode || null, vnode, container, null, null, null, isSVG);
           }
+          flushPreFlushCbs();
           flushPostFlushCbs();
           container._vnode = vnode;
       };
@@ -9398,8 +9432,8 @@ var Vue = (function () {
               // guaranteed to be vnodes
               const c1 = ch1[i];
               let c2 = ch2[i];
-              if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) {
-                  if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* HYDRATE_EVENTS */) {
+              if (c2.shapeFlag & 1 /* ShapeFlags.ELEMENT */ && !c2.dynamicChildren) {
+                  if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* PatchFlags.HYDRATE_EVENTS */) {
                       c2 = ch2[i] = cloneIfMounted(ch2[i]);
                       c2.el = c1.el;
                   }
@@ -9519,7 +9553,7 @@ var Vue = (function () {
               const mount = (container, anchor) => {
                   // Teleport *always* has Array children. This is enforced in both the
                   // compiler and vnode children normalization.
-                  if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+                  if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                       mountChildren(children, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized);
                   }
               };
@@ -9555,7 +9589,7 @@ var Vue = (function () {
                   if (!wasDisabled) {
                       // enabled -> disabled
                       // move into main container
-                      moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);
+                      moveTeleport(n2, container, mainAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */);
                   }
               }
               else {
@@ -9563,7 +9597,7 @@ var Vue = (function () {
                   if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) {
                       const nextTarget = (n2.target = resolveTarget(n2.props, querySelector));
                       if (nextTarget) {
-                          moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */);
+                          moveTeleport(n2, nextTarget, null, internals, 0 /* TeleportMoveTypes.TARGET_CHANGE */);
                       }
                       else {
                           warn$1('Invalid Teleport target on update:', target, `(${typeof target})`);
@@ -9572,7 +9606,7 @@ var Vue = (function () {
                   else if (wasDisabled) {
                       // disabled -> enabled
                       // move into teleport target
-                      moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);
+                      moveTeleport(n2, target, targetAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */);
                   }
               }
           }
@@ -9585,7 +9619,7 @@ var Vue = (function () {
           // an unmounted teleport should always remove its children if not disabled
           if (doRemove || !isTeleportDisabled(props)) {
               hostRemove(anchor);
-              if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+              if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
                   for (let i = 0; i < children.length; i++) {
                       const child = children[i];
                       unmount(child, parentComponent, parentSuspense, true, !!child.dynamicChildren);
@@ -9596,13 +9630,13 @@ var Vue = (function () {
       move: moveTeleport,
       hydrate: hydrateTeleport
   };
-  function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* REORDER */) {
+  function moveTeleport(vnode, container, parentAnchor, { o: { insert }, m: move }, moveType = 2 /* TeleportMoveTypes.REORDER */) {
       // move target anchor if this is a target change.
-      if (moveType === 0 /* TARGET_CHANGE */) {
+      if (moveType === 0 /* TeleportMoveTypes.TARGET_CHANGE */) {
           insert(vnode.targetAnchor, container, parentAnchor);
       }
       const { el, anchor, shapeFlag, children, props } = vnode;
-      const isReorder = moveType === 2 /* REORDER */;
+      const isReorder = moveType === 2 /* TeleportMoveTypes.REORDER */;
       // move main view anchor if this is a re-order.
       if (isReorder) {
           insert(el, container, parentAnchor);
@@ -9612,9 +9646,9 @@ var Vue = (function () {
       // is not a reorder, or the teleport is disabled
       if (!isReorder || isTeleportDisabled(props)) {
           // Teleport has either Array children or no children.
-          if (shapeFlag & 16 /* ARRAY_CHILDREN */) {
+          if (shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
               for (let i = 0; i < children.length; i++) {
-                  move(children[i], container, parentAnchor, 2 /* REORDER */);
+                  move(children[i], container, parentAnchor, 2 /* MoveType.REORDER */);
               }
           }
       }
@@ -9629,7 +9663,7 @@ var Vue = (function () {
           // if multiple teleports rendered to the same target element, we need to
           // pick up from where the last teleport finished instead of the first node
           const targetNode = target._lpa || target.firstChild;
-          if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) {
+          if (vnode.shapeFlag & 16 /* ShapeFlags.ARRAY_CHILDREN */) {
               if (isTeleportDisabled(vnode.props)) {
                   vnode.anchor = hydrateChildren(nextSibling(node), vnode, parentNode(node), parentComponent, parentSuspense, slotScopeIds, optimized);
                   vnode.targetAnchor = targetNode;
@@ -9706,7 +9740,7 @@ var Vue = (function () {
       }
       // 2.x async component
       if (isFunction(comp) &&
-          checkCompatEnabled("COMPONENT_ASYNC" /* COMPONENT_ASYNC */, instance, comp)) {
+          checkCompatEnabled("COMPONENT_ASYNC" /* DeprecationTypes.COMPONENT_ASYNC */, instance, comp)) {
           // since after disabling this, plain functions are still valid usage, do not
           // use softAssert here.
           return convertLegacyAsyncComponent(comp);
@@ -9714,7 +9748,7 @@ var Vue = (function () {
       // 2.x functional component
       if (isObject(comp) &&
           comp.functional &&
-          softAssertCompatEnabled("COMPONENT_FUNCTIONAL" /* COMPONENT_FUNCTIONAL */, instance, comp)) {
+          softAssertCompatEnabled("COMPONENT_FUNCTIONAL" /* DeprecationTypes.COMPONENT_FUNCTIONAL */, instance, comp)) {
           return convertLegacyFunctionalComponent(comp);
       }
       return comp;
@@ -9811,7 +9845,7 @@ var Vue = (function () {
       return value ? value.__v_isVNode === true : false;
   }
   function isSameVNodeType(n1, n2) {
-      if (n2.shapeFlag & 6 /* COMPONENT */ &&
+      if (n2.shapeFlag & 6 /* ShapeFlags.COMPONENT */ &&
           hmrDirtyComponents.has(n2.type)) {
           // HMR only: if the component has been hot-updated, force a reload.
           return false;
@@ -9842,7 +9876,7 @@ var Vue = (function () {
               : ref
           : null);
   };
-  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1 /* ELEMENT */, isBlockNode = false, needFullChildrenNormalization = false) {
+  function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1 /* ShapeFlags.ELEMENT */, isBlockNode = false, needFullChildrenNormalization = false) {
       const vnode = {
           __v_isVNode: true,
           __v_skip: true,
@@ -9873,7 +9907,7 @@ var Vue = (function () {
       if (needFullChildrenNormalization) {
           normalizeChildren(vnode, children);
           // normalize suspense children
-          if (shapeFlag & 128 /* SUSPENSE */) {
+          if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
               type.normalize(vnode);
           }
       }
@@ -9881,8 +9915,8 @@ var Vue = (function () {
           // compiled element vnode - if children is passed, only possible types are
           // string or Array.
           vnode.shapeFlag |= isString(children)
-              ? 8 /* TEXT_CHILDREN */
-              : 16 /* ARRAY_CHILDREN */;
+              ? 8 /* ShapeFlags.TEXT_CHILDREN */
+              : 16 /* ShapeFlags.ARRAY_CHILDREN */;
       }
       // validate key
       if (vnode.key !== vnode.key) {
@@ -9898,10 +9932,10 @@ var Vue = (function () {
           // component nodes also should always be patched, because even if the
           // component doesn't need to update, it needs to persist the instance on to
           // the next vnode so that it can be properly unmounted later.
-          (vnode.patchFlag > 0 || shapeFlag & 6 /* COMPONENT */) &&
+          (vnode.patchFlag > 0 || shapeFlag & 6 /* ShapeFlags.COMPONENT */) &&
           // the EVENTS flag is only for hydration and if it is the only flag, the
           // vnode should not be considered dynamic due to handler caching.
-          vnode.patchFlag !== 32 /* HYDRATE_EVENTS */) {
+          vnode.patchFlag !== 32 /* PatchFlags.HYDRATE_EVENTS */) {
           currentBlock.push(vnode);
       }
       {
@@ -9927,14 +9961,14 @@ var Vue = (function () {
               normalizeChildren(cloned, children);
           }
           if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
-              if (cloned.shapeFlag & 6 /* COMPONENT */) {
+              if (cloned.shapeFlag & 6 /* ShapeFlags.COMPONENT */) {
                   currentBlock[currentBlock.indexOf(type)] = cloned;
               }
               else {
                   currentBlock.push(cloned);
               }
           }
-          cloned.patchFlag |= -2 /* BAIL */;
+          cloned.patchFlag |= -2 /* PatchFlags.BAIL */;
           return cloned;
       }
       // class component normalization.
@@ -9964,17 +9998,17 @@ var Vue = (function () {
       }
       // encode the vnode type information into a bitmap
       const shapeFlag = isString(type)
-          ? 1 /* ELEMENT */
+          ? 1 /* ShapeFlags.ELEMENT */
           : isSuspense(type)
-              ? 128 /* SUSPENSE */
+              ? 128 /* ShapeFlags.SUSPENSE */
               : isTeleport(type)
-                  ? 64 /* TELEPORT */
+                  ? 64 /* ShapeFlags.TELEPORT */
                   : isObject(type)
-                      ? 4 /* STATEFUL_COMPONENT */
+                      ? 4 /* ShapeFlags.STATEFUL_COMPONENT */
                       : isFunction(type)
-                          ? 2 /* FUNCTIONAL_COMPONENT */
+                          ? 2 /* ShapeFlags.FUNCTIONAL_COMPONENT */
                           : 0;
-      if (shapeFlag & 4 /* STATEFUL_COMPONENT */ && isProxy(type)) {
+      if (shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */ && isProxy(type)) {
           type = toRaw(type);
           warn$1(`Vue received a Component which was made a reactive object. This can ` +
               `lead to unnecessary performance overhead, and should be avoided by ` +
@@ -10013,7 +10047,7 @@ var Vue = (function () {
               : ref,
           scopeId: vnode.scopeId,
           slotScopeIds: vnode.slotScopeIds,
-          children: patchFlag === -1 /* HOISTED */ && isArray(children)
+          children: patchFlag === -1 /* PatchFlags.HOISTED */ && isArray(children)
               ? children.map(deepCloneVNode)
               : children,
           target: vnode.target,
@@ -10026,8 +10060,8 @@ var Vue = (function () {
           // fast paths only.
           patchFlag: extraProps && vnode.type !== Fragment
               ? patchFlag === -1 // hoisted node
-                  ? 16 /* FULL_PROPS */
-                  : patchFlag | 16 /* FULL_PROPS */
+                  ? 16 /* PatchFlags.FULL_PROPS */
+                  : patchFlag | 16 /* PatchFlags.FULL_PROPS */
               : patchFlag,
           dynamicProps: vnode.dynamicProps,
           dynamicChildren: vnode.dynamicChildren,
@@ -10120,10 +10154,10 @@ var Vue = (function () {
           children = null;
       }
       else if (isArray(children)) {
-          type = 16 /* ARRAY_CHILDREN */;
+          type = 16 /* ShapeFlags.ARRAY_CHILDREN */;
       }
       else if (typeof children === 'object') {
-          if (shapeFlag & (1 /* ELEMENT */ | 64 /* TELEPORT */)) {
+          if (shapeFlag & (1 /* ShapeFlags.ELEMENT */ | 64 /* ShapeFlags.TELEPORT */)) {
               // Normalize slot to plain children for plain element and Teleport
               const slot = children.default;
               if (slot) {
@@ -10135,37 +10169,37 @@ var Vue = (function () {
               return;
           }
           else {
-              type = 32 /* SLOTS_CHILDREN */;
+              type = 32 /* ShapeFlags.SLOTS_CHILDREN */;
               const slotFlag = children._;
               if (!slotFlag && !(InternalObjectKey in children)) {
                   children._ctx = currentRenderingInstance;
               }
-              else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) {
+              else if (slotFlag === 3 /* SlotFlags.FORWARDED */ && currentRenderingInstance) {
                   // a child component receives forwarded slots from the parent.
                   // its slot type is determined by its parent's slot type.
-                  if (currentRenderingInstance.slots._ === 1 /* STABLE */) {
-                      children._ = 1 /* STABLE */;
+                  if (currentRenderingInstance.slots._ === 1 /* SlotFlags.STABLE */) {
+                      children._ = 1 /* SlotFlags.STABLE */;
                   }
                   else {
-                      children._ = 2 /* DYNAMIC */;
-                      vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */;
+                      children._ = 2 /* SlotFlags.DYNAMIC */;
+                      vnode.patchFlag |= 1024 /* PatchFlags.DYNAMIC_SLOTS */;
                   }
               }
           }
       }
       else if (isFunction(children)) {
           children = { default: children, _ctx: currentRenderingInstance };
-          type = 32 /* SLOTS_CHILDREN */;
+          type = 32 /* ShapeFlags.SLOTS_CHILDREN */;
       }
       else {
           children = String(children);
           // force teleport children to array so it can be moved around
-          if (shapeFlag & 64 /* TELEPORT */) {
-              type = 16 /* ARRAY_CHILDREN */;
+          if (shapeFlag & 64 /* ShapeFlags.TELEPORT */) {
+              type = 16 /* ShapeFlags.ARRAY_CHILDREN */;
               children = [createTextVNode(children)];
           }
           else {
-              type = 8 /* TEXT_CHILDREN */;
+              type = 8 /* ShapeFlags.TEXT_CHILDREN */;
           }
       }
       vnode.children = children;
@@ -10203,7 +10237,7 @@ var Vue = (function () {
       return ret;
   }
   function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
-      callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [
+      callWithAsyncErrorHandling(hook, instance, 7 /* ErrorCodes.VNODE_HOOK */, [
           vnode,
           prevVNode
       ]);
@@ -10311,7 +10345,7 @@ var Vue = (function () {
       }
   }
   function isStatefulComponent(instance) {
-      return instance.vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */;
+      return instance.vnode.shapeFlag & 4 /* ShapeFlags.STATEFUL_COMPONENT */;
   }
   let isInSSRComponentSetup = false;
   function setupComponent(instance, isSSR = false) {
@@ -10366,7 +10400,7 @@ var Vue = (function () {
               setup.length > 1 ? createSetupContext(instance) : null);
           setCurrentInstance(instance);
           pauseTracking();
-          const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [shallowReadonly(instance.props) , setupContext]);
+          const setupResult = callWithErrorHandling(setup, instance, 0 /* ErrorCodes.SETUP_FUNCTION */, [shallowReadonly(instance.props) , setupContext]);
           resetTracking();
           unsetCurrentInstance();
           if (isPromise(setupResult)) {
@@ -10378,7 +10412,7 @@ var Vue = (function () {
                       handleSetupResult(instance, resolvedResult, isSSR);
                   })
                       .catch(e => {
-                      handleError(e, instance, 0 /* SETUP_FUNCTION */);
+                      handleError(e, instance, 0 /* ErrorCodes.SETUP_FUNCTION */);
                   });
               }
               else {
@@ -10461,7 +10495,8 @@ var Vue = (function () {
           if (!isSSR && compile && !Component.render) {
               const template = (instance.vnode.props &&
                   instance.vnode.props['inline-template']) ||
-                  Component.template;
+                  Component.template ||
+                  resolveMergedOptions(instance).template;
               if (template) {
                   {
                       startMeasure(instance, `compile`);
@@ -10476,6 +10511,7 @@ var Vue = (function () {
                       // pass runtime compat config into the compiler
                       finalCompilerOptions.compatConfig = Object.create(globalCompatConfig);
                       if (Component.compatConfig) {
+                          // @ts-expect-error types are not compatible
                           extend(finalCompilerOptions.compatConfig, Component.compatConfig);
                       }
                   }
@@ -10520,7 +10556,7 @@ var Vue = (function () {
       return new Proxy(instance.attrs, {
               get(target, key) {
                   markAttrsAccessed();
-                  track(instance, "get" /* GET */, '$attrs');
+                  track(instance, "get" /* TrackOpTypes.GET */, '$attrs');
                   return target[key];
               },
               set() {
@@ -10576,10 +10612,10 @@ var Vue = (function () {
   }
   const classifyRE = /(?:^|[-_])(\w)/g;
   const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '');
-  function getComponentName(Component) {
+  function getComponentName(Component, includeInferred = true) {
       return isFunction(Component)
           ? Component.displayName || Component.name
-          : Component.name;
+          : Component.name || (includeInferred && Component.__name);
   }
   /* istanbul ignore next */
   function formatComponentName(instance, Component, isRoot = false) {
@@ -11018,9 +11054,9 @@ var Vue = (function () {
   }
 
   // Core API ------------------------------------------------------------------
-  const version = "3.2.36";
+  const version = "3.2.39";
   /**
-   * SSR utils for \@vue/server-renderer. Only exposed in cjs builds.
+   * SSR utils for \@vue/server-renderer. Only exposed in ssr-possible builds.
    * @internal
    */
   const ssrUtils = (null);
@@ -11268,14 +11304,14 @@ var Vue = (function () {
                   ? 'true'
                   : null;
           if (v2CocercedValue &&
-              compatUtils.softAssertCompatEnabled("ATTR_ENUMERATED_COERCION" /* ATTR_ENUMERATED_COERCION */, instance, key, value, v2CocercedValue)) {
+              compatUtils.softAssertCompatEnabled("ATTR_ENUMERATED_COERCION" /* DeprecationTypes.ATTR_ENUMERATED_COERCION */, instance, key, value, v2CocercedValue)) {
               el.setAttribute(key, v2CocercedValue);
               return true;
           }
       }
       else if (value === false &&
           !isSpecialBooleanAttr(key) &&
-          compatUtils.softAssertCompatEnabled("ATTR_FALSE_VALUE" /* ATTR_FALSE_VALUE */, instance, key)) {
+          compatUtils.softAssertCompatEnabled("ATTR_FALSE_VALUE" /* DeprecationTypes.ATTR_FALSE_VALUE */, instance, key)) {
           el.removeAttribute(key);
           return true;
       }
@@ -11337,10 +11373,10 @@ var Vue = (function () {
       }
       else {
           if (value === false &&
-              compatUtils.isCompatEnabled("ATTR_FALSE_VALUE" /* ATTR_FALSE_VALUE */, parentComponent)) {
+              compatUtils.isCompatEnabled("ATTR_FALSE_VALUE" /* DeprecationTypes.ATTR_FALSE_VALUE */, parentComponent)) {
               const type = typeof el[key];
               if (type === 'string' || type === 'number') {
-                  compatUtils.warnDeprecation("ATTR_FALSE_VALUE" /* ATTR_FALSE_VALUE */, parentComponent, key);
+                  compatUtils.warnDeprecation("ATTR_FALSE_VALUE" /* DeprecationTypes.ATTR_FALSE_VALUE */, parentComponent, key);
                   value = type === 'number' ? 0 : '';
                   needRemove = true;
               }
@@ -11430,7 +11466,8 @@ var Vue = (function () {
               options[m[0].toLowerCase()] = true;
           }
       }
-      return [hyphenate(name.slice(2)), options];
+      const event = name[2] === ':' ? name.slice(3) : hyphenate(name.slice(2));
+      return [event, options];
   }
   function createInvoker(initialValue, instance) {
       const invoker = (e) => {
@@ -11442,7 +11479,7 @@ var Vue = (function () {
           // AFTER it was attached.
           const timeStamp = e.timeStamp || _getNow();
           if (skipTimestampCheck || timeStamp >= invoker.attached - 1) {
-              callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* NATIVE_EVENT_HANDLER */, [e]);
+              callWithAsyncErrorHandling(patchStopImmediatePropagation(e, invoker.value), instance, 5 /* ErrorCodes.NATIVE_EVENT_HANDLER */, [e]);
           }
       };
       invoker.value = initialValue;
@@ -11785,7 +11822,7 @@ var Vue = (function () {
       });
   }
   function setVarsOnVNode(vnode, vars) {
-      if (vnode.shapeFlag & 128 /* SUSPENSE */) {
+      if (vnode.shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
           const suspense = vnode.suspense;
           vnode = suspense.activeBranch;
           if (suspense.pendingBranch && !suspense.isHydrating) {
@@ -11798,7 +11835,7 @@ var Vue = (function () {
       while (vnode.component) {
           vnode = vnode.component.subTree;
       }
-      if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) {
+      if (vnode.shapeFlag & 1 /* ShapeFlags.ELEMENT */ && vnode.el) {
           setVarsOnNode(vnode.el, vars);
       }
       else if (vnode.type === Fragment) {
@@ -11887,7 +11924,7 @@ var Vue = (function () {
       }
       const { name = 'v', type, duration, enterFromClass = `${name}-enter-from`, enterActiveClass = `${name}-enter-active`, enterToClass = `${name}-enter-to`, appearFromClass = enterFromClass, appearActiveClass = enterActiveClass, appearToClass = enterToClass, leaveFromClass = `${name}-leave-from`, leaveActiveClass = `${name}-leave-active`, leaveToClass = `${name}-leave-to` } = rawProps;
       // legacy transition class compat
-      const legacyClassEnabled = compatUtils.isCompatEnabled("TRANSITION_CLASSES" /* TRANSITION_CLASSES */, null);
+      const legacyClassEnabled = compatUtils.isCompatEnabled("TRANSITION_CLASSES" /* DeprecationTypes.TRANSITION_CLASSES */, null);
       let legacyEnterFromClass;
       let legacyAppearFromClass;
       let legacyLeaveFromClass;
@@ -12196,7 +12233,7 @@ var Vue = (function () {
               const cssTransitionProps = resolveTransitionProps(rawProps);
               let tag = rawProps.tag || Fragment;
               if (!rawProps.tag &&
-                  compatUtils.checkCompatEnabled("TRANSITION_GROUP_ROOT" /* TRANSITION_GROUP_ROOT */, instance.parent)) {
+                  compatUtils.checkCompatEnabled("TRANSITION_GROUP_ROOT" /* DeprecationTypes.TRANSITION_GROUP_ROOT */, instance.parent)) {
                   tag = 'span';
               }
               prevChildren = children;
@@ -12566,13 +12603,13 @@ var Vue = (function () {
       let instance = null;
       {
           instance = getCurrentInstance();
-          if (compatUtils.isCompatEnabled("CONFIG_KEY_CODES" /* CONFIG_KEY_CODES */, instance)) {
+          if (compatUtils.isCompatEnabled("CONFIG_KEY_CODES" /* DeprecationTypes.CONFIG_KEY_CODES */, instance)) {
               if (instance) {
                   globalKeyCodes = instance.appContext.config.keyCodes;
               }
           }
           if (modifiers.some(m => /^\d+$/.test(m))) {
-              compatUtils.warnDeprecation("V_ON_KEYCODE_MODIFIER" /* V_ON_KEYCODE_MODIFIER */, instance);
+              compatUtils.warnDeprecation("V_ON_KEYCODE_MODIFIER" /* DeprecationTypes.V_ON_KEYCODE_MODIFIER */, instance);
           }
       }
       return (event) => {
@@ -12585,7 +12622,7 @@ var Vue = (function () {
           }
           {
               const keyCode = String(event.keyCode);
-              if (compatUtils.isCompatEnabled("V_ON_KEYCODE_MODIFIER" /* V_ON_KEYCODE_MODIFIER */, instance) &&
+              if (compatUtils.isCompatEnabled("V_ON_KEYCODE_MODIFIER" /* DeprecationTypes.V_ON_KEYCODE_MODIFIER */, instance) &&
                   modifiers.some(mod => mod == keyCode)) {
                   return fn(event);
               }
@@ -12694,7 +12731,7 @@ var Vue = (function () {
                   for (let i = 0; i < container.attributes.length; i++) {
                       const attr = container.attributes[i];
                       if (attr.name !== 'v-cloak' && /^(v-|:|@)/.test(attr.name)) {
-                          compatUtils.warnDeprecation("GLOBAL_MOUNT_CONTAINER" /* GLOBAL_MOUNT_CONTAINER */, null);
+                          compatUtils.warnDeprecation("GLOBAL_MOUNT_CONTAINER" /* DeprecationTypes.GLOBAL_MOUNT_CONTAINER */, null);
                           break;
                       }
                   }
@@ -12951,7 +12988,7 @@ var Vue = (function () {
   function wrappedCreateApp(...args) {
       // @ts-ignore
       const app = createApp(...args);
-      if (compatUtils.isCompatEnabled("RENDER_FUNCTION" /* RENDER_FUNCTION */, null)) {
+      if (compatUtils.isCompatEnabled("RENDER_FUNCTION" /* DeprecationTypes.RENDER_FUNCTION */, null)) {
           // register built-in components so that they can be resolved via strings
           // in the legacy h() call. The __compat__ prefix is to ensure that v3 h()
           // doesn't get affected.