@vue/compat 3.3.9 → 3.4.0-alpha.2

package/dist/vue.global.js

@@ -2,12 +2,8 @@ var Vue = (function () {
   'use strict';
 
   function makeMap(str, expectsLowerCase) {
-    const map = /* @__PURE__ */ Object.create(null);
-    const list = str.split(",");
-    for (let i = 0; i < list.length; i++) {
-      map[list[i]] = true;
-    }
-    return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val];
+    const set = new Set(str.split(","));
+    return expectsLowerCase ? (val) => set.has(val.toLowerCase()) : (val) => set.has(val);
   }
 
   const EMPTY_OBJ = Object.freeze({}) ;
@@ -422,117 +418,120 @@ var Vue = (function () {
     }
   }
 
-  const createDep = (effects) => {
-    const dep = new Set(effects);
-    dep.w = 0;
-    dep.n = 0;
-    return dep;
-  };
-  const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
-  const newTracked = (dep) => (dep.n & trackOpBit) > 0;
-  const initDepMarkers = ({ deps }) => {
-    if (deps.length) {
-      for (let i = 0; i < deps.length; i++) {
-        deps[i].w |= trackOpBit;
-      }
-    }
-  };
-  const finalizeDepMarkers = (effect) => {
-    const { deps } = effect;
-    if (deps.length) {
-      let ptr = 0;
-      for (let i = 0; i < deps.length; i++) {
-        const dep = deps[i];
-        if (wasTracked(dep) && !newTracked(dep)) {
-          dep.delete(effect);
-        } else {
-          deps[ptr++] = dep;
-        }
-        dep.w &= ~trackOpBit;
-        dep.n &= ~trackOpBit;
-      }
-      deps.length = ptr;
-    }
-  };
-
-  const targetMap = /* @__PURE__ */ new WeakMap();
-  let effectTrackDepth = 0;
-  let trackOpBit = 1;
-  const maxMarkerBits = 30;
   let activeEffect;
-  const ITERATE_KEY = Symbol("iterate" );
-  const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate" );
   class ReactiveEffect {
-    constructor(fn, scheduler = null, scope) {
+    constructor(fn, trigger, scheduler, scope) {
       this.fn = fn;
+      this.trigger = trigger;
       this.scheduler = scheduler;
       this.active = true;
       this.deps = [];
-      this.parent = void 0;
+      /**
+       * @internal
+       */
+      this._dirtyLevel = 3;
+      /**
+       * @internal
+       */
+      this._trackId = 0;
+      /**
+       * @internal
+       */
+      this._runnings = 0;
+      /**
+       * @internal
+       */
+      this._queryings = 0;
+      /**
+       * @internal
+       */
+      this._depsLength = 0;
       recordEffectScope(this, scope);
     }
+    get dirty() {
+      if (this._dirtyLevel === 1) {
+        this._dirtyLevel = 0;
+        this._queryings++;
+        pauseTracking();
+        for (const dep of this.deps) {
+          if (dep.computed) {
+            triggerComputed(dep.computed);
+            if (this._dirtyLevel >= 2) {
+              break;
+            }
+          }
+        }
+        resetTracking();
+        this._queryings--;
+      }
+      return this._dirtyLevel >= 2;
+    }
+    set dirty(v) {
+      this._dirtyLevel = v ? 3 : 0;
+    }
     run() {
+      this._dirtyLevel = 0;
       if (!this.active) {
         return this.fn();
       }
-      let parent = activeEffect;
       let lastShouldTrack = shouldTrack;
-      while (parent) {
-        if (parent === this) {
-          return;
-        }
-        parent = parent.parent;
-      }
+      let lastEffect = activeEffect;
       try {
-        this.parent = activeEffect;
-        activeEffect = this;
         shouldTrack = true;
-        trackOpBit = 1 << ++effectTrackDepth;
-        if (effectTrackDepth <= maxMarkerBits) {
-          initDepMarkers(this);
-        } else {
-          cleanupEffect(this);
-        }
+        activeEffect = this;
+        this._runnings++;
+        preCleanupEffect(this);
         return this.fn();
       } finally {
-        if (effectTrackDepth <= maxMarkerBits) {
-          finalizeDepMarkers(this);
-        }
-        trackOpBit = 1 << --effectTrackDepth;
-        activeEffect = this.parent;
+        postCleanupEffect(this);
+        this._runnings--;
+        activeEffect = lastEffect;
         shouldTrack = lastShouldTrack;
-        this.parent = void 0;
-        if (this.deferStop) {
-          this.stop();
-        }
       }
     }
     stop() {
-      if (activeEffect === this) {
-        this.deferStop = true;
-      } else if (this.active) {
-        cleanupEffect(this);
-        if (this.onStop) {
-          this.onStop();
-        }
+      var _a;
+      if (this.active) {
+        preCleanupEffect(this);
+        postCleanupEffect(this);
+        (_a = this.onStop) == null ? void 0 : _a.call(this);
         this.active = false;
       }
     }
   }
-  function cleanupEffect(effect2) {
-    const { deps } = effect2;
-    if (deps.length) {
-      for (let i = 0; i < deps.length; i++) {
-        deps[i].delete(effect2);
+  function triggerComputed(computed) {
+    return computed.value;
+  }
+  function preCleanupEffect(effect2) {
+    effect2._trackId++;
+    effect2._depsLength = 0;
+  }
+  function postCleanupEffect(effect2) {
+    if (effect2.deps && effect2.deps.length > effect2._depsLength) {
+      for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
+        cleanupDepEffect(effect2.deps[i], effect2);
+      }
+      effect2.deps.length = effect2._depsLength;
+    }
+  }
+  function cleanupDepEffect(dep, effect2) {
+    const trackId = dep.get(effect2);
+    if (trackId !== void 0 && effect2._trackId !== trackId) {
+      dep.delete(effect2);
+      if (dep.size === 0) {
+        dep.cleanup();
       }
-      deps.length = 0;
     }
   }
   function effect(fn, options) {
     if (fn.effect instanceof ReactiveEffect) {
       fn = fn.effect.fn;
     }
-    const _effect = new ReactiveEffect(fn);
+    const _effect = new ReactiveEffect(fn, NOOP, () => {
+      if (_effect.dirty) {
+        _effect.run();
+      }
+    });
     if (options) {
       extend(_effect, options);
       if (options.scope)
@@ -549,6 +548,7 @@ var Vue = (function () {
     runner.effect.stop();
   }
   let shouldTrack = true;
+  let pauseScheduleStack = 0;
   const trackStack = [];
   function pauseTracking() {
     trackStack.push(shouldTrack);
@@ -558,6 +558,68 @@ var Vue = (function () {
     const last = trackStack.pop();
     shouldTrack = last === void 0 ? true : last;
   }
+  function pauseScheduling() {
+    pauseScheduleStack++;
+  }
+  function resetScheduling() {
+    pauseScheduleStack--;
+    while (!pauseScheduleStack && queueEffectSchedulers.length) {
+      queueEffectSchedulers.shift()();
+    }
+  }
+  function trackEffect(effect2, dep, debuggerEventExtraInfo) {
+    var _a;
+    if (dep.get(effect2) !== effect2._trackId) {
+      dep.set(effect2, effect2._trackId);
+      const oldDep = effect2.deps[effect2._depsLength];
+      if (oldDep !== dep) {
+        if (oldDep) {
+          cleanupDepEffect(oldDep, effect2);
+        }
+        effect2.deps[effect2._depsLength++] = dep;
+      } else {
+        effect2._depsLength++;
+      }
+      {
+        (_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+      }
+    }
+  }
+  const queueEffectSchedulers = [];
+  function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
+    var _a;
+    pauseScheduling();
+    for (const effect2 of dep.keys()) {
+      if (!effect2.allowRecurse && effect2._runnings) {
+        continue;
+      }
+      if (effect2._dirtyLevel < dirtyLevel && (!effect2._runnings || dirtyLevel !== 2)) {
+        const lastDirtyLevel = effect2._dirtyLevel;
+        effect2._dirtyLevel = dirtyLevel;
+        if (lastDirtyLevel === 0 && (!effect2._queryings || dirtyLevel !== 2)) {
+          {
+            (_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
+          }
+          effect2.trigger();
+          if (effect2.scheduler) {
+            queueEffectSchedulers.push(effect2.scheduler);
+          }
+        }
+      }
+    }
+    resetScheduling();
+  }
+
+  const createDep = (cleanup, computed) => {
+    const dep = /* @__PURE__ */ new Map();
+    dep.cleanup = cleanup;
+    dep.computed = computed;
+    return dep;
+  };
+
+  const targetMap = /* @__PURE__ */ new WeakMap();
+  const ITERATE_KEY = Symbol("iterate" );
+  const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate" );
   function track(target, type, key) {
     if (shouldTrack && activeEffect) {
       let depsMap = targetMap.get(target);
@@ -566,35 +628,17 @@ var Vue = (function () {
       }
       let dep = depsMap.get(key);
       if (!dep) {
-        depsMap.set(key, dep = createDep());
-      }
-      const eventInfo = { effect: activeEffect, target, type, key } ;
-      trackEffects(dep, eventInfo);
-    }
-  }
-  function trackEffects(dep, debuggerEventExtraInfo) {
-    let shouldTrack2 = false;
-    if (effectTrackDepth <= maxMarkerBits) {
-      if (!newTracked(dep)) {
-        dep.n |= trackOpBit;
-        shouldTrack2 = !wasTracked(dep);
-      }
-    } else {
-      shouldTrack2 = !dep.has(activeEffect);
-    }
-    if (shouldTrack2) {
-      dep.add(activeEffect);
-      activeEffect.deps.push(dep);
-      if (activeEffect.onTrack) {
-        activeEffect.onTrack(
-          extend(
-            {
-              effect: activeEffect
-            },
-            debuggerEventExtraInfo
-          )
-        );
+        depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
       }
+      trackEffect(
+        activeEffect,
+        dep,
+        {
+          target,
+          type,
+          key
+        } 
+      );
     }
   }
   function trigger(target, type, key, newValue, oldValue, oldTarget) {
@@ -642,49 +686,24 @@ var Vue = (function () {
           break;
       }
     }
-    const eventInfo = { target, type, key, newValue, oldValue, oldTarget } ;
-    if (deps.length === 1) {
-      if (deps[0]) {
-        {
-          triggerEffects(deps[0], eventInfo);
-        }
-      }
-    } else {
-      const effects = [];
-      for (const dep of deps) {
-        if (dep) {
-          effects.push(...dep);
-        }
-      }
-      {
-        triggerEffects(createDep(effects), eventInfo);
-      }
-    }
-  }
-  function triggerEffects(dep, debuggerEventExtraInfo) {
-    const effects = isArray(dep) ? dep : [...dep];
-    for (const effect2 of effects) {
-      if (effect2.computed) {
-        triggerEffect(effect2, debuggerEventExtraInfo);
-      }
-    }
-    for (const effect2 of effects) {
-      if (!effect2.computed) {
-        triggerEffect(effect2, debuggerEventExtraInfo);
-      }
-    }
-  }
-  function triggerEffect(effect2, debuggerEventExtraInfo) {
-    if (effect2 !== activeEffect || effect2.allowRecurse) {
-      if (effect2.onTrigger) {
-        effect2.onTrigger(extend({ effect: effect2 }, debuggerEventExtraInfo));
-      }
-      if (effect2.scheduler) {
-        effect2.scheduler();
-      } else {
-        effect2.run();
+    pauseScheduling();
+    for (const dep of deps) {
+      if (dep) {
+        triggerEffects(
+          dep,
+          3,
+          {
+            target,
+            type,
+            key,
+            newValue,
+            oldValue,
+            oldTarget
+          } 
+        );
       }
     }
+    resetScheduling();
   }
   function getDepFromReactive(object, key) {
     var _a;
@@ -715,7 +734,9 @@ var Vue = (function () {
     ["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
       instrumentations[key] = function(...args) {
         pauseTracking();
+        pauseScheduling();
         const res = toRaw(this)[key].apply(this, args);
+        resetScheduling();
         resetTracking();
         return res;
       };
@@ -1254,30 +1275,94 @@ var Vue = (function () {
   const toReactive = (value) => isObject(value) ? reactive(value) : value;
   const toReadonly = (value) => isObject(value) ? readonly(value) : value;
 
+  class ComputedRefImpl {
+    constructor(getter, _setter, isReadonly, isSSR) {
+      this._setter = _setter;
+      this.dep = void 0;
+      this.__v_isRef = true;
+      this["__v_isReadonly"] = false;
+      this.effect = new ReactiveEffect(
+        () => getter(this._value),
+        () => triggerRefValue(this, 1)
+      );
+      this.effect.computed = this;
+      this.effect.active = this._cacheable = !isSSR;
+      this["__v_isReadonly"] = isReadonly;
+    }
+    get value() {
+      const self = toRaw(this);
+      trackRefValue(self);
+      if (!self._cacheable || self.effect.dirty) {
+        if (hasChanged(self._value, self._value = self.effect.run())) {
+          triggerRefValue(self, 2);
+        }
+      }
+      return self._value;
+    }
+    set value(newValue) {
+      this._setter(newValue);
+    }
+    // #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
+    get _dirty() {
+      return this.effect.dirty;
+    }
+    set _dirty(v) {
+      this.effect.dirty = v;
+    }
+    // #endregion
+  }
+  function computed$1(getterOrOptions, debugOptions, isSSR = false) {
+    let getter;
+    let setter;
+    const onlyGetter = isFunction(getterOrOptions);
+    if (onlyGetter) {
+      getter = getterOrOptions;
+      setter = () => {
+        console.warn("Write operation failed: computed value is readonly");
+      } ;
+    } else {
+      getter = getterOrOptions.get;
+      setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+    if (debugOptions && !isSSR) {
+      cRef.effect.onTrack = debugOptions.onTrack;
+      cRef.effect.onTrigger = debugOptions.onTrigger;
+    }
+    return cRef;
+  }
+
   function trackRefValue(ref2) {
     if (shouldTrack && activeEffect) {
       ref2 = toRaw(ref2);
-      {
-        trackEffects(ref2.dep || (ref2.dep = createDep()), {
+      trackEffect(
+        activeEffect,
+        ref2.dep || (ref2.dep = createDep(
+          () => ref2.dep = void 0,
+          ref2 instanceof ComputedRefImpl ? ref2 : void 0
+        )),
+        {
           target: ref2,
           type: "get",
           key: "value"
-        });
-      }
+        } 
+      );
     }
   }
-  function triggerRefValue(ref2, newVal) {
+  function triggerRefValue(ref2, dirtyLevel = 3, newVal) {
     ref2 = toRaw(ref2);
     const dep = ref2.dep;
     if (dep) {
-      {
-        triggerEffects(dep, {
+      triggerEffects(
+        dep,
+        dirtyLevel,
+        {
           target: ref2,
           type: "set",
           key: "value",
           newValue: newVal
-        });
-      }
+        } 
+      );
     }
   }
   function isRef(r) {
@@ -1313,12 +1398,12 @@ var Vue = (function () {
       if (hasChanged(newVal, this._rawValue)) {
         this._rawValue = newVal;
         this._value = useDirectValue ? newVal : toReactive(newVal);
-        triggerRefValue(this, newVal);
+        triggerRefValue(this, 3, newVal);
       }
     }
   }
   function triggerRef(ref2) {
-    triggerRefValue(ref2, ref2.value );
+    triggerRefValue(ref2, 3, ref2.value );
   }
   function unref(ref2) {
     return isRef(ref2) ? ref2.value : ref2;
@@ -1416,67 +1501,16 @@ var Vue = (function () {
     return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
   }
 
-  class ComputedRefImpl {
-    constructor(getter, _setter, isReadonly, isSSR) {
-      this._setter = _setter;
-      this.dep = void 0;
-      this.__v_isRef = true;
-      this["__v_isReadonly"] = false;
-      this._dirty = true;
-      this.effect = new ReactiveEffect(getter, () => {
-        if (!this._dirty) {
-          this._dirty = true;
-          triggerRefValue(this);
-        }
-      });
-      this.effect.computed = this;
-      this.effect.active = this._cacheable = !isSSR;
-      this["__v_isReadonly"] = isReadonly;
-    }
-    get value() {
-      const self = toRaw(this);
-      trackRefValue(self);
-      if (self._dirty || !self._cacheable) {
-        self._dirty = false;
-        self._value = self.effect.run();
-      }
-      return self._value;
-    }
-    set value(newValue) {
-      this._setter(newValue);
-    }
-  }
-  function computed$1(getterOrOptions, debugOptions, isSSR = false) {
-    let getter;
-    let setter;
-    const onlyGetter = isFunction(getterOrOptions);
-    if (onlyGetter) {
-      getter = getterOrOptions;
-      setter = () => {
-        console.warn("Write operation failed: computed value is readonly");
-      } ;
-    } else {
-      getter = getterOrOptions.get;
-      setter = getterOrOptions.set;
-    }
-    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
-    if (debugOptions && !isSSR) {
-      cRef.effect.onTrack = debugOptions.onTrack;
-      cRef.effect.onTrigger = debugOptions.onTrigger;
-    }
-    return cRef;
-  }
-
-  const stack = [];
+  const stack$1 = [];
   function pushWarningContext(vnode) {
-    stack.push(vnode);
+    stack$1.push(vnode);
   }
   function popWarningContext() {
-    stack.pop();
+    stack$1.pop();
   }
   function warn(msg, ...args) {
     pauseTracking();
-    const instance = stack.length ? stack[stack.length - 1].component : null;
+    const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
     const appWarnHandler = instance && instance.appContext.config.warnHandler;
     const trace = getComponentTrace();
     if (appWarnHandler) {
@@ -1505,7 +1539,7 @@ var Vue = (function () {
     resetTracking();
   }
   function getComponentTrace() {
-    let currentVNode = stack[stack.length - 1];
+    let currentVNode = stack$1[stack$1.length - 1];
     if (!currentVNode) {
       return [];
     }
@@ -1581,7 +1615,7 @@ var Vue = (function () {
     }
   }
 
-  const ErrorTypeStrings = {
+  const ErrorTypeStrings$1 = {
     ["sp"]: "serverPrefetch hook",
     ["bc"]: "beforeCreate hook",
     ["c"]: "created hook",
@@ -1642,7 +1676,7 @@ var Vue = (function () {
     if (instance) {
       let cur = instance.parent;
       const exposedInstance = instance.proxy;
-      const errorInfo = ErrorTypeStrings[type] ;
+      const errorInfo = ErrorTypeStrings$1[type] ;
       while (cur) {
         const errorCapturedHooks = cur.ec;
         if (errorCapturedHooks) {
@@ -1669,7 +1703,7 @@ var Vue = (function () {
   }
   function logError(err, type, contextVNode, throwInDev = true) {
     {
-      const info = ErrorTypeStrings[type];
+      const info = ErrorTypeStrings$1[type];
       if (contextVNode) {
         pushWarningContext(contextVNode);
       }
@@ -1897,6 +1931,7 @@ var Vue = (function () {
       }
       instance.renderCache = [];
       isHmrUpdating = true;
+      instance.effect.dirty = true;
       instance.update();
       isHmrUpdating = false;
     });
@@ -1924,6 +1959,7 @@ var Vue = (function () {
         instance.ceReload(newComp.styles);
         hmrDirtyComponents.delete(oldComp);
       } else if (instance.parent) {
+        instance.parent.effect.dirty = true;
         queueJob(instance.parent.update);
       } else if (instance.appContext.reload) {
         instance.appContext.reload();
@@ -3688,8 +3724,15 @@ If this is a native custom element, make sure to exclude it from component resol
     }
     return doWatch(source, cb, options);
   }
-  function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) {
+  function doWatch(source, cb, { immediate, deep, flush, once, onTrack, onTrigger } = EMPTY_OBJ) {
     var _a;
+    if (cb && once) {
+      const _cb = cb;
+      cb = (...args) => {
+        _cb(...args);
+        unwatch();
+      };
+    }
     if (!cb) {
       if (immediate !== void 0) {
         warn(
@@ -3701,6 +3744,11 @@ If this is a native custom element, make sure to exclude it from component resol
           `watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
         );
       }
+      if (once !== void 0) {
+        warn(
+          `watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
+        );
+      }
     }
     const warnInvalidSource = (s) => {
       warn(
@@ -3779,7 +3827,7 @@ If this is a native custom element, make sure to exclude it from component resol
     };
     let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
     const job = () => {
-      if (!effect.active) {
+      if (!effect.active || !effect.dirty) {
         return;
       }
       if (cb) {
@@ -3812,7 +3860,13 @@ If this is a native custom element, make sure to exclude it from component resol
         job.id = instance.uid;
       scheduler = () => queueJob(job);
     }
-    const effect = new ReactiveEffect(getter, scheduler);
+    const effect = new ReactiveEffect(getter, NOOP, scheduler);
+    const unwatch = () => {
+      effect.stop();
+      if (instance && instance.scope) {
+        remove(instance.scope.effects, effect);
+      }
+    };
     {
       effect.onTrack = onTrack;
       effect.onTrigger = onTrigger;
@@ -3831,12 +3885,6 @@ If this is a native custom element, make sure to exclude it from component resol
     } else {
       effect.run();
     }
-    const unwatch = () => {
-      effect.stop();
-      if (instance && instance.scope) {
-        remove(instance.scope.effects, effect);
-      }
-    };
     return unwatch;
   }
   function instanceWatch(source, value, options) {
@@ -4069,6 +4117,7 @@ If this is a native custom element, make sure to exclude it from component resol
             leavingHooks.afterLeave = () => {
               state.isLeaving = false;
               if (instance.update.active !== false) {
+                instance.effect.dirty = true;
                 instance.update();
               }
             };
@@ -4411,6 +4460,7 @@ If this is a native custom element, make sure to exclude it from component resol
         load().then(() => {
           loaded.value = true;
           if (instance.parent && isKeepAlive(instance.parent.vnode)) {
+            instance.parent.effect.dirty = true;
             queueJob(instance.parent.update);
           }
         }).catch((err) => {
@@ -4708,7 +4758,7 @@ If this is a native custom element, make sure to exclude it from component resol
       }
       return wrappedHook;
     } else {
-      const apiName = toHandlerKey(ErrorTypeStrings[type].replace(/ hook$/, ""));
+      const apiName = toHandlerKey(ErrorTypeStrings$1[type].replace(/ hook$/, ""));
       warn(
         `${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().` + (` If you are using async setup(), make sure to register lifecycle hooks before the first await statement.` )
       );
@@ -5371,7 +5421,10 @@ If this is a native custom element, make sure to exclude it from component resol
       $root: (i) => getPublicInstance(i.root),
       $emit: (i) => i.emit,
       $options: (i) => resolveMergedOptions(i) ,
-      $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)),
+      $forceUpdate: (i) => i.f || (i.f = () => {
+        i.effect.dirty = true;
+        queueJob(i.update);
+      }),
       $nextTick: (i) => i.n || (i.n = nextTick.bind(i.proxy)),
       $watch: (i) => instanceWatch.bind(i) 
     })
@@ -6272,7 +6325,7 @@ If this is a native custom element, make sure to exclude it from component resol
         return vm;
       }
     }
-    Vue.version = `2.6.14-compat:${"3.3.9"}`;
+    Vue.version = `2.6.14-compat:${"3.4.0-alpha.2"}`;
     Vue.config = singletonApp.config;
     Vue.use = (p, ...options) => {
       if (p && isFunction(p.install)) {
@@ -8695,6 +8748,7 @@ If you want to remount the same app, move your app creation logic into a factory
         } else {
           instance.next = n2;
           invalidateJob(instance.update);
+          instance.effect.dirty = true;
           instance.update();
         }
       } else {
@@ -8888,11 +8942,16 @@ If you want to remount the same app, move your app creation logic into a factory
       };
       const effect = instance.effect = new ReactiveEffect(
         componentUpdateFn,
+        NOOP,
         () => queueJob(update),
         instance.scope
         // track it in component's effect scope
       );
-      const update = instance.update = () => effect.run();
+      const update = instance.update = () => {
+        if (effect.dirty) {
+          effect.run();
+        }
+      };
       update.id = instance.uid;
       toggleRecurse(instance, true);
       {
@@ -10859,7 +10918,8 @@ Component that was made reactive: `,
     return true;
   }
 
-  const version = "3.3.9";
+  const version = "3.4.0-alpha.2";
+  const ErrorTypeStrings = ErrorTypeStrings$1 ;
   const ssrUtils = null;
   const resolveFilter = resolveFilter$1 ;
   const _compatUtils = {
@@ -12482,6 +12542,7 @@ Component that was made reactive: `,
     BaseTransitionPropsValidators: BaseTransitionPropsValidators,
     Comment: Comment,
     EffectScope: EffectScope,
+    ErrorTypeStrings: ErrorTypeStrings,
     Fragment: Fragment,
     KeepAlive: KeepAlive,
     ReactiveEffect: ReactiveEffect,
@@ -12665,83 +12726,6 @@ Make sure to use the production build (*.prod.js) when deploying for production.
     return Vue;
   }
 
-  function defaultOnError(error) {
-    throw error;
-  }
-  function defaultOnWarn(msg) {
-    console.warn(`[Vue warn] ${msg.message}`);
-  }
-  function createCompilerError(code, loc, messages, additionalMessage) {
-    const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
-    const error = new SyntaxError(String(msg));
-    error.code = code;
-    error.loc = loc;
-    return error;
-  }
-  const errorMessages = {
-    // parse errors
-    [0]: "Illegal comment.",
-    [1]: "CDATA section is allowed only in XML context.",
-    [2]: "Duplicate attribute.",
-    [3]: "End tag cannot have attributes.",
-    [4]: "Illegal '/' in tags.",
-    [5]: "Unexpected EOF in tag.",
-    [6]: "Unexpected EOF in CDATA section.",
-    [7]: "Unexpected EOF in comment.",
-    [8]: "Unexpected EOF in script.",
-    [9]: "Unexpected EOF in tag.",
-    [10]: "Incorrectly closed comment.",
-    [11]: "Incorrectly opened comment.",
-    [12]: "Illegal tag name. Use '&lt;' to print '<'.",
-    [13]: "Attribute value was expected.",
-    [14]: "End tag name was expected.",
-    [15]: "Whitespace was expected.",
-    [16]: "Unexpected '<!--' in comment.",
-    [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
-    [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
-    [19]: "Attribute name cannot start with '='.",
-    [21]: "'<?' is allowed only in XML context.",
-    [20]: `Unexpected null character.`,
-    [22]: "Illegal '/' in tags.",
-    // Vue-specific parse errors
-    [23]: "Invalid end tag.",
-    [24]: "Element is missing end tag.",
-    [25]: "Interpolation end sign was not found.",
-    [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
-    [26]: "Legal directive name was expected.",
-    // transform errors
-    [28]: `v-if/v-else-if is missing expression.`,
-    [29]: `v-if/else branches must use unique keys.`,
-    [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
-    [31]: `v-for is missing expression.`,
-    [32]: `v-for has invalid expression.`,
-    [33]: `<template v-for> key should be placed on the <template> tag.`,
-    [34]: `v-bind is missing expression.`,
-    [35]: `v-on is missing expression.`,
-    [36]: `Unexpected custom directive on <slot> outlet.`,
-    [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
-    [38]: `Duplicate slot names found. `,
-    [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
-    [40]: `v-slot can only be used on components or <template> tags.`,
-    [41]: `v-model is missing expression.`,
-    [42]: `v-model value must be a valid JavaScript member expression.`,
-    [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
-    [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
-Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
-    [45]: `Error parsing JavaScript expression: `,
-    [46]: `<KeepAlive> expects exactly one child component.`,
-    // generic errors
-    [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
-    [48]: `ES module mode is not supported in this build of compiler.`,
-    [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
-    [50]: `"scopeId" option is only supported in module mode.`,
-    // deprecations
-    [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
-    [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
-    // just to fulfill types
-    [53]: ``
-  };
-
   const FRAGMENT = Symbol(`Fragment` );
   const TELEPORT = Symbol(`Teleport` );
   const SUSPENSE = Symbol(`Suspense` );
@@ -12831,13 +12815,14 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   }
 
   const locStub = {
-    source: "",
     start: { line: 1, column: 1, offset: 0 },
-    end: { line: 1, column: 1, offset: 0 }
+    end: { line: 1, column: 1, offset: 0 },
+    source: ""
   };
-  function createRoot(children, loc = locStub) {
+  function createRoot(children, source = "") {
     return {
       type: 0,
+      source,
       children,
       helpers: /* @__PURE__ */ new Set(),
       components: [],
@@ -12847,7 +12832,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       cached: 0,
       temps: 0,
       codegenNode: void 0,
-      loc
+      loc: locStub
     };
   }
   function createVNodeCall(context, tag, props, children, patchFlag, dynamicProps, directives, isBlock = false, disableTracking = false, isComponent = false, loc = locStub) {
@@ -12973,268 +12958,809 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     }
   }
 
-  const isStaticExp = (p) => p.type === 4 && p.isStatic;
-  const isBuiltInType = (tag, expected) => tag === expected || tag === hyphenate(expected);
-  function isCoreComponent(tag) {
-    if (isBuiltInType(tag, "Teleport")) {
-      return TELEPORT;
-    } else if (isBuiltInType(tag, "Suspense")) {
-      return SUSPENSE;
-    } else if (isBuiltInType(tag, "KeepAlive")) {
-      return KEEP_ALIVE;
-    } else if (isBuiltInType(tag, "BaseTransition")) {
-      return BASE_TRANSITION;
-    }
+  const defaultDelimitersOpen = new Uint8Array([123, 123]);
+  const defaultDelimitersClose = new Uint8Array([125, 125]);
+  function isTagStartChar(c) {
+    return c >= 97 && c <= 122 || c >= 65 && c <= 90;
   }
-  const nonIdentifierRE = /^\d|[^\$\w]/;
-  const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
-  const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
-  const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
-  const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
-  const isMemberExpressionBrowser = (path) => {
-    path = path.trim().replace(whitespaceRE, (s) => s.trim());
-    let state = 0 /* inMemberExp */;
-    let stateStack = [];
-    let currentOpenBracketCount = 0;
-    let currentOpenParensCount = 0;
-    let currentStringType = null;
-    for (let i = 0; i < path.length; i++) {
-      const char = path.charAt(i);
-      switch (state) {
-        case 0 /* inMemberExp */:
-          if (char === "[") {
-            stateStack.push(state);
-            state = 1 /* inBrackets */;
-            currentOpenBracketCount++;
-          } else if (char === "(") {
-            stateStack.push(state);
-            state = 2 /* inParens */;
-            currentOpenParensCount++;
-          } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
-            return false;
-          }
-          break;
-        case 1 /* inBrackets */:
-          if (char === `'` || char === `"` || char === "`") {
-            stateStack.push(state);
-            state = 3 /* inString */;
-            currentStringType = char;
-          } else if (char === `[`) {
-            currentOpenBracketCount++;
-          } else if (char === `]`) {
-            if (!--currentOpenBracketCount) {
-              state = stateStack.pop();
-            }
-          }
-          break;
-        case 2 /* inParens */:
-          if (char === `'` || char === `"` || char === "`") {
-            stateStack.push(state);
-            state = 3 /* inString */;
-            currentStringType = char;
-          } else if (char === `(`) {
-            currentOpenParensCount++;
-          } else if (char === `)`) {
-            if (i === path.length - 1) {
-              return false;
-            }
-            if (!--currentOpenParensCount) {
-              state = stateStack.pop();
-            }
-          }
-          break;
-        case 3 /* inString */:
-          if (char === currentStringType) {
-            state = stateStack.pop();
-            currentStringType = null;
-          }
-          break;
-      }
-    }
-    return !currentOpenBracketCount && !currentOpenParensCount;
-  };
-  const isMemberExpression = isMemberExpressionBrowser ;
-  function getInnerRange(loc, offset, length) {
-    const source = loc.source.slice(offset, offset + length);
-    const newLoc = {
-      source,
-      start: advancePositionWithClone(loc.start, loc.source, offset),
-      end: loc.end
-    };
-    if (length != null) {
-      newLoc.end = advancePositionWithClone(
-        loc.start,
-        loc.source,
-        offset + length
-      );
-    }
-    return newLoc;
+  function isWhitespace(c) {
+    return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
   }
-  function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
-    return advancePositionWithMutation(
-      extend({}, pos),
-      source,
-      numberOfCharacters
-    );
+  function isEndOfTagSection(c) {
+    return c === 47 || c === 62 || isWhitespace(c);
   }
-  function advancePositionWithMutation(pos, source, numberOfCharacters = source.length) {
-    let linesCount = 0;
-    let lastNewLinePos = -1;
-    for (let i = 0; i < numberOfCharacters; i++) {
-      if (source.charCodeAt(i) === 10) {
-        linesCount++;
-        lastNewLinePos = i;
-      }
+  function toCharCodes(str) {
+    const ret = new Uint8Array(str.length);
+    for (let i = 0; i < str.length; i++) {
+      ret[i] = str.charCodeAt(i);
     }
-    pos.offset += numberOfCharacters;
-    pos.line += linesCount;
-    pos.column = lastNewLinePos === -1 ? pos.column + numberOfCharacters : numberOfCharacters - lastNewLinePos;
-    return pos;
+    return ret;
   }
-  function assert(condition, msg) {
-    if (!condition) {
-      throw new Error(msg || `unexpected compiler condition`);
+  const Sequences = {
+    Cdata: new Uint8Array([67, 68, 65, 84, 65, 91]),
+    // CDATA[
+    CdataEnd: new Uint8Array([93, 93, 62]),
+    // ]]>
+    CommentEnd: new Uint8Array([45, 45, 62]),
+    // `-->`
+    ScriptEnd: new Uint8Array([60, 47, 115, 99, 114, 105, 112, 116]),
+    // `<\/script`
+    StyleEnd: new Uint8Array([60, 47, 115, 116, 121, 108, 101]),
+    // `</style`
+    TitleEnd: new Uint8Array([60, 47, 116, 105, 116, 108, 101]),
+    // `</title`
+    TextareaEnd: new Uint8Array([
+      60,
+      47,
+      116,
+      101,
+      120,
+      116,
+      97,
+      114,
+      101,
+      97
+    ])
+    // `</textarea
+  };
+  class Tokenizer {
+    constructor(stack, cbs) {
+      this.stack = stack;
+      this.cbs = cbs;
+      /** The current state the tokenizer is in. */
+      this.state = 1;
+      /** The read buffer. */
+      this.buffer = "";
+      /** The beginning of the section that is currently being read. */
+      this.sectionStart = 0;
+      /** The index within the buffer that we are currently looking at. */
+      this.index = 0;
+      /** The start of the last entity. */
+      this.entityStart = 0;
+      /** Some behavior, eg. when decoding entities, is done while we are in another state. This keeps track of the other state type. */
+      this.baseState = 1;
+      /** For special parsing behavior inside of script and style tags. */
+      this.inRCDATA = false;
+      /** For disabling RCDATA tags handling */
+      this.inXML = false;
+      /** Reocrd newline positions for fast line / column calculation */
+      this.newlines = [];
+      this.mode = 0;
+      this.delimiterOpen = defaultDelimitersOpen;
+      this.delimiterClose = defaultDelimitersClose;
+      this.delimiterIndex = -1;
+      this.currentSequence = void 0;
+      this.sequenceIndex = 0;
+    }
+    get inSFCRoot() {
+      return this.mode === 2 && this.stack.length === 0;
+    }
+    reset() {
+      this.state = 1;
+      this.mode = 0;
+      this.buffer = "";
+      this.sectionStart = 0;
+      this.index = 0;
+      this.baseState = 1;
+      this.currentSequence = void 0;
+      this.newlines.length = 0;
+      this.delimiterOpen = defaultDelimitersOpen;
+      this.delimiterClose = defaultDelimitersClose;
     }
-  }
-  function findDir(node, name, allowEmpty = false) {
-    for (let i = 0; i < node.props.length; i++) {
-      const p = node.props[i];
-      if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
-        return p;
+    /**
+     * Generate Position object with line / column information using recorded
+     * newline positions. We know the index is always going to be an already
+     * processed index, so all the newlines up to this index should have been
+     * recorded.
+     */
+    getPos(index) {
+      let line = 1;
+      let column = index + 1;
+      for (let i = this.newlines.length - 1; i >= 0; i--) {
+        const newlineIndex = this.newlines[i];
+        if (index > newlineIndex) {
+          line = i + 2;
+          column = index - newlineIndex;
+          break;
+        }
       }
+      return {
+        column,
+        line,
+        offset: index
+      };
     }
-  }
-  function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
-    for (let i = 0; i < node.props.length; i++) {
-      const p = node.props[i];
-      if (p.type === 6) {
-        if (dynamicOnly)
-          continue;
-        if (p.name === name && (p.value || allowEmpty)) {
-          return p;
+    peek() {
+      return this.buffer.charCodeAt(this.index + 1);
+    }
+    stateText(c) {
+      if (c === 60) {
+        if (this.index > this.sectionStart) {
+          this.cbs.ontext(this.sectionStart, this.index);
         }
-      } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
-        return p;
+        this.state = 5;
+        this.sectionStart = this.index;
+      } else if (c === this.delimiterOpen[0]) {
+        this.state = 2;
+        this.delimiterIndex = 0;
+        this.stateInterpolationOpen(c);
       }
     }
-  }
-  function isStaticArgOf(arg, name) {
-    return !!(arg && isStaticExp(arg) && arg.content === name);
-  }
-  function hasDynamicKeyVBind(node) {
-    return node.props.some(
-      (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
-      p.arg.type !== 4 || // v-bind:[_ctx.foo]
-      !p.arg.isStatic)
-      // v-bind:[foo]
-    );
-  }
-  function isText$1(node) {
-    return node.type === 5 || node.type === 2;
-  }
-  function isVSlot(p) {
-    return p.type === 7 && p.name === "slot";
-  }
-  function isTemplateNode(node) {
-    return node.type === 1 && node.tagType === 3;
-  }
-  function isSlotOutlet(node) {
-    return node.type === 1 && node.tagType === 2;
-  }
-  const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
-  function getUnnormalizedProps(props, callPath = []) {
-    if (props && !isString(props) && props.type === 14) {
-      const callee = props.callee;
-      if (!isString(callee) && propsHelperSet.has(callee)) {
-        return getUnnormalizedProps(
-          props.arguments[0],
-          callPath.concat(props)
-        );
+    stateInterpolationOpen(c) {
+      if (c === this.delimiterOpen[this.delimiterIndex]) {
+        if (this.delimiterIndex === this.delimiterOpen.length - 1) {
+          const start = this.index + 1 - this.delimiterOpen.length;
+          if (start > this.sectionStart) {
+            this.cbs.ontext(this.sectionStart, start);
+          }
+          this.state = 3;
+          this.sectionStart = start;
+        } else {
+          this.delimiterIndex++;
+        }
+      } else if (this.inRCDATA) {
+        this.state = 32;
+        this.stateInRCDATA(c);
+      } else {
+        this.state = 1;
+        this.stateText(c);
       }
     }
-    return [props, callPath];
-  }
-  function injectProp(node, prop, context) {
-    let propsWithInjection;
-    let props = node.type === 13 ? node.props : node.arguments[2];
-    let callPath = [];
-    let parentCall;
-    if (props && !isString(props) && props.type === 14) {
-      const ret = getUnnormalizedProps(props);
-      props = ret[0];
-      callPath = ret[1];
-      parentCall = callPath[callPath.length - 1];
+    stateInterpolation(c) {
+      if (c === this.delimiterClose[0]) {
+        this.state = 4;
+        this.delimiterIndex = 0;
+        this.stateInterpolationClose(c);
+      }
     }
-    if (props == null || isString(props)) {
-      propsWithInjection = createObjectExpression([prop]);
-    } else if (props.type === 14) {
-      const first = props.arguments[0];
-      if (!isString(first) && first.type === 15) {
-        if (!hasProp(prop, first)) {
-          first.properties.unshift(prop);
+    stateInterpolationClose(c) {
+      if (c === this.delimiterClose[this.delimiterIndex]) {
+        if (this.delimiterIndex === this.delimiterClose.length - 1) {
+          this.cbs.oninterpolation(this.sectionStart, this.index + 1);
+          if (this.inRCDATA) {
+            this.state = 32;
+          } else {
+            this.state = 1;
+          }
+          this.sectionStart = this.index + 1;
+        } else {
+          this.delimiterIndex++;
         }
       } else {
-        if (props.callee === TO_HANDLERS) {
-          propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
-            createObjectExpression([prop]),
-            props
-          ]);
-        } else {
-          props.arguments.unshift(createObjectExpression([prop]));
+        this.state = 3;
+        this.stateInterpolation(c);
+      }
+    }
+    stateSpecialStartSequence(c) {
+      const isEnd = this.sequenceIndex === this.currentSequence.length;
+      const isMatch = isEnd ? (
+        // If we are at the end of the sequence, make sure the tag name has ended
+        isEndOfTagSection(c)
+      ) : (
+        // Otherwise, do a case-insensitive comparison
+        (c | 32) === this.currentSequence[this.sequenceIndex]
+      );
+      if (!isMatch) {
+        this.inRCDATA = false;
+      } else if (!isEnd) {
+        this.sequenceIndex++;
+        return;
+      }
+      this.sequenceIndex = 0;
+      this.state = 6;
+      this.stateInTagName(c);
+    }
+    /** Look for an end tag. For <title> and <textarea>, also decode entities. */
+    stateInRCDATA(c) {
+      if (this.sequenceIndex === this.currentSequence.length) {
+        if (c === 62 || isWhitespace(c)) {
+          const endOfText = this.index - this.currentSequence.length;
+          if (this.sectionStart < endOfText) {
+            const actualIndex = this.index;
+            this.index = endOfText;
+            this.cbs.ontext(this.sectionStart, endOfText);
+            this.index = actualIndex;
+          }
+          this.sectionStart = endOfText + 2;
+          this.stateInClosingTagName(c);
+          this.inRCDATA = false;
+          return;
         }
+        this.sequenceIndex = 0;
       }
-      !propsWithInjection && (propsWithInjection = props);
-    } else if (props.type === 15) {
-      if (!hasProp(prop, props)) {
-        props.properties.unshift(prop);
+      if ((c | 32) === this.currentSequence[this.sequenceIndex]) {
+        this.sequenceIndex += 1;
+      } else if (this.sequenceIndex === 0) {
+        if (this.currentSequence === Sequences.TitleEnd || this.currentSequence === Sequences.TextareaEnd && !this.inSFCRoot) {
+          if (c === this.delimiterOpen[0]) {
+            this.state = 2;
+            this.delimiterIndex = 0;
+            this.stateInterpolationOpen(c);
+          }
+        } else if (this.fastForwardTo(60)) {
+          this.sequenceIndex = 1;
+        }
+      } else {
+        this.sequenceIndex = Number(c === 60);
       }
-      propsWithInjection = props;
-    } else {
-      propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
-        createObjectExpression([prop]),
-        props
-      ]);
-      if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
-        parentCall = callPath[callPath.length - 2];
+    }
+    stateCDATASequence(c) {
+      if (c === Sequences.Cdata[this.sequenceIndex]) {
+        if (++this.sequenceIndex === Sequences.Cdata.length) {
+          this.state = 28;
+          this.currentSequence = Sequences.CdataEnd;
+          this.sequenceIndex = 0;
+          this.sectionStart = this.index + 1;
+        }
+      } else {
+        this.sequenceIndex = 0;
+        this.state = 23;
+        this.stateInDeclaration(c);
       }
     }
-    if (node.type === 13) {
-      if (parentCall) {
-        parentCall.arguments[0] = propsWithInjection;
+    /**
+     * When we wait for one specific character, we can speed things up
+     * by skipping through the buffer until we find it.
+     *
+     * @returns Whether the character was found.
+     */
+    fastForwardTo(c) {
+      while (++this.index < this.buffer.length) {
+        const cc = this.buffer.charCodeAt(this.index);
+        if (cc === 10) {
+          this.newlines.push(this.index);
+        }
+        if (cc === c) {
+          return true;
+        }
+      }
+      this.index = this.buffer.length - 1;
+      return false;
+    }
+    /**
+     * Comments and CDATA end with `-->` and `]]>`.
+     *
+     * Their common qualities are:
+     * - Their end sequences have a distinct character they start with.
+     * - That character is then repeated, so we have to check multiple repeats.
+     * - All characters but the start character of the sequence can be skipped.
+     */
+    stateInCommentLike(c) {
+      if (c === this.currentSequence[this.sequenceIndex]) {
+        if (++this.sequenceIndex === this.currentSequence.length) {
+          if (this.currentSequence === Sequences.CdataEnd) {
+            this.cbs.oncdata(this.sectionStart, this.index - 2);
+          } else {
+            this.cbs.oncomment(this.sectionStart, this.index - 2);
+          }
+          this.sequenceIndex = 0;
+          this.sectionStart = this.index + 1;
+          this.state = 1;
+        }
+      } else if (this.sequenceIndex === 0) {
+        if (this.fastForwardTo(this.currentSequence[0])) {
+          this.sequenceIndex = 1;
+        }
+      } else if (c !== this.currentSequence[this.sequenceIndex - 1]) {
+        this.sequenceIndex = 0;
+      }
+    }
+    startSpecial(sequence, offset) {
+      this.enterRCDATA(sequence, offset);
+      this.state = 31;
+    }
+    enterRCDATA(sequence, offset) {
+      this.inRCDATA = true;
+      this.currentSequence = sequence;
+      this.sequenceIndex = offset;
+    }
+    stateBeforeTagName(c) {
+      if (c === 33) {
+        this.state = 22;
+        this.sectionStart = this.index + 1;
+      } else if (c === 63) {
+        this.state = 24;
+        this.sectionStart = this.index + 1;
+      } else if (isTagStartChar(c)) {
+        this.sectionStart = this.index;
+        if (this.mode === 0) {
+          this.state = 6;
+        } else if (this.inSFCRoot) {
+          this.state = 34;
+        } else if (!this.inXML) {
+          const lower = c | 32;
+          if (lower === 116) {
+            this.state = 30;
+          } else {
+            this.state = lower === 115 ? 29 : 6;
+          }
+        } else {
+          this.state = 6;
+        }
+      } else if (c === 47) {
+        this.state = 8;
       } else {
-        node.props = propsWithInjection;
+        this.state = 1;
+        this.stateText(c);
       }
-    } else {
-      if (parentCall) {
-        parentCall.arguments[0] = propsWithInjection;
+    }
+    stateInTagName(c) {
+      if (isEndOfTagSection(c)) {
+        this.handleTagName(c);
+      }
+    }
+    stateInSFCRootTagName(c) {
+      if (isEndOfTagSection(c)) {
+        const tag = this.buffer.slice(this.sectionStart, this.index);
+        if (tag !== "template") {
+          this.enterRCDATA(toCharCodes(`</` + tag), 0);
+        }
+        this.handleTagName(c);
+      }
+    }
+    handleTagName(c) {
+      this.cbs.onopentagname(this.sectionStart, this.index);
+      this.sectionStart = -1;
+      this.state = 11;
+      this.stateBeforeAttrName(c);
+    }
+    stateBeforeClosingTagName(c) {
+      if (isWhitespace(c)) ; else if (c === 62) {
+        {
+          this.cbs.onerr(14, this.index);
+        }
+        this.state = 1;
+        this.sectionStart = this.index + 1;
       } else {
-        node.arguments[2] = propsWithInjection;
+        this.state = isTagStartChar(c) ? 9 : 27;
+        this.sectionStart = this.index;
       }
     }
-  }
-  function hasProp(prop, props) {
-    let result = false;
-    if (prop.key.type === 4) {
-      const propKeyName = prop.key.content;
-      result = props.properties.some(
-        (p) => p.key.type === 4 && p.key.content === propKeyName
-      );
+    stateInClosingTagName(c) {
+      if (c === 62 || isWhitespace(c)) {
+        this.cbs.onclosetag(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.state = 10;
+        this.stateAfterClosingTagName(c);
+      }
     }
-    return result;
-  }
-  function toValidAssetId(name, type) {
-    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
-    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
-  })}`;
-  }
-  function getMemoedVNodeCall(node) {
-    if (node.type === 14 && node.callee === WITH_MEMO) {
-      return node.arguments[1].returns;
-    } else {
-      return node;
+    stateAfterClosingTagName(c) {
+      if (c === 62) {
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateBeforeAttrName(c) {
+      if (c === 62) {
+        this.cbs.onopentagend(this.index);
+        if (this.inRCDATA) {
+          this.state = 32;
+        } else {
+          this.state = 1;
+        }
+        this.sectionStart = this.index + 1;
+      } else if (c === 47) {
+        this.state = 7;
+        if (this.peek() !== 62) {
+          this.cbs.onerr(22, this.index);
+        }
+      } else if (c === 60 && this.peek() === 47) {
+        this.cbs.onopentagend(this.index);
+        this.state = 5;
+        this.sectionStart = this.index;
+      } else if (!isWhitespace(c)) {
+        if (c === 61) {
+          this.cbs.onerr(
+            19,
+            this.index
+          );
+        }
+        this.handleAttrStart(c);
+      }
+    }
+    handleAttrStart(c) {
+      if (c === 118 && this.peek() === 45) {
+        this.state = 13;
+        this.sectionStart = this.index;
+      } else if (c === 46 || c === 58 || c === 64 || c === 35) {
+        this.cbs.ondirname(this.index, this.index + 1);
+        this.state = 14;
+        this.sectionStart = this.index + 1;
+      } else {
+        this.state = 12;
+        this.sectionStart = this.index;
+      }
+    }
+    stateInSelfClosingTag(c) {
+      if (c === 62) {
+        this.cbs.onselfclosingtag(this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+        this.inRCDATA = false;
+      } else if (!isWhitespace(c)) {
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      }
+    }
+    stateInAttrName(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.onattribname(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 34 || c === 39 || c === 60) {
+        this.cbs.onerr(
+          17,
+          this.index
+        );
+      }
+    }
+    stateInDirName(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 58) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.state = 14;
+        this.sectionStart = this.index + 1;
+      } else if (c === 46) {
+        this.cbs.ondirname(this.sectionStart, this.index);
+        this.state = 16;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateInDirArg(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirarg(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 91) {
+        this.state = 15;
+      } else if (c === 46) {
+        this.cbs.ondirarg(this.sectionStart, this.index);
+        this.state = 16;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateInDynamicDirArg(c) {
+      if (c === 93) {
+        this.state = 14;
+      } else if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirarg(this.sectionStart, this.index + 1);
+        this.handleAttrNameEnd(c);
+        {
+          this.cbs.onerr(
+            27,
+            this.index
+          );
+        }
+      }
+    }
+    stateInDirModifier(c) {
+      if (c === 61 || isEndOfTagSection(c)) {
+        this.cbs.ondirmodifier(this.sectionStart, this.index);
+        this.handleAttrNameEnd(c);
+      } else if (c === 46) {
+        this.cbs.ondirmodifier(this.sectionStart, this.index);
+        this.sectionStart = this.index + 1;
+      }
+    }
+    handleAttrNameEnd(c) {
+      this.sectionStart = this.index;
+      this.state = 17;
+      this.cbs.onattribnameend(this.index);
+      this.stateAfterAttrName(c);
+    }
+    stateAfterAttrName(c) {
+      if (c === 61) {
+        this.state = 18;
+      } else if (c === 47 || c === 62) {
+        this.cbs.onattribend(0, this.sectionStart);
+        this.sectionStart = -1;
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      } else if (!isWhitespace(c)) {
+        this.cbs.onattribend(0, this.sectionStart);
+        this.handleAttrStart(c);
+      }
+    }
+    stateBeforeAttrValue(c) {
+      if (c === 34) {
+        this.state = 19;
+        this.sectionStart = this.index + 1;
+      } else if (c === 39) {
+        this.state = 20;
+        this.sectionStart = this.index + 1;
+      } else if (!isWhitespace(c)) {
+        this.sectionStart = this.index;
+        this.state = 21;
+        this.stateInAttrValueNoQuotes(c);
+      }
+    }
+    handleInAttrValue(c, quote) {
+      if (c === quote || this.fastForwardTo(quote)) {
+        this.cbs.onattribdata(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.cbs.onattribend(
+          quote === 34 ? 3 : 2,
+          this.index + 1
+        );
+        this.state = 11;
+      }
+    }
+    stateInAttrValueDoubleQuotes(c) {
+      this.handleInAttrValue(c, 34);
+    }
+    stateInAttrValueSingleQuotes(c) {
+      this.handleInAttrValue(c, 39);
+    }
+    stateInAttrValueNoQuotes(c) {
+      if (isWhitespace(c) || c === 62) {
+        this.cbs.onattribdata(this.sectionStart, this.index);
+        this.sectionStart = -1;
+        this.cbs.onattribend(1, this.index);
+        this.state = 11;
+        this.stateBeforeAttrName(c);
+      } else if (c === 34 || c === 39 || c === 60 || c === 61 || c === 96) {
+        this.cbs.onerr(
+          18,
+          this.index
+        );
+      } else ;
+    }
+    stateBeforeDeclaration(c) {
+      if (c === 91) {
+        this.state = 26;
+        this.sequenceIndex = 0;
+      } else {
+        this.state = c === 45 ? 25 : 23;
+      }
+    }
+    stateInDeclaration(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateInProcessingInstruction(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.cbs.onprocessinginstruction(this.sectionStart, this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateBeforeComment(c) {
+      if (c === 45) {
+        this.state = 28;
+        this.currentSequence = Sequences.CommentEnd;
+        this.sequenceIndex = 2;
+        this.sectionStart = this.index + 1;
+      } else {
+        this.state = 23;
+      }
+    }
+    stateInSpecialComment(c) {
+      if (c === 62 || this.fastForwardTo(62)) {
+        this.cbs.oncomment(this.sectionStart, this.index);
+        this.state = 1;
+        this.sectionStart = this.index + 1;
+      }
+    }
+    stateBeforeSpecialS(c) {
+      const lower = c | 32;
+      if (lower === Sequences.ScriptEnd[3]) {
+        this.startSpecial(Sequences.ScriptEnd, 4);
+      } else if (lower === Sequences.StyleEnd[3]) {
+        this.startSpecial(Sequences.StyleEnd, 4);
+      } else {
+        this.state = 6;
+        this.stateInTagName(c);
+      }
+    }
+    stateBeforeSpecialT(c) {
+      const lower = c | 32;
+      if (lower === Sequences.TitleEnd[3]) {
+        this.startSpecial(Sequences.TitleEnd, 4);
+      } else if (lower === Sequences.TextareaEnd[3]) {
+        this.startSpecial(Sequences.TextareaEnd, 4);
+      } else {
+        this.state = 6;
+        this.stateInTagName(c);
+      }
+    }
+    startEntity() {
+    }
+    stateInEntity() {
+    }
+    /**
+     * Iterates through the buffer, calling the function corresponding to the current state.
+     *
+     * States that are more likely to be hit are higher up, as a performance improvement.
+     */
+    parse(input) {
+      this.buffer = input;
+      while (this.index < this.buffer.length) {
+        const c = this.buffer.charCodeAt(this.index);
+        if (c === 10) {
+          this.newlines.push(this.index);
+        }
+        switch (this.state) {
+          case 1: {
+            this.stateText(c);
+            break;
+          }
+          case 2: {
+            this.stateInterpolationOpen(c);
+            break;
+          }
+          case 3: {
+            this.stateInterpolation(c);
+            break;
+          }
+          case 4: {
+            this.stateInterpolationClose(c);
+            break;
+          }
+          case 31: {
+            this.stateSpecialStartSequence(c);
+            break;
+          }
+          case 32: {
+            this.stateInRCDATA(c);
+            break;
+          }
+          case 26: {
+            this.stateCDATASequence(c);
+            break;
+          }
+          case 19: {
+            this.stateInAttrValueDoubleQuotes(c);
+            break;
+          }
+          case 12: {
+            this.stateInAttrName(c);
+            break;
+          }
+          case 13: {
+            this.stateInDirName(c);
+            break;
+          }
+          case 14: {
+            this.stateInDirArg(c);
+            break;
+          }
+          case 15: {
+            this.stateInDynamicDirArg(c);
+            break;
+          }
+          case 16: {
+            this.stateInDirModifier(c);
+            break;
+          }
+          case 28: {
+            this.stateInCommentLike(c);
+            break;
+          }
+          case 27: {
+            this.stateInSpecialComment(c);
+            break;
+          }
+          case 11: {
+            this.stateBeforeAttrName(c);
+            break;
+          }
+          case 6: {
+            this.stateInTagName(c);
+            break;
+          }
+          case 34: {
+            this.stateInSFCRootTagName(c);
+            break;
+          }
+          case 9: {
+            this.stateInClosingTagName(c);
+            break;
+          }
+          case 5: {
+            this.stateBeforeTagName(c);
+            break;
+          }
+          case 17: {
+            this.stateAfterAttrName(c);
+            break;
+          }
+          case 20: {
+            this.stateInAttrValueSingleQuotes(c);
+            break;
+          }
+          case 18: {
+            this.stateBeforeAttrValue(c);
+            break;
+          }
+          case 8: {
+            this.stateBeforeClosingTagName(c);
+            break;
+          }
+          case 10: {
+            this.stateAfterClosingTagName(c);
+            break;
+          }
+          case 29: {
+            this.stateBeforeSpecialS(c);
+            break;
+          }
+          case 30: {
+            this.stateBeforeSpecialT(c);
+            break;
+          }
+          case 21: {
+            this.stateInAttrValueNoQuotes(c);
+            break;
+          }
+          case 7: {
+            this.stateInSelfClosingTag(c);
+            break;
+          }
+          case 23: {
+            this.stateInDeclaration(c);
+            break;
+          }
+          case 22: {
+            this.stateBeforeDeclaration(c);
+            break;
+          }
+          case 25: {
+            this.stateBeforeComment(c);
+            break;
+          }
+          case 24: {
+            this.stateInProcessingInstruction(c);
+            break;
+          }
+          case 33: {
+            this.stateInEntity();
+            break;
+          }
+        }
+        this.index++;
+      }
+      this.cleanup();
+      this.finish();
+    }
+    /**
+     * Remove data that has already been consumed from the buffer.
+     */
+    cleanup() {
+      if (this.sectionStart !== this.index) {
+        if (this.state === 1 || this.state === 32 && this.sequenceIndex === 0) {
+          this.cbs.ontext(this.sectionStart, this.index);
+          this.sectionStart = this.index;
+        } else if (this.state === 19 || this.state === 20 || this.state === 21) {
+          this.cbs.onattribdata(this.sectionStart, this.index);
+          this.sectionStart = this.index;
+        }
+      }
+    }
+    finish() {
+      this.handleTrailingData();
+      this.cbs.onend();
+    }
+    /** Handle any trailing data. */
+    handleTrailingData() {
+      const endIndex = this.buffer.length;
+      if (this.sectionStart >= endIndex) {
+        return;
+      }
+      if (this.state === 28) {
+        if (this.currentSequence === Sequences.CdataEnd) {
+          this.cbs.oncdata(this.sectionStart, endIndex);
+        } else {
+          this.cbs.oncomment(this.sectionStart, endIndex);
+        }
+      } else if (this.state === 6 || this.state === 11 || this.state === 18 || this.state === 17 || this.state === 12 || this.state === 13 || this.state === 14 || this.state === 15 || this.state === 16 || this.state === 20 || this.state === 19 || this.state === 21 || this.state === 9) ; else {
+        this.cbs.ontext(this.sectionStart, endIndex);
+      }
+    }
+    emitCodePoint(cp, consumed) {
     }
   }
-  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
 
   const deprecationData = {
     ["COMPILER_IS_ON_ELEMENT"]: {
@@ -13245,9 +13771,6 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       message: (key) => `.sync modifier for v-bind has been removed. Use v-model with argument instead. \`v-bind:${key}.sync\` should be changed to \`v-model:${key}\`.`,
       link: `https://v3-migration.vuejs.org/breaking-changes/v-model.html`
     },
-    ["COMPILER_V_BIND_PROP"]: {
-      message: `.prop modifier for v-bind has been removed and no longer necessary. Vue 3 will automatically set a binding as DOM property when appropriate.`
-    },
     ["COMPILER_V_BIND_OBJECT_ORDER"]: {
       message: `v-bind="obj" usage is now order sensitive and behaves like JavaScript object spread: it will now overwrite an existing non-mergeable attribute that appears before v-bind in the case of conflict. To retain 2.x behavior, move v-bind to make it the first attribute. You can also suppress this warning if the usage is intended.`,
       link: `https://v3-migration.vuejs.org/breaking-changes/v-bind.html`
@@ -13272,9 +13795,8 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       link: `https://v3-migration.vuejs.org/breaking-changes/filters.html`
     }
   };
-  function getCompatValue(key, context) {
-    const config = context.options ? context.options.compatConfig : context.compatConfig;
-    const value = config && config[key];
+  function getCompatValue(key, { compatConfig }) {
+    const value = compatConfig && compatConfig[key];
     if (key === "MODE") {
       return value || 3;
     } else {
@@ -13308,398 +13830,865 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     context.onWarn(err);
   }
 
-  const decodeRE = /&(gt|lt|amp|apos|quot);/g;
-  const decodeMap = {
-    gt: ">",
-    lt: "<",
-    amp: "&",
-    apos: "'",
-    quot: '"'
-  };
-  const defaultParserOptions = {
-    delimiters: [`{{`, `}}`],
-    getNamespace: () => 0,
-    getTextMode: () => 0,
-    isVoidTag: NO,
-    isPreTag: NO,
-    isCustomElement: NO,
-    decodeEntities: (rawText) => rawText.replace(decodeRE, (_, p1) => decodeMap[p1]),
-    onError: defaultOnError,
-    onWarn: defaultOnWarn,
-    comments: true
-  };
-  function baseParse(content, options = {}) {
-    const context = createParserContext(content, options);
-    const start = getCursor(context);
-    return createRoot(
-      parseChildren(context, 0, []),
-      getSelection(context, start)
-    );
-  }
-  function createParserContext(content, rawOptions) {
-    const options = extend({}, defaultParserOptions);
-    let key;
-    for (key in rawOptions) {
-      options[key] = rawOptions[key] === void 0 ? defaultParserOptions[key] : rawOptions[key];
-    }
-    return {
-      options,
-      column: 1,
-      line: 1,
-      offset: 0,
-      originalSource: content,
-      source: content,
-      inPre: false,
-      inVPre: false,
-      onWarn: options.onWarn
-    };
+  function defaultOnError(error) {
+    throw error;
   }
-  function parseChildren(context, mode, ancestors) {
-    const parent = last(ancestors);
-    const ns = parent ? parent.ns : 0;
-    const nodes = [];
-    while (!isEnd(context, mode, ancestors)) {
-      const s = context.source;
-      let node = void 0;
-      if (mode === 0 || mode === 1) {
-        if (!context.inVPre && startsWith(s, context.options.delimiters[0])) {
-          node = parseInterpolation(context, mode);
-        } else if (mode === 0 && s[0] === "<") {
-          if (s.length === 1) {
-            emitError(context, 5, 1);
-          } else if (s[1] === "!") {
-            if (startsWith(s, "<!--")) {
-              node = parseComment(context);
-            } else if (startsWith(s, "<!DOCTYPE")) {
-              node = parseBogusComment(context);
-            } else if (startsWith(s, "<![CDATA[")) {
-              if (ns !== 0) {
-                node = parseCDATA(context, ancestors);
-              } else {
-                emitError(context, 1);
-                node = parseBogusComment(context);
-              }
-            } else {
-              emitError(context, 11);
-              node = parseBogusComment(context);
-            }
-          } else if (s[1] === "/") {
-            if (s.length === 2) {
-              emitError(context, 5, 2);
-            } else if (s[2] === ">") {
-              emitError(context, 14, 2);
-              advanceBy(context, 3);
-              continue;
-            } else if (/[a-z]/i.test(s[2])) {
-              emitError(context, 23);
-              parseTag(context, 1 /* End */, parent);
-              continue;
-            } else {
-              emitError(
-                context,
-                12,
-                2
-              );
-              node = parseBogusComment(context);
-            }
-          } else if (/[a-z]/i.test(s[1])) {
-            node = parseElement(context, ancestors);
-            if (isCompatEnabled(
-              "COMPILER_NATIVE_TEMPLATE",
-              context
-            ) && node && node.tag === "template" && !node.props.some(
-              (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
-            )) {
-              warnDeprecation(
-                "COMPILER_NATIVE_TEMPLATE",
-                context,
-                node.loc
-              );
-              node = node.children;
-            }
-          } else if (s[1] === "?") {
-            emitError(
-              context,
-              21,
-              1
-            );
-            node = parseBogusComment(context);
-          } else {
-            emitError(context, 12, 1);
-          }
-        }
-      }
-      if (!node) {
-        node = parseText(context, mode);
-      }
-      if (isArray(node)) {
-        for (let i = 0; i < node.length; i++) {
-          pushNode(nodes, node[i]);
-        }
-      } else {
-        pushNode(nodes, node);
-      }
-    }
-    let removedWhitespace = false;
-    if (mode !== 2 && mode !== 1) {
-      const shouldCondense = context.options.whitespace !== "preserve";
-      for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        if (node.type === 2) {
-          if (!context.inPre) {
-            if (!/[^\t\r\n\f ]/.test(node.content)) {
-              const prev = nodes[i - 1];
-              const next = nodes[i + 1];
-              if (!prev || !next || shouldCondense && (prev.type === 3 && next.type === 3 || prev.type === 3 && next.type === 1 || prev.type === 1 && next.type === 3 || prev.type === 1 && next.type === 1 && /[\r\n]/.test(node.content))) {
-                removedWhitespace = true;
-                nodes[i] = null;
-              } else {
-                node.content = " ";
-              }
-            } else if (shouldCondense) {
-              node.content = node.content.replace(/[\t\r\n\f ]+/g, " ");
-            }
-          } else {
-            node.content = node.content.replace(/\r\n/g, "\n");
-          }
-        } else if (node.type === 3 && !context.options.comments) {
-          removedWhitespace = true;
-          nodes[i] = null;
-        }
-      }
-      if (context.inPre && parent && context.options.isPreTag(parent.tag)) {
-        const first = nodes[0];
-        if (first && first.type === 2) {
-          first.content = first.content.replace(/^\r?\n/, "");
-        }
-      }
-    }
-    return removedWhitespace ? nodes.filter(Boolean) : nodes;
+  function defaultOnWarn(msg) {
+    console.warn(`[Vue warn] ${msg.message}`);
   }
-  function pushNode(nodes, node) {
-    if (node.type === 2) {
-      const prev = last(nodes);
-      if (prev && prev.type === 2 && prev.loc.end.offset === node.loc.start.offset) {
-        prev.content += node.content;
-        prev.loc.end = node.loc.end;
-        prev.loc.source += node.loc.source;
-        return;
-      }
-    }
-    nodes.push(node);
+  function createCompilerError(code, loc, messages, additionalMessage) {
+    const msg = (messages || errorMessages)[code] + (additionalMessage || ``) ;
+    const error = new SyntaxError(String(msg));
+    error.code = code;
+    error.loc = loc;
+    return error;
   }
-  function parseCDATA(context, ancestors) {
-    advanceBy(context, 9);
-    const nodes = parseChildren(context, 3, ancestors);
-    if (context.source.length === 0) {
-      emitError(context, 6);
-    } else {
-      advanceBy(context, 3);
-    }
-    return nodes;
-  }
-  function parseComment(context) {
-    const start = getCursor(context);
-    let content;
-    const match = /--(\!)?>/.exec(context.source);
-    if (!match) {
-      content = context.source.slice(4);
-      advanceBy(context, context.source.length);
-      emitError(context, 7);
+  const errorMessages = {
+    // parse errors
+    [0]: "Illegal comment.",
+    [1]: "CDATA section is allowed only in XML context.",
+    [2]: "Duplicate attribute.",
+    [3]: "End tag cannot have attributes.",
+    [4]: "Illegal '/' in tags.",
+    [5]: "Unexpected EOF in tag.",
+    [6]: "Unexpected EOF in CDATA section.",
+    [7]: "Unexpected EOF in comment.",
+    [8]: "Unexpected EOF in script.",
+    [9]: "Unexpected EOF in tag.",
+    [10]: "Incorrectly closed comment.",
+    [11]: "Incorrectly opened comment.",
+    [12]: "Illegal tag name. Use '&lt;' to print '<'.",
+    [13]: "Attribute value was expected.",
+    [14]: "End tag name was expected.",
+    [15]: "Whitespace was expected.",
+    [16]: "Unexpected '<!--' in comment.",
+    [17]: `Attribute name cannot contain U+0022 ("), U+0027 ('), and U+003C (<).`,
+    [18]: "Unquoted attribute value cannot contain U+0022 (\"), U+0027 ('), U+003C (<), U+003D (=), and U+0060 (`).",
+    [19]: "Attribute name cannot start with '='.",
+    [21]: "'<?' is allowed only in XML context.",
+    [20]: `Unexpected null character.`,
+    [22]: "Illegal '/' in tags.",
+    // Vue-specific parse errors
+    [23]: "Invalid end tag.",
+    [24]: "Element is missing end tag.",
+    [25]: "Interpolation end sign was not found.",
+    [27]: "End bracket for dynamic directive argument was not found. Note that dynamic directive argument cannot contain spaces.",
+    [26]: "Legal directive name was expected.",
+    // transform errors
+    [28]: `v-if/v-else-if is missing expression.`,
+    [29]: `v-if/else branches must use unique keys.`,
+    [30]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
+    [31]: `v-for is missing expression.`,
+    [32]: `v-for has invalid expression.`,
+    [33]: `<template v-for> key should be placed on the <template> tag.`,
+    [34]: `v-bind is missing expression.`,
+    [35]: `v-on is missing expression.`,
+    [36]: `Unexpected custom directive on <slot> outlet.`,
+    [37]: `Mixed v-slot usage on both the component and nested <template>. When there are multiple named slots, all slots should use <template> syntax to avoid scope ambiguity.`,
+    [38]: `Duplicate slot names found. `,
+    [39]: `Extraneous children found when component already has explicitly named default slot. These children will be ignored.`,
+    [40]: `v-slot can only be used on components or <template> tags.`,
+    [41]: `v-model is missing expression.`,
+    [42]: `v-model value must be a valid JavaScript member expression.`,
+    [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
+    [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+    [45]: `Error parsing JavaScript expression: `,
+    [46]: `<KeepAlive> expects exactly one child component.`,
+    // generic errors
+    [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+    [48]: `ES module mode is not supported in this build of compiler.`,
+    [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+    [50]: `"scopeId" option is only supported in module mode.`,
+    // deprecations
+    [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
+    [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
+    // just to fulfill types
+    [53]: ``
+  };
+
+  const isStaticExp = (p) => p.type === 4 && p.isStatic;
+  function isCoreComponent(tag) {
+    switch (tag) {
+      case "Teleport":
+      case "teleport":
+        return TELEPORT;
+      case "Suspense":
+      case "suspense":
+        return SUSPENSE;
+      case "KeepAlive":
+      case "keep-alive":
+        return KEEP_ALIVE;
+      case "BaseTransition":
+      case "base-transition":
+        return BASE_TRANSITION;
+    }
+  }
+  const nonIdentifierRE = /^\d|[^\$\w]/;
+  const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
+  const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
+  const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
+  const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
+  const isMemberExpressionBrowser = (path) => {
+    path = path.trim().replace(whitespaceRE, (s) => s.trim());
+    let state = 0 /* inMemberExp */;
+    let stateStack = [];
+    let currentOpenBracketCount = 0;
+    let currentOpenParensCount = 0;
+    let currentStringType = null;
+    for (let i = 0; i < path.length; i++) {
+      const char = path.charAt(i);
+      switch (state) {
+        case 0 /* inMemberExp */:
+          if (char === "[") {
+            stateStack.push(state);
+            state = 1 /* inBrackets */;
+            currentOpenBracketCount++;
+          } else if (char === "(") {
+            stateStack.push(state);
+            state = 2 /* inParens */;
+            currentOpenParensCount++;
+          } else if (!(i === 0 ? validFirstIdentCharRE : validIdentCharRE).test(char)) {
+            return false;
+          }
+          break;
+        case 1 /* inBrackets */:
+          if (char === `'` || char === `"` || char === "`") {
+            stateStack.push(state);
+            state = 3 /* inString */;
+            currentStringType = char;
+          } else if (char === `[`) {
+            currentOpenBracketCount++;
+          } else if (char === `]`) {
+            if (!--currentOpenBracketCount) {
+              state = stateStack.pop();
+            }
+          }
+          break;
+        case 2 /* inParens */:
+          if (char === `'` || char === `"` || char === "`") {
+            stateStack.push(state);
+            state = 3 /* inString */;
+            currentStringType = char;
+          } else if (char === `(`) {
+            currentOpenParensCount++;
+          } else if (char === `)`) {
+            if (i === path.length - 1) {
+              return false;
+            }
+            if (!--currentOpenParensCount) {
+              state = stateStack.pop();
+            }
+          }
+          break;
+        case 3 /* inString */:
+          if (char === currentStringType) {
+            state = stateStack.pop();
+            currentStringType = null;
+          }
+          break;
+      }
+    }
+    return !currentOpenBracketCount && !currentOpenParensCount;
+  };
+  const isMemberExpression = isMemberExpressionBrowser ;
+  function assert(condition, msg) {
+    if (!condition) {
+      throw new Error(msg || `unexpected compiler condition`);
+    }
+  }
+  function findDir(node, name, allowEmpty = false) {
+    for (let i = 0; i < node.props.length; i++) {
+      const p = node.props[i];
+      if (p.type === 7 && (allowEmpty || p.exp) && (isString(name) ? p.name === name : name.test(p.name))) {
+        return p;
+      }
+    }
+  }
+  function findProp(node, name, dynamicOnly = false, allowEmpty = false) {
+    for (let i = 0; i < node.props.length; i++) {
+      const p = node.props[i];
+      if (p.type === 6) {
+        if (dynamicOnly)
+          continue;
+        if (p.name === name && (p.value || allowEmpty)) {
+          return p;
+        }
+      } else if (p.name === "bind" && (p.exp || allowEmpty) && isStaticArgOf(p.arg, name)) {
+        return p;
+      }
+    }
+  }
+  function isStaticArgOf(arg, name) {
+    return !!(arg && isStaticExp(arg) && arg.content === name);
+  }
+  function hasDynamicKeyVBind(node) {
+    return node.props.some(
+      (p) => p.type === 7 && p.name === "bind" && (!p.arg || // v-bind="obj"
+      p.arg.type !== 4 || // v-bind:[_ctx.foo]
+      !p.arg.isStatic)
+      // v-bind:[foo]
+    );
+  }
+  function isText$1(node) {
+    return node.type === 5 || node.type === 2;
+  }
+  function isVSlot(p) {
+    return p.type === 7 && p.name === "slot";
+  }
+  function isTemplateNode(node) {
+    return node.type === 1 && node.tagType === 3;
+  }
+  function isSlotOutlet(node) {
+    return node.type === 1 && node.tagType === 2;
+  }
+  const propsHelperSet = /* @__PURE__ */ new Set([NORMALIZE_PROPS, GUARD_REACTIVE_PROPS]);
+  function getUnnormalizedProps(props, callPath = []) {
+    if (props && !isString(props) && props.type === 14) {
+      const callee = props.callee;
+      if (!isString(callee) && propsHelperSet.has(callee)) {
+        return getUnnormalizedProps(
+          props.arguments[0],
+          callPath.concat(props)
+        );
+      }
+    }
+    return [props, callPath];
+  }
+  function injectProp(node, prop, context) {
+    let propsWithInjection;
+    let props = node.type === 13 ? node.props : node.arguments[2];
+    let callPath = [];
+    let parentCall;
+    if (props && !isString(props) && props.type === 14) {
+      const ret = getUnnormalizedProps(props);
+      props = ret[0];
+      callPath = ret[1];
+      parentCall = callPath[callPath.length - 1];
+    }
+    if (props == null || isString(props)) {
+      propsWithInjection = createObjectExpression([prop]);
+    } else if (props.type === 14) {
+      const first = props.arguments[0];
+      if (!isString(first) && first.type === 15) {
+        if (!hasProp(prop, first)) {
+          first.properties.unshift(prop);
+        }
+      } else {
+        if (props.callee === TO_HANDLERS) {
+          propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+            createObjectExpression([prop]),
+            props
+          ]);
+        } else {
+          props.arguments.unshift(createObjectExpression([prop]));
+        }
+      }
+      !propsWithInjection && (propsWithInjection = props);
+    } else if (props.type === 15) {
+      if (!hasProp(prop, props)) {
+        props.properties.unshift(prop);
+      }
+      propsWithInjection = props;
+    } else {
+      propsWithInjection = createCallExpression(context.helper(MERGE_PROPS), [
+        createObjectExpression([prop]),
+        props
+      ]);
+      if (parentCall && parentCall.callee === GUARD_REACTIVE_PROPS) {
+        parentCall = callPath[callPath.length - 2];
+      }
+    }
+    if (node.type === 13) {
+      if (parentCall) {
+        parentCall.arguments[0] = propsWithInjection;
+      } else {
+        node.props = propsWithInjection;
+      }
+    } else {
+      if (parentCall) {
+        parentCall.arguments[0] = propsWithInjection;
+      } else {
+        node.arguments[2] = propsWithInjection;
+      }
+    }
+  }
+  function hasProp(prop, props) {
+    let result = false;
+    if (prop.key.type === 4) {
+      const propKeyName = prop.key.content;
+      result = props.properties.some(
+        (p) => p.key.type === 4 && p.key.content === propKeyName
+      );
+    }
+    return result;
+  }
+  function toValidAssetId(name, type) {
+    return `_${type}_${name.replace(/[^\w]/g, (searchValue, replaceValue) => {
+    return searchValue === "-" ? "_" : name.charCodeAt(replaceValue).toString();
+  })}`;
+  }
+  function getMemoedVNodeCall(node) {
+    if (node.type === 14 && node.callee === WITH_MEMO) {
+      return node.arguments[1].returns;
     } else {
-      if (match.index <= 3) {
-        emitError(context, 0);
+      return node;
+    }
+  }
+  const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+([\s\S]*)/;
+
+  const defaultParserOptions = {
+    parseMode: "base",
+    ns: 0,
+    delimiters: [`{{`, `}}`],
+    getNamespace: () => 0,
+    isVoidTag: NO,
+    isPreTag: NO,
+    isCustomElement: NO,
+    onError: defaultOnError,
+    onWarn: defaultOnWarn,
+    comments: true
+  };
+  let currentOptions = defaultParserOptions;
+  let currentRoot = null;
+  let currentInput = "";
+  let currentOpenTag = null;
+  let currentProp = null;
+  let currentAttrValue = "";
+  let currentAttrStartIndex = -1;
+  let currentAttrEndIndex = -1;
+  let inPre = 0;
+  let inVPre = false;
+  let currentVPreBoundary = null;
+  const stack = [];
+  const tokenizer = new Tokenizer(stack, {
+    onerr: emitError,
+    ontext(start, end) {
+      onText(getSlice(start, end), start, end);
+    },
+    ontextentity(char, start, end) {
+      onText(char, start, end);
+    },
+    oninterpolation(start, end) {
+      if (inVPre) {
+        return onText(getSlice(start, end), start, end);
+      }
+      let innerStart = start + tokenizer.delimiterOpen.length;
+      let innerEnd = end - tokenizer.delimiterClose.length;
+      while (isWhitespace(currentInput.charCodeAt(innerStart))) {
+        innerStart++;
+      }
+      while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
+        innerEnd--;
+      }
+      let exp = getSlice(innerStart, innerEnd);
+      if (exp.includes("&")) {
+        {
+          exp = currentOptions.decodeEntities(exp, false);
+        }
+      }
+      addNode({
+        type: 5,
+        content: createSimpleExpression(exp, false, getLoc(innerStart, innerEnd)),
+        loc: getLoc(start, end)
+      });
+    },
+    onopentagname(start, end) {
+      const name = getSlice(start, end);
+      currentOpenTag = {
+        type: 1,
+        tag: name,
+        ns: currentOptions.getNamespace(name, stack[0], currentOptions.ns),
+        tagType: 0,
+        // will be refined on tag close
+        props: [],
+        children: [],
+        loc: getLoc(start - 1, end),
+        codegenNode: void 0
+      };
+      if (tokenizer.inSFCRoot) {
+        currentOpenTag.innerLoc = getLoc(
+          end + fastForward(end) + 1,
+          end
+        );
+      }
+    },
+    onopentagend(end) {
+      endOpenTag(end);
+    },
+    onclosetag(start, end) {
+      const name = getSlice(start, end);
+      if (!currentOptions.isVoidTag(name)) {
+        let found = false;
+        for (let i = 0; i < stack.length; i++) {
+          const e = stack[i];
+          if (e.tag.toLowerCase() === name.toLowerCase()) {
+            found = true;
+            if (i > 0) {
+              emitError(24, stack[0].loc.start.offset);
+            }
+            for (let j = 0; j <= i; j++) {
+              const el = stack.shift();
+              onCloseTag(el, end, j < i);
+            }
+            break;
+          }
+        }
+        if (!found) {
+          emitError(23, backTrack(start, 60));
+        }
+      }
+    },
+    onselfclosingtag(end) {
+      var _a;
+      const name = currentOpenTag.tag;
+      currentOpenTag.isSelfClosing = true;
+      endOpenTag(end);
+      if (((_a = stack[0]) == null ? void 0 : _a.tag) === name) {
+        onCloseTag(stack.shift(), end);
+      }
+    },
+    onattribname(start, end) {
+      currentProp = {
+        type: 6,
+        name: getSlice(start, end),
+        nameLoc: getLoc(start, end),
+        value: void 0,
+        loc: getLoc(start)
+      };
+    },
+    ondirname(start, end) {
+      const raw = getSlice(start, end);
+      const name = raw === "." || raw === ":" ? "bind" : raw === "@" ? "on" : raw === "#" ? "slot" : raw.slice(2);
+      if (!inVPre && name === "") {
+        emitError(26, start);
+      }
+      if (inVPre || name === "") {
+        currentProp = {
+          type: 6,
+          name: raw,
+          nameLoc: getLoc(start, end),
+          value: void 0,
+          loc: getLoc(start)
+        };
+      } else {
+        currentProp = {
+          type: 7,
+          name,
+          rawName: raw,
+          exp: void 0,
+          arg: void 0,
+          modifiers: raw === "." ? ["prop"] : [],
+          loc: getLoc(start)
+        };
+        if (name === "pre") {
+          inVPre = true;
+          currentVPreBoundary = currentOpenTag;
+          const props = currentOpenTag.props;
+          for (let i = 0; i < props.length; i++) {
+            if (props[i].type === 7) {
+              props[i] = dirToAttr(props[i]);
+            }
+          }
+        }
+      }
+    },
+    ondirarg(start, end) {
+      const arg = getSlice(start, end);
+      if (inVPre) {
+        currentProp.name += arg;
+        setLocEnd(currentProp.nameLoc, end);
+      } else {
+        const isStatic = arg[0] !== `[`;
+        currentProp.arg = createSimpleExpression(
+          isStatic ? arg : arg.slice(1, -1),
+          isStatic,
+          getLoc(start, end),
+          isStatic ? 3 : 0
+        );
+      }
+    },
+    ondirmodifier(start, end) {
+      const mod = getSlice(start, end);
+      if (inVPre) {
+        currentProp.name += "." + mod;
+        setLocEnd(currentProp.nameLoc, end);
+      } else if (currentProp.name === "slot") {
+        const arg = currentProp.arg;
+        if (arg) {
+          arg.content += "." + mod;
+          setLocEnd(arg.loc, end);
+        }
+      } else {
+        currentProp.modifiers.push(mod);
+      }
+    },
+    onattribdata(start, end) {
+      currentAttrValue += getSlice(start, end);
+      if (currentAttrStartIndex < 0)
+        currentAttrStartIndex = start;
+      currentAttrEndIndex = end;
+    },
+    onattribentity(char, start, end) {
+      currentAttrValue += char;
+      if (currentAttrStartIndex < 0)
+        currentAttrStartIndex = start;
+      currentAttrEndIndex = end;
+    },
+    onattribnameend(end) {
+      const start = currentProp.loc.start.offset;
+      const name = getSlice(start, end);
+      if (currentProp.type === 7) {
+        currentProp.rawName = name;
+      }
+      if (currentOpenTag.props.some(
+        (p) => (p.type === 7 ? p.rawName : p.name) === name
+      )) {
+        emitError(2, start);
+      }
+    },
+    onattribend(quote, end) {
+      if (currentOpenTag && currentProp) {
+        setLocEnd(currentProp.loc, end);
+        if (quote !== 0) {
+          if (currentAttrValue.includes("&")) {
+            currentAttrValue = currentOptions.decodeEntities(
+              currentAttrValue,
+              true
+            );
+          }
+          if (currentProp.type === 6) {
+            if (currentProp.name === "class") {
+              currentAttrValue = condense(currentAttrValue).trim();
+            }
+            if (quote === 1 && !currentAttrValue) {
+              emitError(13, end);
+            }
+            currentProp.value = {
+              type: 2,
+              content: currentAttrValue,
+              loc: quote === 1 ? getLoc(currentAttrStartIndex, currentAttrEndIndex) : getLoc(currentAttrStartIndex - 1, currentAttrEndIndex + 1)
+            };
+            if (tokenizer.inSFCRoot && currentOpenTag.tag === "template" && currentProp.name === "lang" && currentAttrValue && currentAttrValue !== "html") {
+              tokenizer.enterRCDATA(toCharCodes(`</template`), 0);
+            }
+          } else {
+            currentProp.exp = createSimpleExpression(
+              currentAttrValue,
+              false,
+              getLoc(currentAttrStartIndex, currentAttrEndIndex)
+            );
+            if (currentProp.name === "for") {
+              currentProp.forParseResult = parseForExpression(currentProp.exp);
+            }
+            let syncIndex = -1;
+            if (currentProp.name === "bind" && (syncIndex = currentProp.modifiers.indexOf("sync")) > -1 && checkCompatEnabled(
+              "COMPILER_V_BIND_SYNC",
+              currentOptions,
+              currentProp.loc,
+              currentProp.rawName
+            )) {
+              currentProp.name = "model";
+              currentProp.modifiers.splice(syncIndex, 1);
+            }
+          }
+        }
+        if (currentProp.type !== 7 || currentProp.name !== "pre") {
+          currentOpenTag.props.push(currentProp);
+        }
       }
-      if (match[1]) {
-        emitError(context, 10);
+      currentAttrValue = "";
+      currentAttrStartIndex = currentAttrEndIndex = -1;
+    },
+    oncomment(start, end) {
+      if (currentOptions.comments) {
+        addNode({
+          type: 3,
+          content: getSlice(start, end),
+          loc: getLoc(start - 4, end + 3)
+        });
       }
-      content = context.source.slice(4, match.index);
-      const s = context.source.slice(0, match.index);
-      let prevIndex = 1, nestedIndex = 0;
-      while ((nestedIndex = s.indexOf("<!--", prevIndex)) !== -1) {
-        advanceBy(context, nestedIndex - prevIndex + 1);
-        if (nestedIndex + 4 < s.length) {
-          emitError(context, 16);
+    },
+    onend() {
+      const end = currentInput.length;
+      if (tokenizer.state !== 1) {
+        switch (tokenizer.state) {
+          case 5:
+          case 8:
+            emitError(5, end);
+            break;
+          case 3:
+          case 4:
+            emitError(
+              25,
+              tokenizer.sectionStart
+            );
+            break;
+          case 28:
+            if (tokenizer.currentSequence === Sequences.CdataEnd) {
+              emitError(6, end);
+            } else {
+              emitError(7, end);
+            }
+            break;
+          case 6:
+          case 7:
+          case 9:
+          case 11:
+          case 12:
+          case 13:
+          case 14:
+          case 15:
+          case 16:
+          case 17:
+          case 18:
+          case 19:
+          case 20:
+          case 21:
+            emitError(9, end);
+            break;
         }
-        prevIndex = nestedIndex + 1;
       }
-      advanceBy(context, match.index + match[0].length - prevIndex + 1);
+      for (let index = 0; index < stack.length; index++) {
+        onCloseTag(stack[index], end - 1);
+        emitError(24, stack[index].loc.start.offset);
+      }
+    },
+    oncdata(start, end) {
+      if (stack[0].ns !== 0) {
+        onText(getSlice(start, end), start, end);
+      } else {
+        emitError(1, start - 9);
+      }
+    },
+    onprocessinginstruction(start) {
+      if ((stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
+        emitError(
+          21,
+          start - 1
+        );
+      }
     }
-    return {
-      type: 3,
-      content,
-      loc: getSelection(context, start)
+  });
+  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
+  const stripParensRE = /^\(|\)$/g;
+  function parseForExpression(input) {
+    const loc = input.loc;
+    const exp = input.content;
+    const inMatch = exp.match(forAliasRE);
+    if (!inMatch)
+      return;
+    const [, LHS, RHS] = inMatch;
+    const createAliasExpression = (content, offset) => {
+      const start = loc.start.offset + offset;
+      const end = start + content.length;
+      return createSimpleExpression(content, false, getLoc(start, end));
     };
+    const result = {
+      source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
+      value: void 0,
+      key: void 0,
+      index: void 0,
+      finalized: false
+    };
+    let valueContent = LHS.trim().replace(stripParensRE, "").trim();
+    const trimmedOffset = LHS.indexOf(valueContent);
+    const iteratorMatch = valueContent.match(forIteratorRE);
+    if (iteratorMatch) {
+      valueContent = valueContent.replace(forIteratorRE, "").trim();
+      const keyContent = iteratorMatch[1].trim();
+      let keyOffset;
+      if (keyContent) {
+        keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
+        result.key = createAliasExpression(keyContent, keyOffset);
+      }
+      if (iteratorMatch[2]) {
+        const indexContent = iteratorMatch[2].trim();
+        if (indexContent) {
+          result.index = createAliasExpression(
+            indexContent,
+            exp.indexOf(
+              indexContent,
+              result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
+            )
+          );
+        }
+      }
+    }
+    if (valueContent) {
+      result.value = createAliasExpression(valueContent, trimmedOffset);
+    }
+    return result;
+  }
+  function getSlice(start, end) {
+    return currentInput.slice(start, end);
   }
-  function parseBogusComment(context) {
-    const start = getCursor(context);
-    const contentStart = context.source[1] === "?" ? 1 : 2;
-    let content;
-    const closeIndex = context.source.indexOf(">");
-    if (closeIndex === -1) {
-      content = context.source.slice(contentStart);
-      advanceBy(context, context.source.length);
+  function endOpenTag(end) {
+    addNode(currentOpenTag);
+    const { tag, ns } = currentOpenTag;
+    if (ns === 0 && currentOptions.isPreTag(tag)) {
+      inPre++;
+    }
+    if (currentOptions.isVoidTag(tag)) {
+      onCloseTag(currentOpenTag, end);
     } else {
-      content = context.source.slice(contentStart, closeIndex);
-      advanceBy(context, closeIndex + 1);
+      stack.unshift(currentOpenTag);
+      if (ns === 1 || ns === 2) {
+        tokenizer.inXML = true;
+      }
     }
-    return {
-      type: 3,
-      content,
-      loc: getSelection(context, start)
-    };
+    currentOpenTag = null;
   }
-  function parseElement(context, ancestors) {
-    const wasInPre = context.inPre;
-    const wasInVPre = context.inVPre;
-    const parent = last(ancestors);
-    const element = parseTag(context, 0 /* Start */, parent);
-    const isPreBoundary = context.inPre && !wasInPre;
-    const isVPreBoundary = context.inVPre && !wasInVPre;
-    if (element.isSelfClosing || context.options.isVoidTag(element.tag)) {
-      if (isPreBoundary) {
-        context.inPre = false;
-      }
-      if (isVPreBoundary) {
-        context.inVPre = false;
-      }
-      return element;
-    }
-    ancestors.push(element);
-    const mode = context.options.getTextMode(element, parent);
-    const children = parseChildren(context, mode, ancestors);
-    ancestors.pop();
+  function onText(content, start, end) {
+    var _a;
+    {
+      const tag = (_a = stack[0]) == null ? void 0 : _a.tag;
+      if (tag !== "script" && tag !== "style" && content.includes("&")) {
+        content = currentOptions.decodeEntities(content, false);
+      }
+    }
+    const parent = stack[0] || currentRoot;
+    const lastNode = parent.children[parent.children.length - 1];
+    if ((lastNode == null ? void 0 : lastNode.type) === 2) {
+      lastNode.content += content;
+      setLocEnd(lastNode.loc, end);
+    } else {
+      parent.children.push({
+        type: 2,
+        content,
+        loc: getLoc(start, end)
+      });
+    }
+  }
+  function onCloseTag(el, end, isImplied = false) {
+    if (isImplied) {
+      setLocEnd(el.loc, backTrack(end, 60));
+    } else {
+      setLocEnd(el.loc, end + fastForward(end) + 1);
+    }
+    if (tokenizer.inSFCRoot) {
+      if (el.children.length) {
+        el.innerLoc.end = extend({}, el.children[el.children.length - 1].loc.end);
+      } else {
+        el.innerLoc.end = extend({}, el.innerLoc.start);
+      }
+      el.innerLoc.source = getSlice(
+        el.innerLoc.start.offset,
+        el.innerLoc.end.offset
+      );
+    }
+    const { tag, ns } = el;
+    if (!inVPre) {
+      if (tag === "slot") {
+        el.tagType = 2;
+      } else if (isFragmentTemplate(el)) {
+        el.tagType = 3;
+      } else if (isComponent(el)) {
+        el.tagType = 1;
+      }
+    }
+    if (!tokenizer.inRCDATA) {
+      el.children = condenseWhitespace(el.children, el.tag);
+    }
+    if (ns === 0 && currentOptions.isPreTag(tag)) {
+      inPre--;
+    }
+    if (currentVPreBoundary === el) {
+      inVPre = false;
+      currentVPreBoundary = null;
+    }
+    if (tokenizer.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
+      tokenizer.inXML = false;
+    }
     {
-      const inlineTemplateProp = element.props.find(
+      const props = el.props;
+      if (isCompatEnabled(
+        "COMPILER_V_IF_V_FOR_PRECEDENCE",
+        currentOptions
+      )) {
+        let hasIf = false;
+        let hasFor = false;
+        for (let i = 0; i < props.length; i++) {
+          const p = props[i];
+          if (p.type === 7) {
+            if (p.name === "if") {
+              hasIf = true;
+            } else if (p.name === "for") {
+              hasFor = true;
+            }
+          }
+          if (hasIf && hasFor) {
+            warnDeprecation(
+              "COMPILER_V_IF_V_FOR_PRECEDENCE",
+              currentOptions,
+              el.loc
+            );
+            break;
+          }
+        }
+      }
+      if (isCompatEnabled(
+        "COMPILER_NATIVE_TEMPLATE",
+        currentOptions
+      ) && el.tag === "template" && !isFragmentTemplate(el)) {
+        warnDeprecation(
+          "COMPILER_NATIVE_TEMPLATE",
+          currentOptions,
+          el.loc
+        );
+        const parent = stack[0] || currentRoot;
+        const index = parent.children.indexOf(el);
+        parent.children.splice(index, 1, ...el.children);
+      }
+      const inlineTemplateProp = props.find(
         (p) => p.type === 6 && p.name === "inline-template"
       );
       if (inlineTemplateProp && checkCompatEnabled(
         "COMPILER_INLINE_TEMPLATE",
-        context,
+        currentOptions,
         inlineTemplateProp.loc
-      )) {
-        const loc = getSelection(context, element.loc.end);
+      ) && el.children.length) {
         inlineTemplateProp.value = {
           type: 2,
-          content: loc.source,
-          loc
-        };
-      }
-    }
-    element.children = children;
-    if (startsWithEndTagOpen(context.source, element.tag)) {
-      parseTag(context, 1 /* End */, parent);
-    } else {
-      emitError(context, 24, 0, element.loc.start);
-      if (context.source.length === 0 && element.tag.toLowerCase() === "script") {
-        const first = children[0];
-        if (first && startsWith(first.loc.source, "<!--")) {
-          emitError(context, 8);
-        }
+          content: getSlice(
+            el.children[0].loc.start.offset,
+            el.children[el.children.length - 1].loc.end.offset
+          ),
+          loc: inlineTemplateProp.loc
+        };
       }
     }
-    element.loc = getSelection(context, element.loc.start);
-    if (isPreBoundary) {
-      context.inPre = false;
-    }
-    if (isVPreBoundary) {
-      context.inVPre = false;
-    }
-    return element;
   }
-  const isSpecialTemplateDirective = /* @__PURE__ */ makeMap(
-    `if,else,else-if,for,slot`
-  );
-  function parseTag(context, type, parent) {
-    const start = getCursor(context);
-    const match = /^<\/?([a-z][^\t\r\n\f />]*)/i.exec(context.source);
-    const tag = match[1];
-    const ns = context.options.getNamespace(tag, parent);
-    advanceBy(context, match[0].length);
-    advanceSpaces(context);
-    const cursor = getCursor(context);
-    const currentSource = context.source;
-    if (context.options.isPreTag(tag)) {
-      context.inPre = true;
-    }
-    let props = parseAttributes(context, type);
-    if (type === 0 /* Start */ && !context.inVPre && props.some((p) => p.type === 7 && p.name === "pre")) {
-      context.inVPre = true;
-      extend(context, cursor);
-      context.source = currentSource;
-      props = parseAttributes(context, type).filter((p) => p.name !== "v-pre");
-    }
-    let isSelfClosing = false;
-    if (context.source.length === 0) {
-      emitError(context, 9);
-    } else {
-      isSelfClosing = startsWith(context.source, "/>");
-      if (type === 1 /* End */ && isSelfClosing) {
-        emitError(context, 4);
-      }
-      advanceBy(context, isSelfClosing ? 2 : 1);
-    }
-    if (type === 1 /* End */) {
-      return;
+  function fastForward(start, c) {
+    let offset = 0;
+    while (currentInput.charCodeAt(start + offset) !== 62 && start + offset < currentInput.length) {
+      offset++;
     }
-    if (isCompatEnabled(
-      "COMPILER_V_IF_V_FOR_PRECEDENCE",
-      context
-    )) {
-      let hasIf = false;
-      let hasFor = false;
+    return offset;
+  }
+  function backTrack(index, c) {
+    let i = index;
+    while (currentInput.charCodeAt(i) !== c && i >= 0)
+      i--;
+    return i;
+  }
+  const specialTemplateDir = /* @__PURE__ */ new Set(["if", "else", "else-if", "for", "slot"]);
+  function isFragmentTemplate({ tag, props }) {
+    if (tag === "template") {
       for (let i = 0; i < props.length; i++) {
-        const p = props[i];
-        if (p.type === 7) {
-          if (p.name === "if") {
-            hasIf = true;
-          } else if (p.name === "for") {
-            hasFor = true;
-          }
-        }
-        if (hasIf && hasFor) {
-          warnDeprecation(
-            "COMPILER_V_IF_V_FOR_PRECEDENCE",
-            context,
-            getSelection(context, start)
-          );
-          break;
-        }
-      }
-    }
-    let tagType = 0;
-    if (!context.inVPre) {
-      if (tag === "slot") {
-        tagType = 2;
-      } else if (tag === "template") {
-        if (props.some(
-          (p) => p.type === 7 && isSpecialTemplateDirective(p.name)
-        )) {
-          tagType = 3;
+        if (props[i].type === 7 && specialTemplateDir.has(props[i].name)) {
+          return true;
         }
-      } else if (isComponent(tag, props, context)) {
-        tagType = 1;
       }
     }
-    return {
-      type: 1,
-      ns,
-      tag,
-      tagType,
-      props,
-      isSelfClosing,
-      children: [],
-      loc: getSelection(context, start),
-      codegenNode: void 0
-      // to be created during transform phase
-    };
+    return false;
   }
-  function isComponent(tag, props, context) {
-    const options = context.options;
-    if (options.isCustomElement(tag)) {
+  function isComponent({ tag, props }) {
+    var _a;
+    if (currentOptions.isCustomElement(tag)) {
       return false;
     }
-    if (tag === "component" || /^[A-Z]/.test(tag) || isCoreComponent(tag) || options.isBuiltInComponent && options.isBuiltInComponent(tag) || options.isNativeTag && !options.isNativeTag(tag)) {
+    if (tag === "component" || isUpperCase(tag.charCodeAt(0)) || isCoreComponent(tag) || ((_a = currentOptions.isBuiltInComponent) == null ? void 0 : _a.call(currentOptions, tag)) || currentOptions.isNativeTag && !currentOptions.isNativeTag(tag)) {
       return true;
     }
     for (let i = 0; i < props.length; i++) {
@@ -13710,374 +14699,179 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
             return true;
           } else if (checkCompatEnabled(
             "COMPILER_IS_ON_ELEMENT",
-            context,
+            currentOptions,
             p.loc
           )) {
             return true;
           }
         }
-      } else {
-        if (p.name === "is") {
-          return true;
-        } else if (
-          // :is on plain element - only treat as component in compat mode
-          p.name === "bind" && isStaticArgOf(p.arg, "is") && true && checkCompatEnabled(
-            "COMPILER_IS_ON_ELEMENT",
-            context,
-            p.loc
-          )
-        ) {
-          return true;
-        }
+      } else if (// :is on plain element - only treat as component in compat mode
+      p.name === "bind" && isStaticArgOf(p.arg, "is") && checkCompatEnabled(
+        "COMPILER_IS_ON_ELEMENT",
+        currentOptions,
+        p.loc
+      )) {
+        return true;
       }
     }
+    return false;
   }
-  function parseAttributes(context, type) {
-    const props = [];
-    const attributeNames = /* @__PURE__ */ new Set();
-    while (context.source.length > 0 && !startsWith(context.source, ">") && !startsWith(context.source, "/>")) {
-      if (startsWith(context.source, "/")) {
-        emitError(context, 22);
-        advanceBy(context, 1);
-        advanceSpaces(context);
-        continue;
-      }
-      if (type === 1 /* End */) {
-        emitError(context, 3);
-      }
-      const attr = parseAttribute(context, attributeNames);
-      if (attr.type === 6 && attr.value && attr.name === "class") {
-        attr.value.content = attr.value.content.replace(/\s+/g, " ").trim();
-      }
-      if (type === 0 /* Start */) {
-        props.push(attr);
-      }
-      if (/^[^\t\r\n\f />]/.test(context.source)) {
-        emitError(context, 15);
-      }
-      advanceSpaces(context);
-    }
-    return props;
+  function isUpperCase(c) {
+    return c > 64 && c < 91;
   }
-  function parseAttribute(context, nameSet) {
-    var _a;
-    const start = getCursor(context);
-    const match = /^[^\t\r\n\f />][^\t\r\n\f />=]*/.exec(context.source);
-    const name = match[0];
-    if (nameSet.has(name)) {
-      emitError(context, 2);
-    }
-    nameSet.add(name);
-    if (name[0] === "=") {
-      emitError(context, 19);
-    }
-    {
-      const pattern = /["'<]/g;
-      let m;
-      while (m = pattern.exec(name)) {
-        emitError(
-          context,
-          17,
-          m.index
-        );
-      }
-    }
-    advanceBy(context, name.length);
-    let value = void 0;
-    if (/^[\t\r\n\f ]*=/.test(context.source)) {
-      advanceSpaces(context);
-      advanceBy(context, 1);
-      advanceSpaces(context);
-      value = parseAttributeValue(context);
-      if (!value) {
-        emitError(context, 13);
-      }
-    }
-    const loc = getSelection(context, start);
-    if (!context.inVPre && /^(v-[A-Za-z0-9-]|:|\.|@|#)/.test(name)) {
-      const match2 = /(?:^v-([a-z0-9-]+))?(?:(?::|^\.|^@|^#)(\[[^\]]+\]|[^\.]+))?(.+)?$/i.exec(
-        name
-      );
-      let isPropShorthand = startsWith(name, ".");
-      let dirName = match2[1] || (isPropShorthand || startsWith(name, ":") ? "bind" : startsWith(name, "@") ? "on" : "slot");
-      let arg;
-      if (match2[2]) {
-        const isSlot = dirName === "slot";
-        const startOffset = name.lastIndexOf(
-          match2[2],
-          name.length - (((_a = match2[3]) == null ? void 0 : _a.length) || 0)
-        );
-        const loc2 = getSelection(
-          context,
-          getNewPosition(context, start, startOffset),
-          getNewPosition(
-            context,
-            start,
-            startOffset + match2[2].length + (isSlot && match2[3] || "").length
-          )
-        );
-        let content = match2[2];
-        let isStatic = true;
-        if (content.startsWith("[")) {
-          isStatic = false;
-          if (!content.endsWith("]")) {
-            emitError(
-              context,
-              27
-            );
-            content = content.slice(1);
-          } else {
-            content = content.slice(1, content.length - 1);
+  const windowsNewlineRE = /\r\n/g;
+  function condenseWhitespace(nodes, tag) {
+    var _a, _b;
+    const shouldCondense = currentOptions.whitespace !== "preserve";
+    let removedWhitespace = false;
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (node.type === 2) {
+        if (!inPre) {
+          if (isAllWhitespace(node.content)) {
+            const prev = (_a = nodes[i - 1]) == null ? void 0 : _a.type;
+            const next = (_b = nodes[i + 1]) == null ? void 0 : _b.type;
+            if (!prev || !next || shouldCondense && (prev === 3 && (next === 3 || next === 1) || prev === 1 && (next === 3 || next === 1 && hasNewlineChar(node.content)))) {
+              removedWhitespace = true;
+              nodes[i] = null;
+            } else {
+              node.content = " ";
+            }
+          } else if (shouldCondense) {
+            node.content = condense(node.content);
           }
-        } else if (isSlot) {
-          content += match2[3] || "";
-        }
-        arg = {
-          type: 4,
-          content,
-          isStatic,
-          constType: isStatic ? 3 : 0,
-          loc: loc2
-        };
-      }
-      if (value && value.isQuoted) {
-        const valueLoc = value.loc;
-        valueLoc.start.offset++;
-        valueLoc.start.column++;
-        valueLoc.end = advancePositionWithClone(valueLoc.start, value.content);
-        valueLoc.source = valueLoc.source.slice(1, -1);
-      }
-      const modifiers = match2[3] ? match2[3].slice(1).split(".") : [];
-      if (isPropShorthand)
-        modifiers.push("prop");
-      if (dirName === "bind" && arg) {
-        if (modifiers.includes("sync") && checkCompatEnabled(
-          "COMPILER_V_BIND_SYNC",
-          context,
-          loc,
-          arg.loc.source
-        )) {
-          dirName = "model";
-          modifiers.splice(modifiers.indexOf("sync"), 1);
-        }
-        if (modifiers.includes("prop")) {
-          checkCompatEnabled(
-            "COMPILER_V_BIND_PROP",
-            context,
-            loc
-          );
+        } else {
+          node.content = node.content.replace(windowsNewlineRE, "\n");
         }
       }
-      return {
-        type: 7,
-        name: dirName,
-        exp: value && {
-          type: 4,
-          content: value.content,
-          isStatic: false,
-          // Treat as non-constant by default. This can be potentially set to
-          // other values by `transformExpression` to make it eligible for hoisting.
-          constType: 0,
-          loc: value.loc
-        },
-        arg,
-        modifiers,
-        loc
-      };
     }
-    if (!context.inVPre && startsWith(name, "v-")) {
-      emitError(context, 26);
+    if (inPre && tag && currentOptions.isPreTag(tag)) {
+      const first = nodes[0];
+      if (first && first.type === 2) {
+        first.content = first.content.replace(/^\r?\n/, "");
+      }
     }
-    return {
-      type: 6,
-      name,
-      value: value && {
-        type: 2,
-        content: value.content,
-        loc: value.loc
-      },
-      loc
-    };
+    return removedWhitespace ? nodes.filter(Boolean) : nodes;
   }
-  function parseAttributeValue(context) {
-    const start = getCursor(context);
-    let content;
-    const quote = context.source[0];
-    const isQuoted = quote === `"` || quote === `'`;
-    if (isQuoted) {
-      advanceBy(context, 1);
-      const endIndex = context.source.indexOf(quote);
-      if (endIndex === -1) {
-        content = parseTextData(
-          context,
-          context.source.length,
-          4
-        );
-      } else {
-        content = parseTextData(context, endIndex, 4);
-        advanceBy(context, 1);
-      }
-    } else {
-      const match = /^[^\t\r\n\f >]+/.exec(context.source);
-      if (!match) {
-        return void 0;
-      }
-      const unexpectedChars = /["'<=`]/g;
-      let m;
-      while (m = unexpectedChars.exec(match[0])) {
-        emitError(
-          context,
-          18,
-          m.index
-        );
+  function isAllWhitespace(str) {
+    for (let i = 0; i < str.length; i++) {
+      if (!isWhitespace(str.charCodeAt(i))) {
+        return false;
       }
-      content = parseTextData(context, match[0].length, 4);
-    }
-    return { content, isQuoted, loc: getSelection(context, start) };
-  }
-  function parseInterpolation(context, mode) {
-    const [open, close] = context.options.delimiters;
-    const closeIndex = context.source.indexOf(close, open.length);
-    if (closeIndex === -1) {
-      emitError(context, 25);
-      return void 0;
-    }
-    const start = getCursor(context);
-    advanceBy(context, open.length);
-    const innerStart = getCursor(context);
-    const innerEnd = getCursor(context);
-    const rawContentLength = closeIndex - open.length;
-    const rawContent = context.source.slice(0, rawContentLength);
-    const preTrimContent = parseTextData(context, rawContentLength, mode);
-    const content = preTrimContent.trim();
-    const startOffset = preTrimContent.indexOf(content);
-    if (startOffset > 0) {
-      advancePositionWithMutation(innerStart, rawContent, startOffset);
-    }
-    const endOffset = rawContentLength - (preTrimContent.length - content.length - startOffset);
-    advancePositionWithMutation(innerEnd, rawContent, endOffset);
-    advanceBy(context, close.length);
-    return {
-      type: 5,
-      content: {
-        type: 4,
-        isStatic: false,
-        // Set `isConstant` to false by default and will decide in transformExpression
-        constType: 0,
-        content,
-        loc: getSelection(context, innerStart, innerEnd)
-      },
-      loc: getSelection(context, start)
-    };
+    }
+    return true;
   }
-  function parseText(context, mode) {
-    const endTokens = mode === 3 ? ["]]>"] : ["<", context.options.delimiters[0]];
-    let endIndex = context.source.length;
-    for (let i = 0; i < endTokens.length; i++) {
-      const index = context.source.indexOf(endTokens[i], 1);
-      if (index !== -1 && endIndex > index) {
-        endIndex = index;
+  function hasNewlineChar(str) {
+    for (let i = 0; i < str.length; i++) {
+      const c = str.charCodeAt(i);
+      if (c === 10 || c === 13) {
+        return true;
       }
     }
-    const start = getCursor(context);
-    const content = parseTextData(context, endIndex, mode);
-    return {
-      type: 2,
-      content,
-      loc: getSelection(context, start)
-    };
+    return false;
   }
-  function parseTextData(context, length, mode) {
-    const rawText = context.source.slice(0, length);
-    advanceBy(context, length);
-    if (mode === 2 || mode === 3 || !rawText.includes("&")) {
-      return rawText;
-    } else {
-      return context.options.decodeEntities(
-        rawText,
-        mode === 4
-      );
+  function condense(str) {
+    let ret = "";
+    let prevCharIsWhitespace = false;
+    for (let i = 0; i < str.length; i++) {
+      if (isWhitespace(str.charCodeAt(i))) {
+        if (!prevCharIsWhitespace) {
+          ret += " ";
+          prevCharIsWhitespace = true;
+        }
+      } else {
+        ret += str[i];
+        prevCharIsWhitespace = false;
+      }
     }
+    return ret;
   }
-  function getCursor(context) {
-    const { column, line, offset } = context;
-    return { column, line, offset };
+  function addNode(node) {
+    (stack[0] || currentRoot).children.push(node);
   }
-  function getSelection(context, start, end) {
-    end = end || getCursor(context);
+  function getLoc(start, end) {
     return {
-      start,
-      end,
-      source: context.originalSource.slice(start.offset, end.offset)
+      start: tokenizer.getPos(start),
+      // @ts-expect-error allow late attachment
+      end: end == null ? end : tokenizer.getPos(end),
+      // @ts-expect-error allow late attachment
+      source: end == null ? end : getSlice(start, end)
     };
   }
-  function last(xs) {
-    return xs[xs.length - 1];
-  }
-  function startsWith(source, searchString) {
-    return source.startsWith(searchString);
+  function setLocEnd(loc, end) {
+    loc.end = tokenizer.getPos(end);
+    loc.source = getSlice(loc.start.offset, end);
   }
-  function advanceBy(context, numberOfCharacters) {
-    const { source } = context;
-    advancePositionWithMutation(context, source, numberOfCharacters);
-    context.source = source.slice(numberOfCharacters);
-  }
-  function advanceSpaces(context) {
-    const match = /^[\t\r\n\f ]+/.exec(context.source);
-    if (match) {
-      advanceBy(context, match[0].length);
+  function dirToAttr(dir) {
+    const attr = {
+      type: 6,
+      name: dir.rawName,
+      nameLoc: getLoc(
+        dir.loc.start.offset,
+        dir.loc.start.offset + dir.rawName.length
+      ),
+      value: void 0,
+      loc: dir.loc
+    };
+    if (dir.exp) {
+      const loc = dir.exp.loc;
+      if (loc.end.offset < dir.loc.end.offset) {
+        loc.start.offset--;
+        loc.start.column--;
+        loc.end.offset++;
+        loc.end.column++;
+      }
+      attr.value = {
+        type: 2,
+        content: dir.exp.content,
+        loc
+      };
     }
+    return attr;
   }
-  function getNewPosition(context, start, numberOfCharacters) {
-    return advancePositionWithClone(
-      start,
-      context.originalSource.slice(start.offset, numberOfCharacters),
-      numberOfCharacters
-    );
+  function emitError(code, index) {
+    currentOptions.onError(createCompilerError(code, getLoc(index, index)));
   }
-  function emitError(context, code, offset, loc = getCursor(context)) {
-    if (offset) {
-      loc.offset += offset;
-      loc.column += offset;
-    }
-    context.options.onError(
-      createCompilerError(code, {
-        start: loc,
-        end: loc,
-        source: ""
-      })
-    );
+  function reset() {
+    tokenizer.reset();
+    currentOpenTag = null;
+    currentProp = null;
+    currentAttrValue = "";
+    currentAttrStartIndex = -1;
+    currentAttrEndIndex = -1;
+    stack.length = 0;
   }
-  function isEnd(context, mode, ancestors) {
-    const s = context.source;
-    switch (mode) {
-      case 0:
-        if (startsWith(s, "</")) {
-          for (let i = ancestors.length - 1; i >= 0; --i) {
-            if (startsWithEndTagOpen(s, ancestors[i].tag)) {
-              return true;
-            }
-          }
-        }
-        break;
-      case 1:
-      case 2: {
-        const parent = last(ancestors);
-        if (parent && startsWithEndTagOpen(s, parent.tag)) {
-          return true;
+  function baseParse(input, options) {
+    reset();
+    currentInput = input;
+    currentOptions = extend({}, defaultParserOptions);
+    if (options) {
+      let key;
+      for (key in options) {
+        if (options[key] != null) {
+          currentOptions[key] = options[key];
         }
-        break;
       }
-      case 3:
-        if (startsWith(s, "]]>")) {
-          return true;
-        }
-        break;
     }
-    return !s;
-  }
-  function startsWithEndTagOpen(source, tag) {
-    return startsWith(source, "</") && source.slice(2, 2 + tag.length).toLowerCase() === tag.toLowerCase() && /[\t\r\n\f />]/.test(source[2 + tag.length] || ">");
+    {
+      if (!currentOptions.decodeEntities) {
+        throw new Error(
+          `[@vue/compiler-core] decodeEntities option is required in browser builds.`
+        );
+      }
+    }
+    tokenizer.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
+    const delimiters = options == null ? void 0 : options.delimiters;
+    if (delimiters) {
+      tokenizer.delimiterOpen = toCharCodes(delimiters[0]);
+      tokenizer.delimiterClose = toCharCodes(delimiters[1]);
+    }
+    const root = currentRoot = createRoot([], input);
+    tokenizer.parse(currentInput);
+    root.loc = getLoc(0, input.length);
+    root.children = condenseWhitespace(root.children);
+    currentRoot = null;
+    return root;
   }
 
   function hoistStatic(root, context) {
@@ -14489,6 +15283,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     root.hoists = context.hoists;
     root.temps = context.temps;
     root.cached = context.cached;
+    root.transformed = true;
     {
       root.filters = [...context.filters];
     }
@@ -14645,7 +15440,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       ssr,
       isTS,
       inSSR,
-      source: ast.loc.source,
+      source: ast.source,
       code: ``,
       column: 1,
       line: 1,
@@ -14656,7 +15451,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       helper(key) {
         return `_${helperNameMap[key]}`;
       },
-      push(code, node) {
+      push(code, newlineIndex = -2 /* None */, node) {
         context.code += code;
       },
       indent() {
@@ -14674,7 +15469,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       }
     };
     function newline(n) {
-      context.push("\n" + `  `.repeat(n));
+      context.push("\n" + `  `.repeat(n), 0 /* Start */);
     }
     return context;
   }
@@ -14711,9 +15506,11 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       push(`with (_ctx) {`);
       indent();
       if (hasHelpers) {
-        push(`const { ${helpers.map(aliasHelper).join(", ")} } = _Vue`);
-        push(`
-`);
+        push(
+          `const { ${helpers.map(aliasHelper).join(", ")} } = _Vue
+`,
+          -1 /* End */
+        );
         newline();
       }
     }
@@ -14742,7 +15539,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     }
     if (ast.components.length || ast.directives.length || ast.temps) {
       push(`
-`);
+`, 0 /* Start */);
       newline();
     }
     if (!ssr) {
@@ -14763,7 +15560,6 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       ast,
       code: context.code,
       preamble: isSetupInlined ? preambleContext.code : ``,
-      // SourceMapGenerator does have toJSON() method but it's not in the types
       map: context.map ? context.map.toJSON() : void 0
     };
   }
@@ -14782,7 +15578,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (helpers.length > 0) {
       {
         push(`const _Vue = ${VueBinding}
-`);
+`, -1 /* End */);
         if (ast.hoists.length) {
           const staticHelpers = [
             CREATE_VNODE,
@@ -14792,7 +15588,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
             CREATE_STATIC
           ].filter((helper) => helpers.includes(helper)).map(aliasHelper).join(", ");
           push(`const { ${staticHelpers} } = _Vue
-`);
+`, -1 /* End */);
         }
       }
     }
@@ -14853,7 +15649,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
       if (isString(node)) {
-        push(node);
+        push(node, -3 /* Unknown */);
       } else if (isArray(node)) {
         genNodeListAsArray(node, context);
       } else {
@@ -14871,7 +15667,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   }
   function genNode(node, context) {
     if (isString(node)) {
-      context.push(node);
+      context.push(node, -3 /* Unknown */);
       return;
     }
     if (isSymbol(node)) {
@@ -14951,11 +15747,15 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     }
   }
   function genText(node, context) {
-    context.push(JSON.stringify(node.content), node);
+    context.push(JSON.stringify(node.content), -3 /* Unknown */, node);
   }
   function genExpression(node, context) {
     const { content, isStatic } = node;
-    context.push(isStatic ? JSON.stringify(content) : content, node);
+    context.push(
+      isStatic ? JSON.stringify(content) : content,
+      -3 /* Unknown */,
+      node
+    );
   }
   function genInterpolation(node, context) {
     const { push, helper, pure } = context;
@@ -14969,7 +15769,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     for (let i = 0; i < node.children.length; i++) {
       const child = node.children[i];
       if (isString(child)) {
-        context.push(child);
+        context.push(child, -3 /* Unknown */);
       } else {
         genNode(child, context);
       }
@@ -14983,9 +15783,9 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       push(`]`);
     } else if (node.isStatic) {
       const text = isSimpleIdentifier(node.content) ? node.content : JSON.stringify(node.content);
-      push(text, node);
+      push(text, -2 /* None */, node);
     } else {
-      push(`[${node.content}]`, node);
+      push(`[${node.content}]`, -3 /* Unknown */, node);
     }
   }
   function genComment(node, context) {
@@ -14993,7 +15793,11 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (pure) {
       push(PURE_ANNOTATION);
     }
-    push(`${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`, node);
+    push(
+      `${helper(CREATE_COMMENT)}(${JSON.stringify(node.content)})`,
+      -3 /* Unknown */,
+      node
+    );
   }
   function genVNodeCall(node, context) {
     const { push, helper, pure } = context;
@@ -15018,7 +15822,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       push(PURE_ANNOTATION);
     }
     const callHelper = isBlock ? getVNodeBlockHelper(context.inSSR, isComponent) : getVNodeHelper(context.inSSR, isComponent);
-    push(helper(callHelper) + `(`, node);
+    push(helper(callHelper) + `(`, -2 /* None */, node);
     genNodeList(
       genNullableArgs([tag, props, children, patchFlag, dynamicProps]),
       context
@@ -15047,7 +15851,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (pure) {
       push(PURE_ANNOTATION);
     }
-    push(callee + `(`, node);
+    push(callee + `(`, -2 /* None */, node);
     genNodeList(node.arguments, context);
     push(`)`);
   }
@@ -15055,7 +15859,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     const { push, indent, deindent, newline } = context;
     const { properties } = node;
     if (!properties.length) {
-      push(`{}`, node);
+      push(`{}`, -2 /* None */, node);
       return;
     }
     const multilines = properties.length > 1 || properties.some((p) => p.value.type !== 4);
@@ -15083,7 +15887,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (isSlot) {
       push(`_${helperNameMap[WITH_CTX]}(`);
     }
-    push(`(`, node);
+    push(`(`, -2 /* None */, node);
     if (isArray(params)) {
       genNodeList(params, context);
     } else if (params) {
@@ -15317,7 +16121,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
           context.removeNode();
           const branch = createIfBranch(node, dir);
           if (comments.length && // #3619 ignore comments if the v-if is direct child of <transition>
-          !(context.parent && context.parent.type === 1 && isBuiltInType(context.parent.tag, "transition"))) {
+          !(context.parent && context.parent.type === 1 && (context.parent.tag === "transition" || context.parent.tag === "Transition"))) {
             branch.children = [...comments, ...branch.children];
           }
           {
@@ -15599,18 +16403,14 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       );
       return;
     }
-    const parseResult = parseForExpression(
-      // can only be simple expression because vFor transform is applied
-      // before expression transform.
-      dir.exp,
-      context
-    );
+    const parseResult = dir.forParseResult;
     if (!parseResult) {
       context.onError(
         createCompilerError(32, dir.loc)
       );
       return;
     }
+    finalizeForParseResult(parseResult, context);
     const { addIdentifiers, removeIdentifiers, scopes } = context;
     const { source, value, key, index } = parseResult;
     const forNode = {
@@ -15632,70 +16432,26 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         onExit();
     };
   }
-  const forIteratorRE = /,([^,\}\]]*)(?:,([^,\}\]]*))?$/;
-  const stripParensRE = /^\(|\)$/g;
-  function parseForExpression(input, context) {
-    const loc = input.loc;
-    const exp = input.content;
-    const inMatch = exp.match(forAliasRE);
-    if (!inMatch)
+  function finalizeForParseResult(result, context) {
+    if (result.finalized)
       return;
-    const [, LHS, RHS] = inMatch;
-    const result = {
-      source: createAliasExpression(
-        loc,
-        RHS.trim(),
-        exp.indexOf(RHS, LHS.length)
-      ),
-      value: void 0,
-      key: void 0,
-      index: void 0
-    };
     {
       validateBrowserExpression(result.source, context);
-    }
-    let valueContent = LHS.trim().replace(stripParensRE, "").trim();
-    const trimmedOffset = LHS.indexOf(valueContent);
-    const iteratorMatch = valueContent.match(forIteratorRE);
-    if (iteratorMatch) {
-      valueContent = valueContent.replace(forIteratorRE, "").trim();
-      const keyContent = iteratorMatch[1].trim();
-      let keyOffset;
-      if (keyContent) {
-        keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
-        result.key = createAliasExpression(loc, keyContent, keyOffset);
-        {
-          validateBrowserExpression(
-            result.key,
-            context,
-            true
-          );
-        }
+      if (result.key) {
+        validateBrowserExpression(
+          result.key,
+          context,
+          true
+        );
       }
-      if (iteratorMatch[2]) {
-        const indexContent = iteratorMatch[2].trim();
-        if (indexContent) {
-          result.index = createAliasExpression(
-            loc,
-            indexContent,
-            exp.indexOf(
-              indexContent,
-              result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
-            )
-          );
-          {
-            validateBrowserExpression(
-              result.index,
-              context,
-              true
-            );
-          }
-        }
+      if (result.index) {
+        validateBrowserExpression(
+          result.index,
+          context,
+          true
+        );
       }
-    }
-    if (valueContent) {
-      result.value = createAliasExpression(loc, valueContent, trimmedOffset);
-      {
+      if (result.value) {
         validateBrowserExpression(
           result.value,
           context,
@@ -15703,14 +16459,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         );
       }
     }
-    return result;
-  }
-  function createAliasExpression(range, content, offset) {
-    return createSimpleExpression(
-      content,
-      false,
-      getInnerRange(range, offset, content.length)
-    );
+    result.finalized = true;
   }
   function createForLoopParams({ value, key, index }, memoArgs = []) {
     return createParamsList([value, key, index, ...memoArgs]);
@@ -15797,12 +16546,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         hasDynamicSlots = true;
       }
       const vFor = findDir(slotElement, "for");
-      const slotFunction = buildSlotFn(
-        slotProps,
-        vFor == null ? void 0 : vFor.exp,
-        slotChildren,
-        slotLoc
-      );
+      const slotFunction = buildSlotFn(slotProps, vFor, slotChildren, slotLoc);
       let vIf;
       let vElse;
       if (vIf = findDir(slotElement, "if")) {
@@ -15851,8 +16595,9 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
       } else if (vFor) {
         hasDynamicSlots = true;
-        const parseResult = vFor.parseResult || parseForExpression(vFor.exp, context);
+        const parseResult = vFor.forParseResult;
         if (parseResult) {
+          finalizeForParseResult(parseResult, context);
           dynamicSlots.push(
             createCallExpression(context.helper(RENDER_LIST), [
               parseResult.source,
@@ -16113,17 +16858,6 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         tag = isProp.value.content.slice(4);
       }
     }
-    const isDir = !isExplicitDynamic && findDir(node, "is");
-    if (isDir && isDir.exp) {
-      {
-        context.onWarn(
-          createCompilerError(52, isDir.loc)
-        );
-      }
-      return createCallExpression(context.helper(RESOLVE_DYNAMIC_COMPONENT), [
-        isDir.exp
-      ]);
-    }
     const builtIn = isCoreComponent(tag) || context.isBuiltInComponent(tag);
     if (builtIn) {
       if (!ssr)
@@ -16195,7 +16929,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     for (let i = 0; i < props.length; i++) {
       const prop = props[i];
       if (prop.type === 6) {
-        const { loc, name, value } = prop;
+        const { loc, name, nameLoc, value } = prop;
         let isStatic = true;
         if (name === "ref") {
           hasRef = true;
@@ -16216,11 +16950,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
         properties.push(
           createObjectProperty(
-            createSimpleExpression(
-              name,
-              true,
-              getInnerRange(loc, 0, name.length)
-            ),
+            createSimpleExpression(name, true, nameLoc),
             createSimpleExpression(
               value ? value.content : "",
               isStatic,
@@ -16702,8 +17432,13 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
   };
 
   const transformBind = (dir, _node, context) => {
-    const { exp, modifiers, loc } = dir;
+    const { modifiers, loc } = dir;
     const arg = dir.arg;
+    let { exp } = dir;
+    if (!exp && arg.type === 4) {
+      const propName = camelize(arg.content);
+      exp = dir.exp = createSimpleExpression(propName, false, arg.loc);
+    }
     if (arg.type !== 4) {
       arg.children.unshift(`(`);
       arg.children.push(`) || ""`);
@@ -17102,7 +17837,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
       }
     ];
   }
-  function baseCompile(template, options = {}) {
+  function baseCompile(source, options = {}) {
     const onError = options.onError || defaultOnError;
     const isModuleMode = options.mode === "module";
     {
@@ -17119,7 +17854,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     if (options.scopeId && !isModuleMode) {
       onError(createCompilerError(50));
     }
-    const ast = isString(template) ? baseParse(template, options) : template;
+    const ast = isString(source) ? baseParse(source, options) : source;
     const [nodeTransforms, directiveTransforms] = getBaseTransformPreset();
     transform(
       ast,
@@ -17185,25 +17920,22 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     }
   }
 
-  const isRawTextContainer = /* @__PURE__ */ makeMap(
-    "style,iframe,script,noscript",
-    true
-  );
   const parserOptions = {
+    parseMode: "html",
     isVoidTag,
     isNativeTag: (tag) => isHTMLTag(tag) || isSVGTag(tag),
     isPreTag: (tag) => tag === "pre",
     decodeEntities: decodeHtmlBrowser ,
     isBuiltInComponent: (tag) => {
-      if (isBuiltInType(tag, `Transition`)) {
+      if (tag === "Transition" || tag === "transition") {
         return TRANSITION;
-      } else if (isBuiltInType(tag, `TransitionGroup`)) {
+      } else if (tag === "TransitionGroup" || tag === "transition-group") {
         return TRANSITION_GROUP;
       }
     },
     // https://html.spec.whatwg.org/multipage/parsing.html#tree-construction-dispatcher
-    getNamespace(tag, parent) {
-      let ns = parent ? parent.ns : 0;
+    getNamespace(tag, parent, rootNamespace) {
+      let ns = parent ? parent.ns : rootNamespace;
       if (parent && ns === 2) {
         if (parent.tag === "annotation-xml") {
           if (tag === "svg") {
@@ -17231,18 +17963,6 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
         }
       }
       return ns;
-    },
-    // https://html.spec.whatwg.org/multipage/parsing.html#parsing-html-fragments
-    getTextMode({ tag, ns }) {
-      if (ns === 0) {
-        if (tag === "textarea" || tag === "title") {
-          return 1;
-        }
-        if (isRawTextContainer(tag)) {
-          return 2;
-        }
-      }
-      return 0;
     }
   };
 
@@ -17563,6 +18283,7 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
                 node.props.push({
                   type: 6,
                   name: "persisted",
+                  nameLoc: node.loc,
                   value: void 0,
                   loc: node.loc
                 });
@@ -17607,9 +18328,9 @@ Use a v-bind binding combined with a v-on listener that emits update:x event ins
     // override compiler-core
     show: transformShow
   };
-  function compile(template, options = {}) {
+  function compile(src, options = {}) {
     return baseCompile(
-      template,
+      src,
       extend({}, parserOptions, options, {
         nodeTransforms: [
           // ignore <script> and <tag>