@vue/compat 3.2.9 → 3.2.13

package/dist/vue.cjs.prod.js

@@ -1,10 +1,7 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var types = require('@babel/types');
-var estreeWalker = require('estree-walker');
 var parser = require('@babel/parser');
+var estreeWalker = require('estree-walker');
 var sourceMap = require('source-map');
 
 /**
@@ -1479,7 +1476,8 @@ class ComputedRefImpl {
 function computed(getterOrOptions, debugOptions) {
     let getter;
     let setter;
-    if (isFunction(getterOrOptions)) {
+    const onlyGetter = isFunction(getterOrOptions);
+    if (onlyGetter) {
         getter = getterOrOptions;
         setter = NOOP;
     }
@@ -1487,7 +1485,7 @@ function computed(getterOrOptions, debugOptions) {
         getter = getterOrOptions.get;
         setter = getterOrOptions.set;
     }
-    const cRef = new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set);
+    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter);
     return cRef;
 }
 
@@ -1852,21 +1850,14 @@ function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // true onl
     return renderFnWithContext;
 }
 
-/**
- * dev only flag to track whether $attrs was used during render.
- * If $attrs was used during render then the warning for failed attrs
- * fallthrough can be suppressed.
- */
-let accessedAttrs = false;
 function markAttrsAccessed() {
-    accessedAttrs = true;
 }
 function renderComponentRoot(instance) {
     const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance;
     let result;
+    let fallthroughAttrs;
     const prev = setCurrentRenderingInstance(instance);
     try {
-        let fallthroughAttrs;
         if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) {
             // withProxy is a proxy with a different `has` trap only for
             // runtime-compiled render functions using `with` block.
@@ -1895,95 +1886,57 @@ function renderComponentRoot(instance) {
                 ? attrs
                 : getFunctionalFallthrough(attrs);
         }
-        // attr merging
-        // in dev mode, comments are preserved, and it's possible for a template
-        // to have comments along side the root element which makes it a fragment
-        let root = result;
-        let setRoot = undefined;
-        if (false &&
-            result.patchFlag > 0 &&
-            result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) ;
-        if (fallthroughAttrs && inheritAttrs !== false) {
-            const keys = Object.keys(fallthroughAttrs);
-            const { shapeFlag } = root;
-            if (keys.length) {
-                if (shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
-                    if (propsOptions && keys.some(isModelListener)) {
-                        // If a v-model listener (onUpdate:xxx) has a corresponding declared
-                        // prop, it indicates this component expects to handle v-model and
-                        // it should not fallthrough.
-                        // related: #1543, #1643, #1989
-                        fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
-                    }
-                    root = cloneVNode(root, fallthroughAttrs);
-                }
-                else if (false && !accessedAttrs && root.type !== Comment) ;
-            }
-        }
-        if (true &&
-            isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) &&
-            vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ &&
-            root.shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
-            const { class: cls, style } = vnode.props || {};
-            if (cls || style) {
-                if (false && inheritAttrs === false) ;
-                root = cloneVNode(root, {
-                    class: cls,
-                    style: style
-                });
-            }
-        }
-        // inherit directives
-        if (vnode.dirs) {
-            if (false && !isElementRoot(root)) ;
-            root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
-        }
-        // inherit transition data
-        if (vnode.transition) {
-            if (false && !isElementRoot(root)) ;
-            root.transition = vnode.transition;
-        }
-        if (false && setRoot) ;
-        else {
-            result = root;
-        }
     }
     catch (err) {
         blockStack.length = 0;
         handleError(err, instance, 1 /* RENDER_FUNCTION */);
         result = createVNode(Comment);
     }
