@vue/compat 3.2.8 → 3.2.12

package/dist/vue.cjs.js

@@ -1,8 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var types = require('@babel/types');
 var estreeWalker = require('estree-walker');
 var parser = require('@babel/parser');
 var sourceMap = require('source-map');
@@ -1682,41 +1679,33 @@ function registerHMR(instance) {
     const id = instance.type.__hmrId;
     let record = map.get(id);
     if (!record) {
-        createRecord(id, instance.type);
+        createRecord(id);
         record = map.get(id);
     }
-    record.instances.add(instance);
+    record.add(instance);
 }
 function unregisterHMR(instance) {
-    map.get(instance.type.__hmrId).instances.delete(instance);
+    map.get(instance.type.__hmrId).delete(instance);
 }
-function createRecord(id, component) {
-    if (!component) {
-        warn$1(`HMR API usage is out of date.\n` +
-            `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` +
-            `dependency that handles Vue SFC compilation.`);
-        component = {};
-    }
+function createRecord(id) {
     if (map.has(id)) {
         return false;
     }
-    map.set(id, {
-        component: isClassComponent(component) ? component.__vccOpts : component,
-        instances: new Set()
-    });
+    map.set(id, new Set());
     return true;
 }
+function normalizeClassComponent(component) {
+    return isClassComponent(component) ? component.__vccOpts : component;
+}
 function rerender(id, newRender) {
     const record = map.get(id);
-    if (!record)
+    if (!record) {
         return;
-    if (newRender)
-        record.component.render = newRender;
-    // Array.from creates a snapshot which avoids the set being mutated during
-    // updates
-    Array.from(record.instances).forEach(instance => {
+    }
+    [...record].forEach(instance => {
         if (newRender) {
             instance.render = newRender;
+            normalizeClassComponent(instance.type).render = newRender;
         }
         instance.renderCache = [];
         // this flag forces child components with slot content to update
@@ -1729,34 +1718,31 @@ function reload(id, newComp) {
     const record = map.get(id);
     if (!record)
         return;
-    // Array.from creates a snapshot which avoids the set being mutated during
-    // updates
-    const { component, instances } = record;
-    if (!hmrDirtyComponents.has(component)) {
-        // 1. Update existing comp definition to match new one
-        newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp;
-        extend(component, newComp);
-        for (const key in component) {
-            if (key !== '__file' && !(key in newComp)) {
-                delete component[key];
-            }
-        }
-        // 2. Mark component dirty. This forces the renderer to replace the component
-        // on patch.
-        hmrDirtyComponents.add(component);
-        // 3. Make sure to unmark the component after the reload.
-        queuePostFlushCb(() => {
-            hmrDirtyComponents.delete(component);
-        });
-    }
-    Array.from(instances).forEach(instance => {
-        // invalidate options resolution cache
+    newComp = normalizeClassComponent(newComp);
+    // create a snapshot which avoids the set being mutated during updates
+    const instances = [...record];
+    for (const instance of instances) {
+        const oldComp = normalizeClassComponent(instance.type);
+        if (!hmrDirtyComponents.has(oldComp)) {
+            // 1. Update existing comp definition to match new one
+            extend(oldComp, newComp);
+            for (const key in oldComp) {
+                if (key !== '__file' && !(key in newComp)) {
+                    delete oldComp[key];
+                }
+            }
+            // 2. mark definition dirty. This forces the renderer to replace the
+            // component on patch.
+            hmrDirtyComponents.add(oldComp);
+        }
+        // 3. invalidate options resolution cache
         instance.appContext.optionsCache.delete(instance.type);
+        // 4. actually update
         if (instance.ceReload) {
             // custom element
-            hmrDirtyComponents.add(component);
+            hmrDirtyComponents.add(oldComp);
             instance.ceReload(newComp.styles);
-            hmrDirtyComponents.delete(component);
+            hmrDirtyComponents.delete(oldComp);
         }
         else if (instance.parent) {
             // 4. Force the parent instance to re-render. This will cause all updated
@@ -1781,6 +1767,12 @@ function reload(id, newComp) {
         else {
             console.warn('[HMR] Root or manually mounted instance modified. Full reload required.');
         }
+    }
+    // 5. make sure to cleanup dirty hmr components after update
+    queuePostFlushCb(() => {
+        for (const instance of instances) {
+            hmrDirtyComponents.delete(normalizeClassComponent(instance.type));
+        }
     });
 }
 function tryWrap(fn) {
@@ -2594,12 +2586,12 @@ function markAttrsAccessed() {
 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);
     {
         accessedAttrs = false;
     }
     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.
@@ -2630,108 +2622,105 @@ 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 (true &&
-            result.patchFlag > 0 &&
-            result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {
-            ;
-            [root, setRoot] = getChildRoot(result);
-        }
-        if (fallthroughAttrs && inheritAttrs !== false) {
-            const keys = Object.keys(fallthroughAttrs);
-            const { shapeFlag } = root;
-            if (keys.length) {
-                if (shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
-                    if (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 (true && !accessedAttrs && root.type !== Comment) {
-                    const allAttrs = Object.keys(attrs);
-                    const eventAttrs = [];
-                    const extraAttrs = [];
-                    for (let i = 0, l = allAttrs.length; i < l; i++) {
-                        const key = allAttrs[i];
-                        if (isOn(key)) {
-                            // ignore v-model handlers when they fail to fallthrough
-                            if (!isModelListener(key)) {
-                                // remove `on`, lowercase first letter to reflect event casing
-                                // accurately
-                                eventAttrs.push(key[2].toLowerCase() + key.slice(3));
-                            }
-                        }
-                        else {
-                            extraAttrs.push(key);
+    }
+    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;
+    let setRoot = undefined;
+    if (result.patchFlag > 0 &&
+        result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) {
+        [root, setRoot] = getChildRoot(result);
+    }
+    if (fallthroughAttrs && inheritAttrs !== false) {
+        const keys = Object.keys(fallthroughAttrs);
+        const { shapeFlag } = root;
+        if (keys.length) {
+            if (shapeFlag & (1 /* ELEMENT */ | 6 /* COMPONENT */)) {
+                if (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 (!accessedAttrs && root.type !== Comment) {
+                const allAttrs = Object.keys(attrs);
+                const eventAttrs = [];
+                const extraAttrs = [];
+                for (let i = 0, l = allAttrs.length; i < l; i++) {
+                    const key = allAttrs[i];
+                    if (isOn(key)) {
+                        // ignore v-model handlers when they fail to fallthrough
+                        if (!isModelListener(key)) {
+                            // remove `on`, lowercase first letter to reflect event casing
+                            // accurately
+                            eventAttrs.push(key[2].toLowerCase() + key.slice(3));
                         }
                     }
-                    if (extraAttrs.length) {
-                        warn$1(`Extraneous non-props attributes (` +
-                            `${extraAttrs.join(', ')}) ` +
-                            `were passed to component but could not be automatically inherited ` +
-                            `because component renders fragment or text root nodes.`);
-                    }
-                    if (eventAttrs.length) {
-                        warn$1(`Extraneous non-emits event listeners (` +
-                            `${eventAttrs.join(', ')}) ` +
-                            `were passed to component but could not be automatically inherited ` +
-                            `because component renders fragment or text root nodes. ` +
-                            `If the listener is intended to be a component custom event listener only, ` +
-                            `declare it using the "emits" option.`);
+                    else {
+                        extraAttrs.push(key);
                     }
                 }
-            }
-        }
-        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 (true && inheritAttrs === false) {
-                    warnDeprecation("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance, getComponentName(instance.type));
+                if (extraAttrs.length) {
+                    warn$1(`Extraneous non-props attributes (` +
+                        `${extraAttrs.join(', ')}) ` +
+                        `were passed to component but could not be automatically inherited ` +
+                        `because component renders fragment or text root nodes.`);
+                }
+                if (eventAttrs.length) {
+                    warn$1(`Extraneous non-emits event listeners (` +
+                        `${eventAttrs.join(', ')}) ` +
+                        `were passed to component but could not be automatically inherited ` +
+                        `because component renders fragment or text root nodes. ` +
+                        `If the listener is intended to be a component custom event listener only, ` +
+                        `declare it using the "emits" option.`);
                 }
-                root = cloneVNode(root, {
-                    class: cls,
-                    style: style
-                });
-            }
-        }
-        // inherit directives
-        if (vnode.dirs) {
-            if (true && !isElementRoot(root)) {
-                warn$1(`Runtime directive used on component with non-element root node. ` +
-                    `The directives will not function as intended.`);
             }
-            root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
         }
-        // inherit transition data
-        if (vnode.transition) {
-            if (true && !isElementRoot(root)) {
-                warn$1(`Component inside <Transition> renders non-element root node ` +
-                    `that cannot be animated.`);
+    }
+    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) {
+            if (inheritAttrs === false) {
+                warnDeprecation("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance, getComponentName(instance.type));
             }
-            root.transition = vnode.transition;
+            root = cloneVNode(root, {
+                class: cls,
+                style: style
+            });
         }
-        if (true && setRoot) {
-            setRoot(root);
+    }
+    // inherit directives
+    if (vnode.dirs) {
+        if (!isElementRoot(root)) {
+            warn$1(`Runtime directive used on component with non-element root node. ` +
+                `The directives will not function as intended.`);
         }
-        else {
-            result = root;
+        root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs;
+    }
+    // inherit transition data
+    if (vnode.transition) {
+        if (!isElementRoot(root)) {
+            warn$1(`Component inside <Transition> renders non-element root node ` +
+                `that cannot be animated.`);
         }
+        root.transition = vnode.transition;
     }
-    catch (err) {
-        blockStack.length = 0;
-        handleError(err, instance, 1 /* RENDER_FUNCTION */);
-        result = createVNode(Comment);
+    if (setRoot) {
+        setRoot(root);
+    }
+    else {
+        result = root;
     }
     setCurrentRenderingInstance(prev);
     return result;
@@ -3266,8 +3255,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)
@@ -3275,7 +3264,7 @@ function normalizeSuspenseSlot(s) {
             openBlock();
         }
         s = s();
-        if (isCompiledSlot) {
+        if (trackBlock) {
             s._d = true;
             block = currentBlock;
             closeBlock();
@@ -5431,7 +5420,7 @@ function createCompatVue(createApp, createSingletonApp) {
             return vm;
         }
     }
-    Vue.version = "3.2.8";
+    Vue.version = "3.2.12";
     Vue.config = singletonApp.config;
     Vue.use = (p, ...options) => {
         if (p && isFunction(p.install)) {
@@ -8079,7 +8068,11 @@ function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false
             return Component;
         }
         if (warnMissing && !res) {
-            warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}`);
+            const extra = type === COMPONENTS
+                ? `\nIf this is a native custom element, make sure to exclude it from ` +
+                    `component resolution via compilerOptions.isCustomElement.`
+                : ``;
+            warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
         }
         return res;
     }
@@ -9521,17 +9514,19 @@ function exposePropsOnRenderContext(instance) {
 function exposeSetupStateOnRenderContext(instance) {
     const { ctx, setupState } = instance;
     Object.keys(toRaw(setupState)).forEach(key => {
-        if (!setupState.__isScriptSetup && (key[0] === '$' || key[0] === '_')) {
-            warn$1(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` +
-                `which are reserved prefixes for Vue internals.`);
-            return;
+        if (!setupState.__isScriptSetup) {
+            if (key[0] === '$' || key[0] === '_') {
+                warn$1(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` +
+                    `which are reserved prefixes for Vue internals.`);
+                return;
+            }
+            Object.defineProperty(ctx, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => setupState[key],
+                set: NOOP
+            });
         }
-        Object.defineProperty(ctx, key, {
-            enumerable: true,
-            configurable: true,
-            get: () => setupState[key],
-            set: NOOP
-        });
     });
 }
 
@@ -10304,11 +10299,18 @@ 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 = (job) => checkRecursiveUpdates(seen, job)
+        ;
     try {
         for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
             const job = queue[flushIndex];
             if (job && job.active !== false) {
-                if (true && checkRecursiveUpdates(seen, job)) {
+                if (true && check(job)) {
                     continue;
                 }
                 // console.log(`running:`, job.id)
@@ -10669,7 +10671,7 @@ function defineExpose(exposed) {
 }
 /**
  * Vue `<script setup>` compiler macro for providing props default values when
- * using type-based `defineProps` decalration.
+ * using type-based `defineProps` declaration.
  *
  * Example usage:
  * ```ts
@@ -11018,7 +11020,7 @@ function isMemoSame(cached, memo) {
 }
 
 // Core API ------------------------------------------------------------------
-const version = "3.2.8";
+const version = "3.2.12";
 const _ssrUtils = {
     createComponentInstance,
     setupComponent,
@@ -11155,19 +11157,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 {
@@ -11182,6 +11178,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) {
@@ -11552,6 +11554,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);
         }
@@ -11567,18 +11570,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() {
@@ -11599,15 +11601,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() {
@@ -11629,7 +11647,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
@@ -11644,7 +11666,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) {
@@ -11660,6 +11682,9 @@ class VueElement extends BaseClass {
             }
         }
     }
+    _update() {
+        render(this._createVNode(), this.shadowRoot);
+    }
     _createVNode() {
         const vnode = createVNode(this._def, extend({}, this._props));
         if (!this._instance) {
@@ -11680,7 +11705,7 @@ class VueElement extends BaseClass {
                         if (!this._def.__asyncLoader) {
                             // reload
                             this._instance = null;
-                            render(this._createVNode(), this.shadowRoot);
+                            this._update();
                         }
                     };
                 }
@@ -14149,6 +14174,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);
         }
@@ -14211,8 +14243,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
@@ -15883,7 +15918,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
@@ -15996,7 +16031,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) => {
@@ -16035,7 +16222,7 @@ function processExpression(node, context,
 // function params
 asParams = false, 
 // v-on handler values may contain multiple statements
-asRawStatements = false) {
+asRawStatements = false, localVars = Object.create(context.identifiers)) {
     if (!context.prefixIdentifiers || !node.content.trim()) {
         return node;
     }
@@ -16049,7 +16236,7 @@ asRawStatements = false) {
             const isUpdateArg = parent && parent.type === 'UpdateExpression' && parent.argument === id;
             // ({ x } = y)
             const isDestructureAssignment = parent && isInDestructureAssignment(parent, parentStack);
-            if (type === "setup-const" /* SETUP_CONST */) {
+            if (type === "setup-const" /* SETUP_CONST */ || localVars[raw]) {
                 return raw;
             }
             else if (type === "setup-ref" /* SETUP_REF */) {
@@ -16073,7 +16260,7 @@ asRawStatements = false) {
                     // x = y --> isRef(x) ? x.value = y : x = y
                     const { right: rVal, operator } = parent;
                     const rExp = rawExp.slice(rVal.start - 1, rVal.end - 1);
-                    const rExpString = stringifyExpression(processExpression(createSimpleExpression(rExp, false), context));
+                    const rExpString = stringifyExpression(processExpression(createSimpleExpression(rExp, false), context, false, false, knownIds));
                     return `${context.helperString(IS_REF)}(${raw})${context.isTS ? ` //@ts-ignore\n` : ``} ? ${raw}.value ${operator} ${rExpString} : ${raw}`;
                 }
                 else if (isUpdateArg) {
@@ -17294,7 +17481,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"
@@ -17614,14 +17801,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;
 }
@@ -17698,7 +17889,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) {
@@ -21423,4 +21614,4 @@ registerRuntimeCompiler(compileToFunction);
 const Vue = createCompatVue$1();
 Vue.compile = compileToFunction;
 
-exports.default = Vue;
+module.exports = Vue;