@vue/runtime-dom 3.2.36 → 3.2.39

package/dist/runtime-dom.global.js

@@ -641,7 +641,7 @@ var VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
           }
           // 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 VueRuntimeDOM = (function (exports) {
                       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 VueRuntimeDOM = (function (exports) {
                       }
                   }
                   break;
-              case "set" /* SET */:
+              case "set" /* TriggerOpTypes.SET */:
                   if (isMap(target)) {
                       deps.push(depsMap.get(ITERATE_KEY));
                   }
@@ -757,7 +757,7 @@ var VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
   }
   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 VueRuntimeDOM = (function (exports) {
               return res;
           }
           if (!isReadonly) {
-              track(target, "get" /* GET */, key);
+              track(target, "get" /* TrackOpTypes.GET */, key);
           }
           if (shallow) {
               return res;
@@ -837,10 +837,10 @@ var VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
           // 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 VueRuntimeDOM = (function (exports) {
       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 VueRuntimeDOM = (function (exports) {
   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 VueRuntimeDOM = (function (exports) {
       }
   }
   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 VueRuntimeDOM = (function (exports) {
       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 VueRuntimeDOM = (function (exports) {
       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 VueRuntimeDOM = (function (exports) {
       // 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 VueRuntimeDOM = (function (exports) {
       // 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 VueRuntimeDOM = (function (exports) {
   }
   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 VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
               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 VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
               ? 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 VueRuntimeDOM = (function (exports) {
       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 VueRuntimeDOM = (function (exports) {
       }
       // 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 VueRuntimeDOM = (function (exports) {
       }
       // 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 VueRuntimeDOM = (function (exports) {
           {
               trackEffects(ref.dep || (ref.dep = createDep()), {
                   target: ref,
-                  type: "get" /* GET */,
+                  type: "get" /* TrackOpTypes.GET */,
                   key: 'value'
               });
           }
@@ -1332,7 +1332,7 @@ var VueRuntimeDOM = (function (exports) {
           {
               triggerEffects(ref.dep, {
                   target: ref,
-                  type: "set" /* SET */,
+                  type: "set" /* TriggerOpTypes.SET */,
                   key: 'value',
                   newValue: newVal
               });
@@ -1367,10 +1367,11 @@ var VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
           : 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 VueRuntimeDOM = (function (exports) {
           });
           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 VueRuntimeDOM = (function (exports) {
           this._setter(newValue);
       }
   }
+  _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
   function computed(getterOrOptions, debugOptions, isSSR = false) {
       let getter;
       let setter;
@@ -1517,7 +1521,7 @@ var VueRuntimeDOM = (function (exports) {
       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 VueRuntimeDOM = (function (exports) {
   }
 
   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 VueRuntimeDOM = (function (exports) {
           // 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 VueRuntimeDOM = (function (exports) {
   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 VueRuntimeDOM = (function (exports) {
       // 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 VueRuntimeDOM = (function (exports) {
           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 VueRuntimeDOM = (function (exports) {
       }
   }
   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 VueRuntimeDOM = (function (exports) {
       //    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 VueRuntimeDOM = (function (exports) {
                       continue;
                   }
                   // console.log(`running:`, job.id)
-                  callWithErrorHandling(job, null, 14 /* SCHEDULER */);
+                  callWithErrorHandling(job, null, 14 /* ErrorCodes.SCHEDULER */);
               }
           }
       }
@@ -1897,9 +1894,7 @@ var VueRuntimeDOM = (function (exports) {
           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);
           }
       }
@@ -2116,7 +2111,7 @@ var VueRuntimeDOM = (function (exports) {
       }
   }
   function devtoolsInitApp(app, version) {
-      emit("app:init" /* APP_INIT */, app, version, {
+      emit("app:init" /* DevtoolsHooks.APP_INIT */, app, version, {
           Fragment,
           Text,
           Comment,
@@ -2124,27 +2119,27 @@ var VueRuntimeDOM = (function (exports) {
       });
   }
   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);
   }
 
   function emit$1(instance, event, ...rawArgs) {
@@ -2209,7 +2204,7 @@ var VueRuntimeDOM = (function (exports) {
           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) {
@@ -2220,7 +2215,7 @@ var VueRuntimeDOM = (function (exports) {
               return;
           }
           instance.emitted[handlerName] = true;
-          callWithAsyncErrorHandling(onceHandler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args);
+          callWithAsyncErrorHandling(onceHandler, instance, 6 /* ErrorCodes.COMPONENT_EVENT_HANDLER */, args);
       }
   }
   function normalizeEmitsOptions(comp, appContext, asMixin = false) {
@@ -2252,7 +2247,9 @@ var VueRuntimeDOM = (function (exports) {
           }
       }
       if (!raw && !hasExtends) {
-          cache.set(comp, null);
+          if (isObject(comp)) {
+              cache.set(comp, null);
+          }
           return null;
       }
       if (isArray(raw)) {
@@ -2261,7 +2258,9 @@ var VueRuntimeDOM = (function (exports) {
       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.
@@ -2380,7 +2379,7 @@ var VueRuntimeDOM = (function (exports) {
           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;
@@ -2413,7 +2412,7 @@ var VueRuntimeDOM = (function (exports) {
       }
       catch (err) {
           blockStack.length = 0;
-          handleError(err, instance, 1 /* RENDER_FUNCTION */);
+          handleError(err, instance, 1 /* ErrorCodes.RENDER_FUNCTION */);
           result = createVNode(Comment);
       }
       // attr merging
@@ -2422,14 +2421,14 @@ var VueRuntimeDOM = (function (exports) {
       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
@@ -2570,7 +2569,7 @@ var VueRuntimeDOM = (function (exports) {
       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
       );
   };
@@ -2589,19 +2588,19 @@ var VueRuntimeDOM = (function (exports) {
           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];
@@ -2859,7 +2858,7 @@ var VueRuntimeDOM = (function (exports) {
                   if (delayEnter) {
                       activeBranch.transition.afterLeave = () => {
                           if (pendingId === suspense.pendingId) {
-                              move(pendingBranch, container, anchor, 0 /* ENTER */);
+                              move(pendingBranch, container, anchor, 0 /* MoveType.ENTER */);
                           }
                       };
                   }
@@ -2874,7 +2873,7 @@ var VueRuntimeDOM = (function (exports) {
                   }
                   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);
@@ -2948,7 +2947,7 @@ var VueRuntimeDOM = (function (exports) {
               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.
@@ -3022,7 +3021,7 @@ var VueRuntimeDOM = (function (exports) {
   }
   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)
@@ -3193,7 +3192,7 @@ var VueRuntimeDOM = (function (exports) {
                   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);
@@ -3203,7 +3202,7 @@ var VueRuntimeDOM = (function (exports) {
       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
@@ -3214,7 +3213,7 @@ var VueRuntimeDOM = (function (exports) {
                   if (cleanup) {
                       cleanup();
                   }
-                  return callWithAsyncErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onCleanup]);
+                  return callWithAsyncErrorHandling(source, instance, 3 /* ErrorCodes.WATCH_CALLBACK */, [onCleanup]);
               };
           }
       }
@@ -3229,7 +3228,7 @@ var VueRuntimeDOM = (function (exports) {
       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;
@@ -3250,7 +3249,7 @@ var VueRuntimeDOM = (function (exports) {
                   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,
@@ -3276,7 +3275,10 @@ var VueRuntimeDOM = (function (exports) {
       }
       else {
           // default: 'pre'
-          scheduler = () => queuePreFlushCb(job);
+          job.pre = true;
+          if (instance)
+              job.id = instance.uid;
+          scheduler = () => queueJob(job);
       }
       const effect = new ReactiveEffect(getter, scheduler);
       {
@@ -3343,7 +3345,7 @@ var VueRuntimeDOM = (function (exports) {
       };
   }
   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();
@@ -3527,7 +3529,7 @@ var VueRuntimeDOM = (function (exports) {
       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];
@@ -3663,10 +3665,10 @@ var VueRuntimeDOM = (function (exports) {
           : 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);
       }
@@ -3685,7 +3687,7 @@ var VueRuntimeDOM = (function (exports) {
               : 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));
           }
@@ -3700,7 +3702,7 @@ var VueRuntimeDOM = (function (exports) {
       // 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;
@@ -3778,7 +3780,7 @@ var VueRuntimeDOM = (function (exports) {
               }
               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) ||
@@ -3880,7 +3882,7 @@ var VueRuntimeDOM = (function (exports) {
           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(() => {
@@ -3900,7 +3902,7 @@ var VueRuntimeDOM = (function (exports) {
           };
           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);
@@ -3989,8 +3991,8 @@ var VueRuntimeDOM = (function (exports) {
                   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;
               }
@@ -4012,7 +4014,7 @@ var VueRuntimeDOM = (function (exports) {
               // 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;
                   }
               }
@@ -4031,7 +4033,7 @@ var VueRuntimeDOM = (function (exports) {
                       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);
@@ -4044,7 +4046,7 @@ var VueRuntimeDOM = (function (exports) {
                   }
               }
               // 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;
           };
@@ -4067,10 +4069,10 @@ var VueRuntimeDOM = (function (exports) {
       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
@@ -4114,16 +4116,16 @@ var VueRuntimeDOM = (function (exports) {
   }
   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) {
@@ -4169,19 +4171,19 @@ var VueRuntimeDOM = (function (exports) {
   }
   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);
   }
 
   /**
@@ -4248,7 +4250,7 @@ var VueRuntimeDOM = (function (exports) {
               // 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,
@@ -4293,7 +4295,7 @@ var VueRuntimeDOM = (function (exports) {
           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) ||
@@ -4390,7 +4392,13 @@ var VueRuntimeDOM = (function (exports) {
           }
           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;
@@ -4426,9 +4434,15 @@ var VueRuntimeDOM = (function (exports) {
       }
       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'];
       }
@@ -4456,14 +4470,16 @@ var VueRuntimeDOM = (function (exports) {
    * 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;
   }
@@ -4527,23 +4543,23 @@ var VueRuntimeDOM = (function (exports) {
               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 (
@@ -4551,15 +4567,15 @@ var VueRuntimeDOM = (function (exports) {
               // 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];
@@ -4567,7 +4583,7 @@ var VueRuntimeDOM = (function (exports) {
           // public $xxx properties
           if (publicGetter) {
               if (key === '$attrs') {
-                  track(instance, "get" /* GET */, key);
+                  track(instance, "get" /* TrackOpTypes.GET */, key);
                   markAttrsAccessed();
               }
               return publicGetter(instance);
@@ -4580,7 +4596,7 @@ var VueRuntimeDOM = (function (exports) {
           }
           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 (
@@ -4763,7 +4779,7 @@ var VueRuntimeDOM = (function (exports) {
       // 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
@@ -4779,7 +4795,7 @@ var VueRuntimeDOM = (function (exports) {
           const [propsOptions] = instance.propsOptions;
           if (propsOptions) {
               for (const key in propsOptions) {
-                  checkDuplicateProperties("Props" /* PROPS */, key);
+                  checkDuplicateProperties("Props" /* OptionTypes.PROPS */, key);
               }
           }
       }
@@ -4809,7 +4825,7 @@ var VueRuntimeDOM = (function (exports) {
                       });
                   }
                   {
-                      checkDuplicateProperties("Methods" /* METHODS */, key);
+                      checkDuplicateProperties("Methods" /* OptionTypes.METHODS */, key);
                   }
               }
               else {
@@ -4836,7 +4852,7 @@ var VueRuntimeDOM = (function (exports) {
               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, {
@@ -4880,7 +4896,7 @@ var VueRuntimeDOM = (function (exports) {
                   set: v => (c.value = v)
               });
               {
-                  checkDuplicateProperties("Computed" /* COMPUTED */, key);
+                  checkDuplicateProperties("Computed" /* OptionTypes.COMPUTED */, key);
               }
           }
       }
@@ -4898,7 +4914,7 @@ var VueRuntimeDOM = (function (exports) {
           });
       }
       if (created) {
-          callHook(created, instance, "c" /* CREATED */);
+          callHook(created, instance, "c" /* LifecycleHooks.CREATED */);
       }
       function registerLifecycleHook(register, hook) {
           if (isArray(hook)) {
@@ -4991,7 +5007,7 @@ var VueRuntimeDOM = (function (exports) {
               ctx[key] = injected;
           }
           {
-              checkDuplicateProperties("Inject" /* INJECT */, key);
+              checkDuplicateProperties("Inject" /* OptionTypes.INJECT */, key);
           }
       }
   }
@@ -5062,7 +5078,9 @@ var VueRuntimeDOM = (function (exports) {
           }
           mergeOptions(resolved, base, optionMergeStrategies);
       }
-      cache.set(base, resolved);
+      if (isObject(base)) {
+          cache.set(base, resolved);
+      }
       return resolved;
   }
   function mergeOptions(to, from, strats, asMixin = false) {
@@ -5191,6 +5209,13 @@ var VueRuntimeDOM = (function (exports) {
       }
       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);
@@ -5200,11 +5225,10 @@ var VueRuntimeDOM = (function (exports) {
       // 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;
@@ -5283,7 +5307,7 @@ var VueRuntimeDOM = (function (exports) {
       }
       // 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);
@@ -5352,11 +5376,11 @@ var VueRuntimeDOM = (function (exports) {
               }
           }
           // 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;
               }
@@ -5394,7 +5418,9 @@ var VueRuntimeDOM = (function (exports) {
           }
       }
       if (!raw && !hasExtends) {
-          cache.set(comp, EMPTY_ARR);
+          if (isObject(comp)) {
+              cache.set(comp, EMPTY_ARR);
+          }
           return EMPTY_ARR;
       }
       if (isArray(raw)) {
@@ -5421,8 +5447,8 @@ var VueRuntimeDOM = (function (exports) {
                   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')) {
@@ -5433,7 +5459,9 @@ var VueRuntimeDOM = (function (exports) {
           }
       }
       const res = [normalized, needCastKeys];
-      cache.set(comp, res);
+      if (isObject(comp)) {
+          cache.set(comp, res);
+      }
       return res;
   }
   function validatePropName(key) {
@@ -5643,7 +5671,7 @@ var VueRuntimeDOM = (function (exports) {
       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`,
@@ -5668,7 +5696,7 @@ var VueRuntimeDOM = (function (exports) {
       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.
@@ -5677,7 +5705,7 @@ var VueRuntimeDOM = (function (exports) {
                   // 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;
@@ -5690,7 +5718,7 @@ var VueRuntimeDOM = (function (exports) {
                   // 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._;
                   }
               }
@@ -5901,7 +5929,7 @@ var VueRuntimeDOM = (function (exports) {
           // 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;
@@ -5927,7 +5955,7 @@ var VueRuntimeDOM = (function (exports) {
           }
       }
       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);
@@ -5964,7 +5992,7 @@ var VueRuntimeDOM = (function (exports) {
                           setupState[ref] = value;
                       }
                   }
-                  else if (isRef(ref)) {
+                  else if (_isRef) {
                       ref.value = value;
                       if (rawRef.k)
                           refs[rawRef.k] = value;
@@ -5989,7 +6017,7 @@ var VueRuntimeDOM = (function (exports) {
 
   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.
@@ -6003,11 +6031,13 @@ var VueRuntimeDOM = (function (exports) {
                       `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.`);
@@ -6019,14 +6049,14 @@ var VueRuntimeDOM = (function (exports) {
           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 === '') {
@@ -6049,7 +6079,7 @@ var VueRuntimeDOM = (function (exports) {
                   }
                   break;
               case Comment:
-                  if (domType !== 8 /* COMMENT */ || isFragmentStart) {
+                  if (domType !== 8 /* DOMNodeTypes.COMMENT */ || isFragmentStart) {
                       nextNode = onMismatch();
                   }
                   else {
@@ -6057,7 +6087,7 @@ var VueRuntimeDOM = (function (exports) {
                   }
                   break;
               case Static:
-                  if (domType !== 1 /* ELEMENT */) {
+                  if (domType !== 1 /* DOMNodeTypes.ELEMENT */ && domType !== 3 /* DOMNodeTypes.TEXT */) {
                       nextNode = onMismatch();
                   }
                   else {
@@ -6068,7 +6098,10 @@ var VueRuntimeDOM = (function (exports) {
                       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;
                           }
@@ -6086,8 +6119,8 @@ var VueRuntimeDOM = (function (exports) {
                   }
                   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();
@@ -6096,7 +6129,7 @@ var VueRuntimeDOM = (function (exports) {
                           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.
@@ -6135,15 +6168,15 @@ var VueRuntimeDOM = (function (exports) {
                           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 {
@@ -6171,7 +6204,7 @@ var VueRuntimeDOM = (function (exports) {
               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))) {
@@ -6200,7 +6233,7 @@ var VueRuntimeDOM = (function (exports) {
                   }, 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);
@@ -6218,7 +6251,7 @@ var VueRuntimeDOM = (function (exports) {
                       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` +
@@ -6281,7 +6314,7 @@ var VueRuntimeDOM = (function (exports) {
       };
       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)`
@@ -6412,7 +6445,7 @@ var VueRuntimeDOM = (function (exports) {
               unmount(n1, parentComponent, parentSuspense, true);
               n1 = null;
           }
-          if (n2.patchFlag === -2 /* BAIL */) {
+          if (n2.patchFlag === -2 /* PatchFlags.BAIL */) {
               optimized = false;
               n2.dynamicChildren = null;
           }
@@ -6436,16 +6469,16 @@ var VueRuntimeDOM = (function (exports) {
                   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 {
@@ -6531,10 +6564,10 @@ var VueRuntimeDOM = (function (exports) {
               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) {
@@ -6610,7 +6643,7 @@ var VueRuntimeDOM = (function (exports) {
           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;
               }
@@ -6633,7 +6666,7 @@ var VueRuntimeDOM = (function (exports) {
           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;
@@ -6668,21 +6701,21 @@ var VueRuntimeDOM = (function (exports) {
               // 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
@@ -6691,7 +6724,7 @@ var VueRuntimeDOM = (function (exports) {
                   // 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++) {
@@ -6707,7 +6740,7 @@ var VueRuntimeDOM = (function (exports) {
               }
               // 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);
                   }
@@ -6741,7 +6774,7 @@ var VueRuntimeDOM = (function (exports) {
                       // 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.
@@ -6779,7 +6812,7 @@ var VueRuntimeDOM = (function (exports) {
           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;
@@ -6801,7 +6834,7 @@ var VueRuntimeDOM = (function (exports) {
           }
           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
@@ -6834,7 +6867,7 @@ var VueRuntimeDOM = (function (exports) {
       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 {
@@ -6996,10 +7029,10 @@ var VueRuntimeDOM = (function (exports) {
                   // 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);
                   }
                   instance.isMounted = true;
@@ -7110,7 +7143,7 @@ var VueRuntimeDOM = (function (exports) {
           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) => {
@@ -7120,22 +7153,22 @@ var VueRuntimeDOM = (function (exports) {
           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) {
@@ -7143,9 +7176,9 @@ var VueRuntimeDOM = (function (exports) {
               }
           }
           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);
                   }
@@ -7157,11 +7190,11 @@ var VueRuntimeDOM = (function (exports) {
               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);
                   }
               }
@@ -7352,7 +7385,7 @@ var VueRuntimeDOM = (function (exports) {
                       // 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--;
@@ -7363,15 +7396,15 @@ var VueRuntimeDOM = (function (exports) {
       };
       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;
           }
@@ -7388,11 +7421,11 @@ var VueRuntimeDOM = (function (exports) {
               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);
@@ -7424,42 +7457,42 @@ var VueRuntimeDOM = (function (exports) {
           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) {
@@ -7480,7 +7513,7 @@ var VueRuntimeDOM = (function (exports) {
           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 => {
@@ -7507,7 +7540,7 @@ var VueRuntimeDOM = (function (exports) {
                   transition.afterLeave();
               }
           };
-          if (vnode.shapeFlag & 1 /* ELEMENT */ &&
+          if (vnode.shapeFlag & 1 /* ShapeFlags.ELEMENT */ &&
               transition &&
               !transition.persisted) {
               const { leave, delayLeave } = transition;
@@ -7583,10 +7616,10 @@ var VueRuntimeDOM = (function (exports) {
           }
       };
       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));
@@ -7600,6 +7633,7 @@ var VueRuntimeDOM = (function (exports) {
           else {
               patch(container._vnode || null, vnode, container, null, null, null, isSVG);
           }
+          flushPreFlushCbs();
           flushPostFlushCbs();
           container._vnode = vnode;
       };
@@ -7649,8 +7683,8 @@ var VueRuntimeDOM = (function (exports) {
               // 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;
                   }
@@ -7770,7 +7804,7 @@ var VueRuntimeDOM = (function (exports) {
               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);
                   }
               };
@@ -7806,7 +7840,7 @@ var VueRuntimeDOM = (function (exports) {
                   if (!wasDisabled) {
                       // enabled -> disabled
                       // move into main container
-                      moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */);
+                      moveTeleport(n2, container, mainAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */);
                   }
               }
               else {
@@ -7814,7 +7848,7 @@ var VueRuntimeDOM = (function (exports) {
                   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})`);
@@ -7823,7 +7857,7 @@ var VueRuntimeDOM = (function (exports) {
                   else if (wasDisabled) {
                       // disabled -> enabled
                       // move into teleport target
-                      moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */);
+                      moveTeleport(n2, target, targetAnchor, internals, 1 /* TeleportMoveTypes.TOGGLE */);
                   }
               }
           }
@@ -7836,7 +7870,7 @@ var VueRuntimeDOM = (function (exports) {
           // 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);
@@ -7847,13 +7881,13 @@ var VueRuntimeDOM = (function (exports) {
       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);
@@ -7863,9 +7897,9 @@ var VueRuntimeDOM = (function (exports) {
       // 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 */);
               }
           }
       }
@@ -7880,7 +7914,7 @@ var VueRuntimeDOM = (function (exports) {
           // 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;
@@ -8002,7 +8036,7 @@ var VueRuntimeDOM = (function (exports) {
       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;
@@ -8033,7 +8067,7 @@ var VueRuntimeDOM = (function (exports) {
               : 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,
@@ -8064,7 +8098,7 @@ var VueRuntimeDOM = (function (exports) {
       if (needFullChildrenNormalization) {
           normalizeChildren(vnode, children);
           // normalize suspense children
-          if (shapeFlag & 128 /* SUSPENSE */) {
+          if (shapeFlag & 128 /* ShapeFlags.SUSPENSE */) {
               type.normalize(vnode);
           }
       }
@@ -8072,8 +8106,8 @@ var VueRuntimeDOM = (function (exports) {
           // 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) {
@@ -8089,10 +8123,10 @@ var VueRuntimeDOM = (function (exports) {
           // 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);
       }
       return vnode;
@@ -8114,14 +8148,14 @@ var VueRuntimeDOM = (function (exports) {
               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.
@@ -8147,17 +8181,17 @@ var VueRuntimeDOM = (function (exports) {
       }
       // 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 ` +
@@ -8196,7 +8230,7 @@ var VueRuntimeDOM = (function (exports) {
               : 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,
@@ -8209,8 +8243,8 @@ var VueRuntimeDOM = (function (exports) {
           // 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,
@@ -8300,10 +8334,10 @@ var VueRuntimeDOM = (function (exports) {
           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) {
@@ -8315,37 +8349,37 @@ var VueRuntimeDOM = (function (exports) {
               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;
@@ -8383,7 +8417,7 @@ var VueRuntimeDOM = (function (exports) {
       return ret;
   }
   function invokeVNodeHook(hook, instance, vnode, prevVNode = null) {
-      callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [
+      callWithAsyncErrorHandling(hook, instance, 7 /* ErrorCodes.VNODE_HOOK */, [
           vnode,
           prevVNode
       ]);
@@ -8491,7 +8525,7 @@ var VueRuntimeDOM = (function (exports) {
       }
   }
   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) {
@@ -8546,7 +8580,7 @@ var VueRuntimeDOM = (function (exports) {
               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)) {
@@ -8558,7 +8592,7 @@ var VueRuntimeDOM = (function (exports) {
                       handleSetupResult(instance, resolvedResult, isSSR);
                   })
                       .catch(e => {
-                      handleError(e, instance, 0 /* SETUP_FUNCTION */);
+                      handleError(e, instance, 0 /* ErrorCodes.SETUP_FUNCTION */);
                   });
               }
               else {
@@ -8633,7 +8667,8 @@ var VueRuntimeDOM = (function (exports) {
           // only do on-the-fly compile if not in SSR - SSR on-the-fly compilation
           // is done by server-renderer
           if (!isSSR && compile && !Component.render) {
-              const template = Component.template;
+              const template = Component.template ||
+                  resolveMergedOptions(instance).template;
               if (template) {
                   {
                       startMeasure(instance, `compile`);
@@ -8685,7 +8720,7 @@ var VueRuntimeDOM = (function (exports) {
       return new Proxy(instance.attrs, {
               get(target, key) {
                   markAttrsAccessed();
-                  track(instance, "get" /* GET */, '$attrs');
+                  track(instance, "get" /* TrackOpTypes.GET */, '$attrs');
                   return target[key];
               },
               set() {
@@ -8741,10 +8776,10 @@ var VueRuntimeDOM = (function (exports) {
   }
   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) {
@@ -9183,9 +9218,9 @@ var VueRuntimeDOM = (function (exports) {
   }
 
   // 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);
@@ -9550,7 +9585,8 @@ var VueRuntimeDOM = (function (exports) {
               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) => {
@@ -9562,7 +9598,7 @@ var VueRuntimeDOM = (function (exports) {
           // 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;
@@ -9905,7 +9941,7 @@ var VueRuntimeDOM = (function (exports) {
       });
   }
   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) {
@@ -9918,7 +9954,7 @@ var VueRuntimeDOM = (function (exports) {
       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) {