+    // attr merging
+    // in dev mode, comments are preserved, and it's possible for a template
+    // to have comments along side the root element which makes it a fragment
+    let root = result;
+    if (fallthroughAttrs && inheritAttrs !== false) {
+        const keys = Object.keys(fallthroughAttrs);
+        const { shapeFlag } = root;
+        if (keys.length) {
+            if (shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
+                if (propsOptions && keys.some(isModelListener)) {
+                    // If a v-model listener (onUpdate:xxx) has a corresponding declared
+                    // prop, it indicates this component expects to handle v-model and
+                    // it should not fallthrough.
+                    // related: #1543, #1643, #1989
+                    fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions);
+                }
+                root = cloneVNode(root, fallthroughAttrs);
+            }
+        }
+    }
+    if (isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) &&
+        vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ &&
+        root.shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
+        const { class: cls, style } = vnode.props || {};
+        if (cls || style) {
+            root = cloneVNode(root, {
+                class: cls,
+                style: style
+            });
+        }
+    }
+    // inherit directives
+    if (vnode.dirs) {
+        root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+    }
+    // inherit transition data
+    if (vnode.transition) {
+        root.transition = vnode.transition;
+    }
+    {
+        result = root;
+    }
     setCurrentRenderingInstance(prev);
     return result;
 }
-/**
- * dev only
- * In dev mode, template root level comments are rendered, which turns the
- * template into a fragment root, but we need to locate the single element
- * root for attrs and scope id processing.
- */
-const getChildRoot = (vnode) => {
-    const rawChildren = vnode.children;
-    const dynamicChildren = vnode.dynamicChildren;
-    const childRoot = filterSingleRoot(rawChildren);
-    if (!childRoot) {
-        return [vnode, undefined];
-    }
-    const index = rawChildren.indexOf(childRoot);
-    const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1;
-    const setRoot = (updatedRoot) => {
-        rawChildren[index] = updatedRoot;
-        if (dynamicChildren) {
-            if (dynamicIndex > -1) {
-                dynamicChildren[dynamicIndex] = updatedRoot;
-            }
-            else if (updatedRoot.patchFlag > 0) {
-                vnode.dynamicChildren = [...dynamicChildren, updatedRoot];
-            }
-        }
-    };
-    return [normalizeVNode(childRoot), setRoot];
-};
 function filterSingleRoot(children) {
     let singleRoot;
     for (let i = 0; i < children.length; i++) {
@@ -2024,11 +1977,6 @@ const filterModelListeners = (attrs, props) => {
     }
     return res;
 };
-const isElementRoot = (vnode) => {
-    return (vnode.shapeFlag & (6 /* COMPONENT */ | 1 /* ELEMENT */) ||
-        vnode.type === Comment // potential v-if branch switch
-    );
-};
 function shouldUpdateComponent(prevVNode, nextVNode, optimized) {
     const { props: prevProps, children: prevChildren, component } = prevVNode;
     const { props: nextProps, children: nextChildren, patchFlag } = nextVNode;
@@ -2459,8 +2407,8 @@ function normalizeSuspenseChildren(vnode) {
 function normalizeSuspenseSlot(s) {
     let block;
     if (isFunction(s)) {
-        const isCompiledSlot = s._c;
-        if (isCompiledSlot) {
+        const trackBlock = isBlockTreeEnabled && s._c;
+        if (trackBlock) {
             // disableTracking: false
             // allow block tracking for compiled slots
             // (see ./componentRenderContext.ts)
@@ -2468,7 +2416,7 @@ function normalizeSuspenseSlot(s) {
             openBlock();
         }
         s = s();
-        if (isCompiledSlot) {
+        if (trackBlock) {
             s._d = true;
             block = currentBlock;
             closeBlock();
@@ -4285,7 +4233,7 @@ function createCompatVue(createApp, createSingletonApp) {
             return vm;
         }
     }
-    Vue.version = "3.2.9";
+    Vue.version = "3.2.13";
     Vue.config = singletonApp.config;
     Vue.use = (p, ...options) => {
         if (p && isFunction(p.install)) {
@@ -4741,7 +4689,7 @@ function createAppAPI(render, hydrate) {
                     isMounted = true;
                     app._container = rootContainer;
                     rootContainer.__vue_app__ = app;
-                    return vnode.component.proxy;
+                    return getExposeProxy(vnode.component) || vnode.component.proxy;
                 }
             },
             unmount() {
@@ -4926,14 +4874,14 @@ function createHydrationFunctions(rendererInternals) {
                     for (const key in props) {
                         if ((forcePatchValue && key.endsWith('value')) ||
                             (isOn(key) && !isReservedProp(key))) {
-                            patchProp(el, key, null, props[key]);
+                            patchProp(el, key, null, props[key], false, undefined, parentComponent);
                         }
                     }
                 }
                 else if (props.onClick) {
                     // Fast path for click listeners (which is most often) to avoid
                     // iterating through props.
-                    patchProp(el, 'onClick', null, props.onClick);
+                    patchProp(el, 'onClick', null, props.onClick, false, undefined, parentComponent);
                 }
             }
             // vnode / directive hooks
@@ -8383,7 +8331,6 @@ let postFlushIndex = 0;
 const resolvedPromise = Promise.resolve();
 let currentFlushPromise = null;
 let currentPreFlushParentJob = null;
-const RECURSION_LIMIT = 100;
 function nextTick(fn) {
     const p = currentFlushPromise || resolvedPromise;
     return fn ? p.then(this ? fn.bind(this) : fn) : p;
@@ -8501,11 +8448,17 @@ function flushJobs(seen) {
     // 2. If a component is unmounted during a parent component's update,
     //    its update can be skipped.
     queue.sort((a, b) => getId(a) - getId(b));
+    // conditional usage of checkRecursiveUpdate must be determined out of
+    // try ... catch block since Rollup by default de-optimizes treeshaking
+    // inside try-catch. This can leave all warning code unshaked. Although
+    // they would get eventually shaken by a minifier like terser, some minifiers
+    // would fail to do that (e.g. https://github.com/evanw/esbuild/issues/1610)
+    const check = NOOP;
     try {
         for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
             const job = queue[flushIndex];
             if (job && job.active !== false) {
-                if (false && checkRecursiveUpdates(seen, job)) ;
+                if (false && check(job)) ;
                 // console.log(`running:`, job.id)
                 callWithErrorHandling(job, null, 14 /* SCHEDULER */);
             }
@@ -8525,27 +8478,6 @@ function flushJobs(seen) {
             flushJobs(seen);
         }
     }
-}
-function checkRecursiveUpdates(seen, fn) {
-    if (!seen.has(fn)) {
-        seen.set(fn, 1);
-    }
-    else {
-        const count = seen.get(fn);
-        if (count > RECURSION_LIMIT) {
-            const instance = fn.ownerInstance;
-            const componentName = instance && getComponentName(instance.type);
-            warn(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. ` +
-                `This means you have a reactive effect that is mutating its own ` +
-                `dependencies and thus recursively triggering itself. Possible sources ` +
-                `include component template, render function, updated hook or ` +
-                `watcher source function.`);
-            return true;
-        }
-        else {
-            seen.set(fn, count + 1);
-        }
-    }
 }
 
 // Simple effect.
@@ -8769,7 +8701,7 @@ function createPathGetter(ctx, path) {
         return cur;
     };
 }
-function traverse(value, seen = new Set()) {
+function traverse(value, seen) {
     if (!isObject(value) || value["__v_skip" /* SKIP */]) {
         return value;
     }
@@ -8978,7 +8910,7 @@ function isMemoSame(cached, memo) {
 }
 
 // Core API ------------------------------------------------------------------
-const version = "3.2.9";
+const version = "3.2.13";
 const _ssrUtils = {
     createComponentInstance,
     setupComponent,
@@ -9115,19 +9047,13 @@ function patchClass(el, value, isSVG) {
 
 function patchStyle(el, prev, next) {
     const style = el.style;
+    const currentDisplay = style.display;
     if (!next) {
         el.removeAttribute('style');
     }
     else if (isString(next)) {
         if (prev !== next) {
-            const current = style.display;
             style.cssText = next;
-            // indicates that the `display` of the element is controlled by `v-show`,
-            // so we always keep the current `display` value regardless of the `style` value,
-            // thus handing over control to `v-show`.
-            if ('_vod' in el) {
-                style.display = current;
-            }
         }
     }
     else {
@@ -9142,6 +9068,12 @@ function patchStyle(el, prev, next) {
             }
         }
     }
+    // indicates that the `display` of the element is controlled by `v-show`,
+    // so we always keep the current `display` value regardless of the `style` value,
+    // thus handing over control to `v-show`.
+    if ('_vod' in el) {
+        style.display = currentDisplay;
+    }
 }
 const importantRE = /\s*!important$/;
 function setStyle(style, name, val) {
@@ -9507,6 +9439,7 @@ class VueElement extends BaseClass {
         this._instance = null;
         this._connected = false;
         this._resolved = false;
+        this._numberProps = null;
         if (this.shadowRoot && hydrate) {
             hydrate(this._createVNode(), this.shadowRoot);
         }
@@ -9518,18 +9451,17 @@ class VueElement extends BaseClass {
             this._setAttr(this.attributes[i].name);
         }
         // watch future attr changes
-        const observer = new MutationObserver(mutations => {
+        new MutationObserver(mutations => {
             for (const m of mutations) {
                 this._setAttr(m.attributeName);
             }
-        });
-        observer.observe(this, { attributes: true });
+        }).observe(this, { attributes: true });
     }
     connectedCallback() {
         this._connected = true;
         if (!this._instance) {
             this._resolveDef();
-            render(this._createVNode(), this.shadowRoot);
+            this._update();
         }
     }
     disconnectedCallback() {
@@ -9550,15 +9482,31 @@ class VueElement extends BaseClass {
         }
         const resolve = (def) => {
             this._resolved = true;
+            const { props, styles } = def;
+            const hasOptions = !isArray(props);
+            const rawKeys = props ? (hasOptions ? Object.keys(props) : props) : [];
+            // cast Number-type props set before resolve
+            let numberProps;
+            if (hasOptions) {
+                for (const key in this._props) {
+                    const opt = props[key];
+                    if (opt === Number || (opt && opt.type === Number)) {
+                        this._props[key] = toNumber(this._props[key]);
+                        (numberProps || (numberProps = Object.create(null)))[key] = true;
+                    }
+                }
+            }
+            if (numberProps) {
+                this._numberProps = numberProps;
+                this._update();
+            }
             // check if there are props set pre-upgrade or connect
             for (const key of Object.keys(this)) {
                 if (key[0] !== '_') {
                     this._setProp(key, this[key]);
                 }
             }
-            const { props, styles } = def;
             // defining getter/setters on prototype
-            const rawKeys = props ? (isArray(props) ? props : Object.keys(props)) : [];
             for (const key of rawKeys.map(camelize)) {
                 Object.defineProperty(this, key, {
                     get() {
@@ -9580,7 +9528,11 @@ class VueElement extends BaseClass {
         }
     }
     _setAttr(key) {
-        this._setProp(camelize(key), toNumber(this.getAttribute(key)), false);
+        let value = this.getAttribute(key);
+        if (this._numberProps && this._numberProps[key]) {
+            value = toNumber(value);
+        }
+        this._setProp(camelize(key), value, false);
     }
     /**
      * @internal
@@ -9595,7 +9547,7 @@ class VueElement extends BaseClass {
         if (val !== this._props[key]) {
             this._props[key] = val;
             if (this._instance) {
-                render(this._createVNode(), this.shadowRoot);
+                this._update();
             }
             // reflect
             if (shouldReflect) {
@@ -9611,6 +9563,9 @@ class VueElement extends BaseClass {
             }
         }
     }
+    _update() {
+        render(this._createVNode(), this.shadowRoot);
+    }
     _createVNode() {
         const vnode = createVNode(this._def, extend({}, this._props));
         if (!this._instance) {
@@ -10795,7 +10750,7 @@ const errorMessages = {
     // transform errors
     [28 /* X_V_IF_NO_EXPRESSION */]: `v-if/v-else-if is missing expression.`,
     [29 /* X_V_IF_SAME_KEY */]: `v-if/else branches must use unique keys.`,
-    [30 /* X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if.`,
+    [30 /* X_V_ELSE_NO_ADJACENT_IF */]: `v-else/v-else-if has no adjacent v-if or v-else-if.`,
     [31 /* X_V_FOR_NO_EXPRESSION */]: `v-for is missing expression.`,
     [32 /* X_V_FOR_MALFORMED_EXPRESSION */]: `v-for has invalid expression.`,
     [33 /* X_V_FOR_TEMPLATE_KEY_PLACEMENT */]: `<template v-for> key should be placed on the <template> tag.`,
@@ -11065,84 +11020,27 @@ function isCoreComponent(tag) {
 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;
-/**
- * Simple lexer to check if an expression is a member expression. This is
- * lax and only checks validity at the root level (i.e. does not validate exps
- * inside square brackets), but it's ok since these are only used on template
- * expressions and false positives are invalid expressions in the first place.
- */
-const isMemberExpression = (path) => {
-    // remove whitespaces around . or [ first
-    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 the exp ends as a call then it should not be considered valid
-                    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;
+const isMemberExpressionNode = (path, context) => {
+    path = path.trim();
+    if (!validFirstIdentCharRE.test(path[0])) {
+        return false;
+    }
+    try {
+        let ret = parser.parseExpression(path, {
+            plugins: [...context.expressionPlugins, ...babelParserDefaultPlugins]
+        });
+        if (ret.type === 'TSAsExpression' || ret.type === 'TSTypeAssertion') {
+            ret = ret.expression;
         }
+        return (ret.type === 'MemberExpression' ||
+            ret.type === 'OptionalMemberExpression' ||
+            ret.type === 'Identifier');
+    }
+    catch (e) {
+        return false;
     }
-    return !currentOpenBracketCount && !currentOpenParensCount;
 };
+const isMemberExpression = isMemberExpressionNode;
 function getInnerRange(loc, offset, length) {
     const source = loc.source.substr(offset, length);
     const newLoc = {
@@ -11890,6 +11788,13 @@ function parseAttributes(context, type) {
             emitError(context, 3 /* END_TAG_WITH_ATTRIBUTES */);
         }
         const attr = parseAttribute(context, attributeNames);
+        // Trim whitespace between class
+        // https://github.com/vuejs/vue-next/issues/4251
+        if (attr.type === 6 /* ATTRIBUTE */ &&
+            attr.value &&
+            attr.name === 'class') {
+            attr.value.content = attr.value.content.replace(/\s+/g, ' ').trim();
+        }
         if (type === 0 /* Start */) {
             props.push(attr);
         }
@@ -11952,8 +11857,11 @@ function parseAttribute(context, nameSet) {
                 isStatic = false;
                 if (!content.endsWith(']')) {
                     emitError(context, 27 /* X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END */);
+                    content = content.substr(1);
+                }
+                else {
+                    content = content.substr(1, content.length - 2);
                 }
-                content = content.substr(1, content.length - 2);
             }
             else if (isSlot) {
                 // #1241 special case for v-slot: vuetify relies extensively on slot
@@ -12220,7 +12128,7 @@ function walk$1(node, context, doNotHoistNode = false) {
     // This is only a concern for pre-stringification (via transformHoist by
     // @vue/compiler-dom), but doing it here allows us to perform only one full
     // walk of the AST and allow `stringifyStatic` to stop walking as soon as its
-    // stringficiation threshold is met.
+    // stringification threshold is met.
     let canStringify = true;
     const { children } = node;
     const originalCount = children.length;
@@ -12466,7 +12374,7 @@ function getGeneratedPropsConstantType(node, context) {
             else if (value.type === 14 /* JS_CALL_EXPRESSION */) {
                 // some helper calls can be hoisted,
                 // such as the `normalizeProps` generated by the compiler for pre-normalize class,
-                // in this case we need to respect the ConstanType of the helper's argments
+                // in this case we need to respect the ConstantType of the helper's argments
                 valueType = getConstantTypeOfHelperCall(value, context);
             }
             else {
@@ -13094,22 +13002,22 @@ function genHoists(hoists, context) {
     const { push, newline, helper, scopeId, mode } = context;
     const genScopeId = scopeId != null && mode !== 'function';
     newline();
-    // push scope Id before initializing hoisted vnodes so that these vnodes
-    // get the proper scopeId as well.
+    // generate inlined withScopeId helper
     if (genScopeId) {
-        push(`${helper(PUSH_SCOPE_ID)}("${scopeId}")`);
+        push(`const _withScopeId = n => (${helper(PUSH_SCOPE_ID)}("${scopeId}"),n=n(),${helper(POP_SCOPE_ID)}(),n)`);
         newline();
     }
-    hoists.forEach((exp, i) => {
+    for (let i = 0; i < hoists.length; i++) {
+        const exp = hoists[i];
         if (exp) {
-            push(`const _hoisted_${i + 1} = `);
+            const needScopeIdWrapper = genScopeId && exp.type === 13 /* VNODE_CALL */;
+            push(`const _hoisted_${i + 1} = ${needScopeIdWrapper ? `${PURE_ANNOTATION} _withScopeId(() => ` : ``}`);
             genNode(exp, context);
+            if (needScopeIdWrapper) {
+                push(`)`);
+            }
             newline();
         }
-    });
-    if (genScopeId) {
-        push(`${helper(POP_SCOPE_ID)}()`);
-        newline();
     }
     context.pure = false;
 }
@@ -13585,7 +13493,7 @@ function isReferencedIdentifier(id, parent, parentStack) {
     if (id.name === 'arguments') {
         return false;
     }
-    if (types.isReferenced(id, parent)) {
+    if (isReferenced(id, parent)) {
         return true;
     }
     // babel's isReferenced check returns false for ids being assigned to, so we
@@ -13698,7 +13606,159 @@ const isFunctionType = (node) => {
 const isStaticProperty = (node) => node &&
     (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
     !node.computed;
-const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+/**
+ * Copied from https://github.com/babel/babel/blob/main/packages/babel-types/src/validators/isReferenced.ts
+ * To avoid runtime dependency on @babel/types (which includes process references)
+ * This file should not change very often in babel but we may need to keep it
+ * up-to-date from time to time.
+ *
+ * https://github.com/babel/babel/blob/main/LICENSE
+ *
+ */
+function isReferenced(node, parent, grandparent) {
+    switch (parent.type) {
+        // yes: PARENT[NODE]
+        // yes: NODE.child
+        // no: parent.NODE
+        case 'MemberExpression':
+        case 'OptionalMemberExpression':
+            if (parent.property === node) {
+                return !!parent.computed;
+            }
+            return parent.object === node;
+        case 'JSXMemberExpression':
+            return parent.object === node;
+        // no: let NODE = init;
+        // yes: let id = NODE;
+        case 'VariableDeclarator':
+            return parent.init === node;
+        // yes: () => NODE
+        // no: (NODE) => {}
+        case 'ArrowFunctionExpression':
+            return parent.body === node;
+        // no: class { #NODE; }
+        // no: class { get #NODE() {} }
+        // no: class { #NODE() {} }
+        // no: class { fn() { return this.#NODE; } }
+        case 'PrivateName':
+            return false;
+        // no: class { NODE() {} }
+        // yes: class { [NODE]() {} }
+        // no: class { foo(NODE) {} }
+        case 'ClassMethod':
+        case 'ClassPrivateMethod':
+        case 'ObjectMethod':
+            if (parent.key === node) {
+                return !!parent.computed;
+            }
+            return false;
+        // yes: { [NODE]: "" }
+        // no: { NODE: "" }
+        // depends: { NODE }
+        // depends: { key: NODE }
+        case 'ObjectProperty':
+            if (parent.key === node) {
+                return !!parent.computed;
+            }
+            // parent.value === node
+            return !grandparent || grandparent.type !== 'ObjectPattern';
+        // no: class { NODE = value; }
+        // yes: class { [NODE] = value; }
+        // yes: class { key = NODE; }
+        case 'ClassProperty':
+            if (parent.key === node) {
+                return !!parent.computed;
+            }
+            return true;
+        case 'ClassPrivateProperty':
+            return parent.key !== node;
+        // no: class NODE {}
+        // yes: class Foo extends NODE {}
+        case 'ClassDeclaration':
+        case 'ClassExpression':
+            return parent.superClass === node;
+        // yes: left = NODE;
+        // no: NODE = right;
+        case 'AssignmentExpression':
+            return parent.right === node;
+        // no: [NODE = foo] = [];
+        // yes: [foo = NODE] = [];
+        case 'AssignmentPattern':
+            return parent.right === node;
+        // no: NODE: for (;;) {}
+        case 'LabeledStatement':
+            return false;
+        // no: try {} catch (NODE) {}
+        case 'CatchClause':
+            return false;
+        // no: function foo(...NODE) {}
+        case 'RestElement':
+            return false;
+        case 'BreakStatement':
+        case 'ContinueStatement':
+            return false;
+        // no: function NODE() {}
+        // no: function foo(NODE) {}
+        case 'FunctionDeclaration':
+        case 'FunctionExpression':
+            return false;
+        // no: export NODE from "foo";
+        // no: export * as NODE from "foo";
+        case 'ExportNamespaceSpecifier':
+        case 'ExportDefaultSpecifier':
+            return false;
+        // no: export { foo as NODE };
+        // yes: export { NODE as foo };
+        // no: export { NODE as foo } from "foo";
+        case 'ExportSpecifier':
+            // @ts-expect-error
+            if (grandparent === null || grandparent === void 0 ? void 0 : grandparent.source) {
+                return false;
+            }
+            return parent.local === node;
+        // no: import NODE from "foo";
+        // no: import * as NODE from "foo";
+        // no: import { NODE as foo } from "foo";
+        // no: import { foo as NODE } from "foo";
+        // no: import NODE from "bar";
+        case 'ImportDefaultSpecifier':
+        case 'ImportNamespaceSpecifier':
+        case 'ImportSpecifier':
+            return false;
+        // no: import "foo" assert { NODE: "json" }
+        case 'ImportAttribute':
+            return false;
+        // no: <div NODE="foo" />
+        case 'JSXAttribute':
+            return false;
+        // no: [NODE] = [];
+        // no: ({ NODE }) = [];
+        case 'ObjectPattern':
+        case 'ArrayPattern':
+            return false;
+        // no: new.NODE
+        // no: NODE.target
+        case 'MetaProperty':
+            return false;
+        // yes: type X = { somePropert: NODE }
+        // no: type X = { NODE: OtherType }
+        case 'ObjectTypeProperty':
+            return parent.key !== node;
+        // yes: enum X { Foo = NODE }
+        // no: enum X { NODE }
+        case 'TSEnumMember':
+            return parent.id !== node;
+        // yes: { [NODE]: value }
+        // no: { NODE: value }
+        case 'TSPropertySignature':
+            if (parent.key === node) {
+                return !!parent.computed;
+            }
+            return true;
+    }
+    return true;
+}
 
 const isLiteralWhitelisted = /*#__PURE__*/ makeMap('true,false,null,this');
 const transformExpression = (node, context) => {
@@ -14024,6 +14084,11 @@ function processIf(node, dir, context, processCodegen) {
                 continue;
             }
             if (sibling && sibling.type === 9 /* IF */) {
+                // Check if v-else was followed by v-else-if
+                if (dir.name === 'else-if' &&
+                    sibling.branches[sibling.branches.length - 1].condition === undefined) {
+                    context.onError(createCompilerError(30 /* X_V_ELSE_NO_ADJACENT_IF */, node.loc));
+                }
                 // move the node to the if node's branches
                 context.removeNode();
                 const branch = createIfBranch(node, dir);
@@ -14956,7 +15021,7 @@ function buildProps(node, context, props = node.props, ssr = false) {
                 // acrtual ref instead.
                 if (context.inline && (value === null || value === void 0 ? void 0 : value.content)) {
                     valueNode = createFunctionExpression(['_value', '_refs']);
-                    valueNode.body = createBlockStatement(processInlineRef(context.bindingMetadata, value.content));
+                    valueNode.body = createBlockStatement(processInlineRef(context, value.content));
                 }
             }
             // skip is on <component>, or is="vue:xxx"
@@ -15179,7 +15244,7 @@ function dedupeProperties(properties) {
         const name = prop.key.content;
         const existing = knownProps.get(name);
         if (existing) {
-            if (name === 'style' || name === 'class' || name.startsWith('on')) {
+            if (name === 'style' || name === 'class' || isOn(name)) {
                 mergeAsArray$1(existing, prop);
             }
             // unexpected duplicate, should have emitted error during parse
@@ -15253,14 +15318,18 @@ function stringifyDynamicPropNames(props) {
 function isComponentTag(tag) {
     return tag[0].toLowerCase() + tag.slice(1) === 'component';
 }
-function processInlineRef(bindings, raw) {
+function processInlineRef(context, raw) {
     const body = [createSimpleExpression(`_refs['${raw}'] = _value`)];
-    const type = bindings[raw];
+    const { bindingMetadata, helperString } = context;
+    const type = bindingMetadata[raw];
     if (type === "setup-ref" /* SETUP_REF */) {
         body.push(createSimpleExpression(`${raw}.value = _value`));
     }
+    else if (type === "setup-maybe-ref" /* SETUP_MAYBE_REF */) {
+        body.push(createSimpleExpression(`${helperString(IS_REF)}(${raw}) && (${raw}.value = _value)`));
+    }
     else if (type === "setup-let" /* SETUP_LET */) {
-        body.push(createSimpleExpression(`${raw} = _value`));
+        body.push(createSimpleExpression(`${helperString(IS_REF)}(${raw}) ? ${raw}.value = _value : ${raw} = _value`));
     }
     return body;
 }
@@ -15271,26 +15340,24 @@ const transformSlotOutlet = (node, context) => {
         const { slotName, slotProps } = processSlotOutlet(node, context);
         const slotArgs = [
             context.prefixIdentifiers ? `_ctx.$slots` : `$slots`,
-            slotName
+            slotName,
+            '{}',
+            'undefined',
+            'true'
         ];
+        let expectedLen = 2;
         if (slotProps) {
-            slotArgs.push(slotProps);
+            slotArgs[2] = slotProps;
+            expectedLen = 3;
         }
         if (children.length) {
-            if (!slotProps) {
-                slotArgs.push(`{}`);
-            }
-            slotArgs.push(createFunctionExpression([], children, false, false, loc));
+            slotArgs[3] = createFunctionExpression([], children, false, false, loc);
+            expectedLen = 4;
         }
         if (context.scopeId && !context.slotted) {
-            if (!slotProps) {
-                slotArgs.push(`{}`);
-            }
-            if (!children.length) {
-                slotArgs.push(`undefined`);
-            }
-            slotArgs.push(`true`);
+            expectedLen = 5;
         }
+        slotArgs.splice(expectedLen); // remove unused arguments
         node.codegenNode = createCallExpression(context.helper(RENDER_SLOT), slotArgs, loc);
     }
 };
@@ -15337,7 +15404,7 @@ function processSlotOutlet(node, context) {
     };
 }
 
-const fnExpRE = /^\s*([\w$_]+|\([^)]*?\))\s*=>|^\s*function(?:\s+[\w$]+)?\s*\(/;
+const fnExpRE = /^\s*([\w$_]+|(async\s*)?\([^)]*?\))\s*=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
 const transformOn = (dir, node, context, augmentor) => {
     const { loc, modifiers, arg } = dir;
     if (!dir.exp && !modifiers.length) {
@@ -15372,7 +15439,7 @@ const transformOn = (dir, node, context, augmentor) => {
     }
     let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
     if (exp) {
-        const isMemberExp = isMemberExpression(exp.content);
+        const isMemberExp = isMemberExpression(exp.content, context);
         const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
         const hasMultipleStatements = exp.content.includes(`;`);
         // process the expression since it's been skipped
@@ -15629,7 +15696,8 @@ const transformModel = (dir, node, context) => {
     const maybeRef = context.inline &&
         bindingType &&
         bindingType !== "setup-const" /* SETUP_CONST */;
-    if (!expString.trim() || (!isMemberExpression(expString) && !maybeRef)) {
+    if (!expString.trim() ||
+        (!isMemberExpression(expString, context) && !maybeRef)) {
         context.onError(createCompilerError(42 /* X_V_MODEL_MALFORMED_EXPRESSION */, exp.loc));
         return createTransformProps();
     }
@@ -15937,6 +16005,12 @@ function baseCompile(template, options = {}) {
     }
     const ast = isString(template) ? baseParse(template, options) : template;
     const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
+    if (options.isTS) {
+        const { expressionPlugins } = options;
+        if (!expressionPlugins || !expressionPlugins.includes('typescript')) {
+            options.expressionPlugins = [...(expressionPlugins || []), 'typescript'];
+        }
+    }
     transform(ast, extend({}, options, {
         prefixIdentifiers,
         nodeTransforms: [
@@ -19004,4 +19078,4 @@ registerRuntimeCompiler(compileToFunction);
 const Vue = createCompatVue$1();
 Vue.compile = compileToFunction;
 
-exports.default = Vue;
+module.exports = Vue;