@vue/compiler-sfc 3.2.2 → 3.2.6

package/dist/compiler-sfc.cjs.js

@@ -16,6 +16,7 @@ var merge = require('merge-source-map');
 var MagicString = require('magic-string');
 var parser = require('@babel/parser');
 var estreeWalker = require('estree-walker');
+var refTransform = require('@vue/ref-transform');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e['default'] : e; }
 
@@ -639,16 +640,6 @@ function warnOnce(msg) {
 }
 function warn(msg) {
     console.warn(`\x1b[1m\x1b[33m[@vue/compiler-sfc]\x1b[0m\x1b[33m ${msg}\x1b[0m\n`);
-}
-function warnExperimental(feature, url) {
-    // eslint-disable-next-line
-    if (typeof window !== 'undefined') {
-        return;
-    }
-    warnOnce(`${feature} is still an experimental proposal.\n` +
-        `Follow its status at ${url}.`);
-    warnOnce(`When using experimental features,\n` +
-        `it is recommended to pin your vue dependencies to exact versions to avoid breakage.`);
 }
 
 function preprocess({ source, filename, preprocessOptions }, preprocessor) {
@@ -1251,11 +1242,6 @@ const DEFINE_PROPS = 'defineProps';
 const DEFINE_EMITS = 'defineEmits';
 const DEFINE_EXPOSE = 'defineExpose';
 const WITH_DEFAULTS = 'withDefaults';
-const $REF = `$ref`;
-const $SHALLOW_REF = '$shallowRef';
-const $COMPUTED = `$computed`;
-const $FROM_REFS = `$fromRefs`;
-const $RAW = `$raw`;
 const isBuiltInDir = shared.makeMap(`once,memo,if,else,else-if,slot,text,html,on,bind,model,show,cloak,is`);
 /**
  * Compile `<script setup>`
@@ -1265,18 +1251,8 @@ const isBuiltInDir = shared.makeMap(`once,memo,if,else,else-if,slot,text,html,on
 function compileScript(sfc, options) {
     let { script, scriptSetup, source, filename } = sfc;
     // feature flags
-    const enableRefSugar = !!options.refSugar;
-    const parseOnly = !!options.parseOnly;
-    if (parseOnly && !scriptSetup) {
-        // in parse-only mode, construct a fake script setup so we still perform
-        // the full parse logic.
-        scriptSetup = {
-            type: 'script',
-            content: '',
-            attrs: {},
-            loc: CompilerDOM.locStub
-        };
-    }
+    const enableRefTransform = !!options.refSugar || !!options.refTransform;
+    let refBindings;
     // for backwards compat
     if (!options) {
         options = { id: '' };
@@ -1311,23 +1287,40 @@ function compileScript(sfc, options) {
             return script;
         }
         try {
-            const scriptAst = parser.parse(script.content, {
-                plugins,
-                sourceType: 'module',
-                errorRecovery: parseOnly
-            }).program.body;
-            const bindings = analyzeScriptBindings(scriptAst);
             let content = script.content;
+            let map = script.map;
+            const scriptAst = parser.parse(content, {
+                plugins,
+                sourceType: 'module'
+            }).program;
+            const bindings = analyzeScriptBindings(scriptAst.body);
+            if (enableRefTransform && refTransform.shouldTransform(content)) {
+                const s = new MagicString__default(source);
+                const startOffset = script.loc.start.offset;
+                const endOffset = script.loc.end.offset;
+                const { importedHelpers } = refTransform.transformAST(scriptAst, s, startOffset);
+                if (importedHelpers.length) {
+                    s.prepend(`import { ${importedHelpers
+                        .map(h => `${h} as _${h}`)
+                        .join(', ')} } from 'vue'\n`);
+                }
+                s.remove(0, startOffset);
+                s.remove(endOffset, source.length);
+                content = s.toString();
+                map = s.generateMap({
+                    source: filename,
+                    hires: true,
+                    includeContent: true
+                });
+            }
             if (cssVars.length) {
                 content = rewriteDefault(content, `__default__`, plugins);
-                if (cssVars.length) {
-                    content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, !!options.isProd);
-                }
+                content += genNormalScriptCssVarsCode(cssVars, bindings, scopeId, !!options.isProd);
                 content += `\nexport default __default__`;
             }
             return Object.assign(Object.assign({}, script), { content,
-                bindings,
-                scriptAst });
+                map,
+                bindings, scriptAst: scriptAst.body });
         }
         catch (e) {
             // silently fallback if parse fails since user may be using custom
@@ -1345,19 +1338,11 @@ function compileScript(sfc, options) {
     }
     // metadata that needs to be returned
     const bindingMetadata = {};
-    const ranges = parseOnly
-        ? {
-            scriptBindings: [],
-            scriptSetupBindings: []
-        }
-        : undefined;
     const defaultTempVar = `__default__`;
     const helperImports = new Set();
     const userImports = Object.create(null);
     const userImportAlias = Object.create(null);
     const setupBindings = Object.create(null);
-    const refBindings = Object.create(null);
-    const refIdentifiers = new Set();
     let defaultExport;
     let hasDefinePropsCall = false;
     let hasDefineEmitCall = false;
@@ -1390,8 +1375,7 @@ function compileScript(sfc, options) {
     }
     function parse(input, options, offset) {
         try {
-            options.errorRecovery = parseOnly;
-            return parser.parse(input, options).program.body;
+            return parser.parse(input, options).program;
         }
         catch (e) {
             e.message = `[@vue/compiler-sfc] ${e.message}\n\n${sfc.filename}\n${shared.generateCodeFrame(source, e.pos + offset, e.pos + offset + 1)}`;
@@ -1401,12 +1385,12 @@ function compileScript(sfc, options) {
     function error(msg, node, end = node.end + startOffset) {
         throw new Error(`[@vue/compiler-sfc] ${msg}\n\n${sfc.filename}\n${shared.generateCodeFrame(source, node.start + startOffset, end)}`);
     }
-    function registerUserImport(source, local, imported, isType, isFromSetup, rangeNode) {
+    function registerUserImport(source, local, imported, isType, isFromSetup) {
         if (source === 'vue' && imported) {
             userImportAlias[imported] = local;
         }
         let isUsedInTemplate = true;
-        if (isTS && sfc.template && !sfc.template.src) {
+        if (isTS && sfc.template && !sfc.template.src && !sfc.template.lang) {
             isUsedInTemplate = new RegExp(
             // #4274 escape $ since it's a special char in regex
             // (and is the only regex special char that is valid in identifiers)
@@ -1416,7 +1400,6 @@ function compileScript(sfc, options) {
             isType,
             imported: imported || 'default',
             source,
-            rangeNode,
             isFromSetup,
             isUsedInTemplate
         };
@@ -1505,7 +1488,7 @@ function compileScript(sfc, options) {
                     return isQualifiedType(node.declaration);
                 }
             };
-            for (const node of scriptSetupAst) {
+            for (const node of scriptSetupAst.body) {
                 const qualified = isQualifiedType(node);
                 if (qualified) {
                     return qualified;
@@ -1526,7 +1509,7 @@ function compileScript(sfc, options) {
     function checkInvalidScopeReference(node, method) {
         if (!node)
             return;
-        walkIdentifiers(node, id => {
+        CompilerDOM.walkIdentifiers(node, id => {
             if (setupBindings[id.name]) {
                 error(`\`${method}()\` in <script setup> cannot reference locally ` +
                     `declared variables because it will be hoisted outside of the ` +
@@ -1545,145 +1528,6 @@ function compileScript(sfc, options) {
         s.overwrite(node.start + startOffset, node.argument.start + startOffset, `${isStatement ? `;` : ``}(([__temp,__restore]=${helper(`withAsyncContext`)}(()=>(`);
         s.appendLeft(node.end + startOffset, `))),__temp=await __temp,__restore()${isStatement ? `` : `,__temp`})`);
     }
-    function isRefSugarCall(callee) {
-        return (callee === $REF ||
-            callee === $COMPUTED ||
-            callee === $FROM_REFS ||
-            callee === $SHALLOW_REF);
-    }
-    function processRefSugar(decl, statement) {
-        if (!isCallOf(decl.init, isRefSugarCall)) {
-            return;
-        }
-        if (!enableRefSugar) {
-            error(`ref sugar is an experimental proposal and must be explicitly ` +
-                `enabled via @vue/compiler-sfc options.`, 
-            // TODO link to RFC details
-            decl.init);
-        }
-        else {
-            warnExperimental(`ref sugar`, `https://github.com/vuejs/rfcs/discussions/369`);
-        }
-        const callee = decl.init.callee.name;
-        const start = decl.init.start + startOffset;
-        if (callee === $REF || callee === $SHALLOW_REF) {
-            if (statement.kind !== 'let') {
-                error(`${callee}() bindings can only be declared with let.`, decl);
-            }
-            if (decl.id.type !== 'Identifier') {
-                error(`${callee}() bindings cannot be used with destructuring. ` +
-                    `If you are trying to destructure from an object of refs, ` +
-                    `use \`let { x } = $fromRefs(obj)\`.`, decl.id);
-            }
-            registerRefBinding(decl.id);
-            s.overwrite(start, start + callee.length, helper(callee === $REF ? 'ref' : 'shallowRef'));
-        }
-        else if (callee === $COMPUTED) {
-            if (decl.id.type !== 'Identifier') {
-                error(`${callee}() bindings cannot be used with destructuring.`, decl.id);
-            }
-            registerRefBinding(decl.id);
-            s.overwrite(start, start + $COMPUTED.length, helper('computed'));
-        }
-        else if (callee === $FROM_REFS) {
-            if (!decl.id.type.endsWith('Pattern')) {
-                error(`${callee}() declaration must be used with destructure patterns.`, decl);
-            }
-            if (decl.id.type === 'ObjectPattern') {
-                processRefObjectPattern(decl.id, statement);
-            }
-            else if (decl.id.type === 'ArrayPattern') {
-                processRefArrayPattern(decl.id, statement);
-            }
-            s.remove(start, start + callee.length);
-        }
-    }
-    function registerRefBinding(id) {
-        if (id.name[0] === '$') {
-            error(`ref variable identifiers cannot start with $.`, id);
-        }
-        refBindings[id.name] = setupBindings[id.name] = {
-            type: "setup-ref" /* SETUP_REF */,
-            rangeNode: id
-        };
-        refIdentifiers.add(id);
-    }
-    function processRefObjectPattern(pattern, statement) {
-        for (const p of pattern.properties) {
-            let nameId;
-            if (p.type === 'ObjectProperty') {
-                if (p.key.start === p.value.start) {
-                    // shorthand { foo } --> { foo: __foo }
-                    nameId = p.key;
-                    s.appendLeft(nameId.end + startOffset, `: __${nameId.name}`);
-                    if (p.value.type === 'AssignmentPattern') {
-                        // { foo = 1 }
-                        refIdentifiers.add(p.value.left);
-                    }
-                }
-                else {
-                    if (p.value.type === 'Identifier') {
-                        // { foo: bar } --> { foo: __bar }
-                        nameId = p.value;
-                        s.prependRight(nameId.start + startOffset, `__`);
-                    }
-                    else if (p.value.type === 'ObjectPattern') {
-                        processRefObjectPattern(p.value, statement);
-                    }
-                    else if (p.value.type === 'ArrayPattern') {
-                        processRefArrayPattern(p.value, statement);
-                    }
-                    else if (p.value.type === 'AssignmentPattern') {
-                        // { foo: bar = 1 } --> { foo: __bar = 1 }
-                        nameId = p.value.left;
-                        s.prependRight(nameId.start + startOffset, `__`);
-                    }
-                }
-            }
-            else {
-                // rest element { ...foo } --> { ...__foo }
-                nameId = p.argument;
-                s.prependRight(nameId.start + startOffset, `__`);
-            }
-            if (nameId) {
-                registerRefBinding(nameId);
-                // append binding declarations after the parent statement
-                s.appendLeft(statement.end + startOffset, `\nconst ${nameId.name} = ${helper('shallowRef')}(__${nameId.name});`);
-            }
-        }
-    }
-    function processRefArrayPattern(pattern, statement) {
-        for (const e of pattern.elements) {
-            if (!e)
-                continue;
-            let nameId;
-            if (e.type === 'Identifier') {
-                // [a] --> [__a]
-                nameId = e;
-            }
-            else if (e.type === 'AssignmentPattern') {
-                // [a = 1] --> [__a = 1]
-                nameId = e.left;
-            }
-            else if (e.type === 'RestElement') {
-                // [...a] --> [...__a]
-                nameId = e.argument;
-            }
-            else if (e.type === 'ObjectPattern') {
-                processRefObjectPattern(e, statement);
-            }
-            else if (e.type === 'ArrayPattern') {
-                processRefArrayPattern(e, statement);
-            }
-            if (nameId) {
-                registerRefBinding(nameId);
-                // prefix original
-                s.prependRight(nameId.start + startOffset, `__`);
-                // append binding declarations after the parent statement
-                s.appendLeft(statement.end + startOffset, `\nconst ${nameId.name} = ${helper('shallowRef')}(__${nameId.name});`);
-            }
-        }
-    }
     function genRuntimeProps(props) {
         const keys = Object.keys(props);
         if (!keys.length) {
@@ -1725,21 +1569,22 @@ function compileScript(sfc, options) {
             plugins,
             sourceType: 'module'
         }, scriptStartOffset);
-        for (const node of scriptAst) {
+        for (const node of scriptAst.body) {
             if (node.type === 'ImportDeclaration') {
                 // record imports for dedupe
                 for (const specifier of node.specifiers) {
                     const imported = specifier.type === 'ImportSpecifier' &&
                         specifier.imported.type === 'Identifier' &&
                         specifier.imported.name;
-                    registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === 'type', false, specifier.local);
+                    registerUserImport(node.source.value, specifier.local.name, imported, node.importKind === 'type', false);
                 }
             }
             else if (node.type === 'ExportDefaultDeclaration') {
                 // export default
                 defaultExport = node;
                 const start = node.start + scriptStartOffset;
-                s.overwrite(start, start + `export default`.length, `const ${defaultTempVar} =`);
+                const end = node.declaration.start + scriptStartOffset;
+                s.overwrite(start, end, `const ${defaultTempVar} = `);
             }
             else if (node.type === 'ExportNamedDeclaration' && node.specifiers) {
                 const defaultSpecifier = node.specifiers.find(s => s.exported.type === 'Identifier' && s.exported.name === 'default');
@@ -1765,6 +1610,20 @@ function compileScript(sfc, options) {
                     }
                 }
             }
+            else if ((node.type === 'VariableDeclaration' ||
+                node.type === 'FunctionDeclaration' ||
+                node.type === 'ClassDeclaration') &&
+                !node.declare) {
+                walkDeclaration(node, setupBindings, userImportAlias);
+            }
+        }
+        // apply ref transform
+        if (enableRefTransform && refTransform.shouldTransform(script.content)) {
+            const { rootVars, importedHelpers } = refTransform.transformAST(scriptAst, s, scriptStartOffset);
+            refBindings = rootVars;
+            for (const h of importedHelpers) {
+                helperImports.add(h);
+            }
         }
     }
     // 2. parse <script setup> and  walk over top level statements
@@ -1776,7 +1635,7 @@ function compileScript(sfc, options) {
         ],
         sourceType: 'module'
     }, startOffset);
-    for (const node of scriptSetupAst) {
+    for (const node of scriptSetupAst.body) {
         const start = node.start + startOffset;
         let end = node.end + startOffset;
         // locate comment
@@ -1796,9 +1655,8 @@ function compileScript(sfc, options) {
             node.label.name === 'ref' &&
             node.body.type === 'ExpressionStatement') {
             error(`ref sugar using the label syntax was an experimental proposal and ` +
-                `has been dropped based on community feedback.`, 
-            // TODO + ` Please check out the adjusted proposal at ...`,
-            node);
+                `has been dropped based on community feedback. Please check out ` +
+                `the new proposal at https://github.com/vuejs/rfcs/discussions/369`, node);
         }
         if (node.type === 'ImportDeclaration') {
             // import declarations are moved to top
@@ -1841,7 +1699,7 @@ function compileScript(sfc, options) {
                     }
                 }
                 else {
-                    registerUserImport(source, local, imported, node.importKind === 'type', true, specifier.local);
+                    registerUserImport(source, local, imported, node.importKind === 'type', true);
                 }
             }
             if (node.specifiers.length && removed === node.specifiers.length) {
@@ -1895,9 +1753,6 @@ function compileScript(sfc, options) {
                             left--;
                         }
                     }
-                    else {
-                        processRefSugar(decl, node);
-                    }
                 }
             }
         }
@@ -1914,7 +1769,7 @@ function compileScript(sfc, options) {
             node.type.endsWith('Statement')) {
             estreeWalker.walk(node, {
                 enter(child, parent) {
-                    if (isFunction(child)) {
+                    if (CompilerDOM.isFunctionType(child)) {
                         this.skip();
                     }
                     if (child.type === 'AwaitExpression') {
@@ -1946,74 +1801,12 @@ function compileScript(sfc, options) {
             }
         }
     }
-    // in parse only mode, we should have collected all the information we need,
-    // return early.
-    if (parseOnly) {
-        for (const key in userImports) {
-            const { rangeNode, isFromSetup } = userImports[key];
-            const bindings = isFromSetup
-                ? ranges.scriptSetupBindings
-                : ranges.scriptBindings;
-            bindings.push(toTextRange(rangeNode));
-        }
-        for (const key in setupBindings) {
-            ranges.scriptSetupBindings.push(toTextRange(setupBindings[key].rangeNode));
-        }
-        if (propsRuntimeDecl) {
-            ranges.propsRuntimeArg = toTextRange(propsRuntimeDecl);
-        }
-        if (propsTypeDeclRaw) {
-            ranges.propsTypeArg = toTextRange(propsTypeDeclRaw);
-        }
-        if (emitsRuntimeDecl) {
-            ranges.emitsRuntimeArg = toTextRange(emitsRuntimeDecl);
-        }
-        if (emitsTypeDeclRaw) {
-            ranges.emitsTypeArg = toTextRange(emitsTypeDeclRaw);
-        }
-        if (propsRuntimeDefaults) {
-            ranges.withDefaultsArg = toTextRange(propsRuntimeDefaults);
-        }
-        return Object.assign(Object.assign({}, scriptSetup), { ranges,
-            scriptAst,
-            scriptSetupAst });
-    }
-    // 3. Do a full walk to rewrite identifiers referencing let exports with ref
-    // value access
-    if (enableRefSugar) {
-        const onIdent = (id, parent, parentStack) => {
-            if (refBindings[id.name] && !refIdentifiers.has(id)) {
-                if (isStaticProperty(parent) && parent.shorthand) {
-                    // let binding used in a property shorthand
-                    // { foo } -> { foo: foo.value }
-                    // skip for destructure patterns
-                    if (!parent.inPattern ||
-                        isInDestructureAssignment(parent, parentStack)) {
-                        s.appendLeft(id.end + startOffset, `: ${id.name}.value`);
-                    }
-                }
-                else {
-                    s.appendLeft(id.end + startOffset, '.value');
-                }
-            }
-        };
-        const onNode = (node, parent) => {
-            if (isCallOf(node, $RAW)) {
-                s.remove(node.callee.start + startOffset, node.callee.end + startOffset);
-                return false; // skip walk
-            }
-            else if (parent &&
-                isCallOf(node, isRefSugarCall) &&
-                (parent.type !== 'VariableDeclarator' || node !== parent.init)) {
-                error(
-                // @ts-ignore
-                `${node.callee.name} can only be used directly as a variable initializer.`, node);
-            }
-        };
-        for (const node of scriptSetupAst) {
-            if (node.type !== 'ImportDeclaration') {
-                walkIdentifiers(node, onIdent, onNode);
-            }
+    // 3. Apply ref sugar transform
+    if (enableRefTransform && refTransform.shouldTransform(scriptSetup.content)) {
+        const { rootVars, importedHelpers } = refTransform.transformAST(scriptSetupAst, s, startOffset, refBindings);
+        refBindings = refBindings ? [...refBindings, ...rootVars] : rootVars;
+        for (const h of importedHelpers) {
+            helperImports.add(h);
         }
     }
     // 4. extract runtime props/emits code from setup context type
@@ -2050,7 +1843,7 @@ function compileScript(sfc, options) {
     }
     // 7. analyze binding metadata
     if (scriptAst) {
-        Object.assign(bindingMetadata, analyzeScriptBindings(scriptAst));
+        Object.assign(bindingMetadata, analyzeScriptBindings(scriptAst.body));
     }
     if (propsRuntimeDecl) {
         for (const key of getObjectOrArrayExpressionKeys(propsRuntimeDecl)) {
@@ -2069,11 +1862,13 @@ function compileScript(sfc, options) {
                 : "setup-maybe-ref" /* SETUP_MAYBE_REF */;
     }
     for (const key in setupBindings) {
-        bindingMetadata[key] = setupBindings[key].type;
+        bindingMetadata[key] = setupBindings[key];
     }
     // known ref bindings
-    for (const key in refBindings) {
-        bindingMetadata[key] = "setup-ref" /* SETUP_REF */;
+    if (refBindings) {
+        for (const key of refBindings) {
+            bindingMetadata[key] = "setup-ref" /* SETUP_REF */;
+        }
     }
     // 8. inject `useCssVars` calls
     if (cssVars.length) {
@@ -2206,8 +2001,14 @@ function compileScript(sfc, options) {
         // wrap setup code with function.
         // export the content of <script setup> as a named export, `setup`.
         // this allows `import { setup } from '*.vue'` for testing purposes.
-        s.prependLeft(startOffset, `\nexport default ${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
-        s.appendRight(endOffset, `})`);
+        if (defaultExport) {
+            s.prependLeft(startOffset, `\n${hasAwait ? `async ` : ``}function setup(${args}) {\n`);
+            s.append(`\nexport default ${helper(`defineComponent`)}({${def}${runtimeOptions}\n  setup})`);
+        }
+        else {
+            s.prependLeft(startOffset, `\nexport default ${helper(`defineComponent`)}({${def}${runtimeOptions}\n  ${hasAwait ? `async ` : ``}setup(${args}) {\n${exposeCall}`);
+            s.appendRight(endOffset, `})`);
+        }
     }
     else {
         if (defaultExport) {
@@ -2232,14 +2033,10 @@ function compileScript(sfc, options) {
             source: filename,
             hires: true,
             includeContent: true
-        }), scriptAst,
-        scriptSetupAst });
+        }), scriptAst: scriptAst === null || scriptAst === void 0 ? void 0 : scriptAst.body, scriptSetupAst: scriptSetupAst === null || scriptSetupAst === void 0 ? void 0 : scriptSetupAst.body });
 }
 function registerBinding(bindings, node, type) {
-    bindings[node.name] = {
-        type,
-        rangeNode: node
-    };
+    bindings[node.name] = type;
 }
 function walkDeclaration(node, bindings, userImportAlias) {
     if (node.type === 'VariableDeclaration') {
@@ -2287,10 +2084,7 @@ function walkDeclaration(node, bindings, userImportAlias) {
         node.type === 'ClassDeclaration') {
         // export function foo() {} / export class Foo {}
         // export declarations must be named.
-        bindings[node.id.name] = {
-            type: "setup-const" /* SETUP_CONST */,
-            rangeNode: node.id
-        };
+        bindings[node.id.name] = "setup-const" /* SETUP_CONST */;
     }
 }
 function walkObjectPattern(node, bindings, isConst, isDefineCall = false) {
@@ -2454,7 +2248,7 @@ function inferRuntimeType(node, declaredTypes) {
             return inferRuntimeType(node.typeAnnotation, declaredTypes);
         case 'TSUnionType':
             return [
-                ...new Set([].concat(node.types.map(t => inferRuntimeType(t, declaredTypes))))
+                ...new Set([].concat(...node.types.map(t => inferRuntimeType(t, declaredTypes))))
             ];
         case 'TSIntersectionType':
             return ['Object'];
@@ -2463,11 +2257,7 @@ function inferRuntimeType(node, declaredTypes) {
     }
 }
 function toRuntimeTypeString(types) {
-    return types.some(t => t === 'null')
-        ? `null`
-        : types.length > 1
-            ? `[${types.join(', ')}]`
-            : types[0];
+    return types.length > 1 ? `[${types.join(', ')}]` : types[0];
 }
 function extractRuntimeEmits(node, emits) {
     if (node.type === 'TSTypeLiteral' || node.type === 'TSInterfaceBody') {
@@ -2489,11 +2279,14 @@ function extractEventNames(eventName, emits) {
         eventName.typeAnnotation.type === 'TSTypeAnnotation') {
         const typeNode = eventName.typeAnnotation.typeAnnotation;
         if (typeNode.type === 'TSLiteralType') {
-            emits.add(String(typeNode.literal.value));
+            if (typeNode.literal.type !== 'UnaryExpression') {
+                emits.add(String(typeNode.literal.value));
+            }
         }
         else if (typeNode.type === 'TSUnionType') {
             for (const t of typeNode.types) {
-                if (t.type === 'TSLiteralType') {
+                if (t.type === 'TSLiteralType' &&
+                    t.literal.type !== 'UnaryExpression') {
                     emits.add(String(t.literal.value));
                 }
             }
@@ -2507,146 +2300,6 @@ function genRuntimeEmits(emits) {
             .join(', ')}] as unknown as undefined,`
         : ``;
 }
-function markScopeIdentifier(node, child, knownIds) {
-    const { name } = child;
-    if (node.scopeIds && node.scopeIds.has(name)) {
-        return;
-    }
-    if (name in knownIds) {
-        knownIds[name]++;
-    }
-    else {
-        knownIds[name] = 1;
-    }
-    (node.scopeIds || (node.scopeIds = new Set())).add(name);
-}
-/**
- * Walk an AST and find identifiers that are variable references.
- * This is largely the same logic with `transformExpressions` in compiler-core
- * but with some subtle differences as this needs to handle a wider range of
- * possible syntax.
- */
-function walkIdentifiers(root, onIdentifier, onNode) {
-    const parentStack = [];
-    const knownIds = Object.create(null);
-    estreeWalker.walk(root, {
-        enter(node, parent) {
-            parent && parentStack.push(parent);
-            if (parent &&
-                parent.type.startsWith('TS') &&
-                parent.type !== 'TSAsExpression' &&
-                parent.type !== 'TSNonNullExpression' &&
-                parent.type !== 'TSTypeAssertion') {
-                return this.skip();
-            }
-            if (onNode && onNode(node, parent, parentStack) === false) {
-                return this.skip();
-            }
-            if (node.type === 'Identifier') {
-                if (!knownIds[node.name] &&
-                    isRefIdentifier(node, parent, parentStack)) {
-                    onIdentifier(node, parent, parentStack);
-                }
-            }
-            else if (isFunction(node)) {
-                // #3445
-                // should not rewrite local variables sharing a name with a top-level ref
-                if (node.body.type === 'BlockStatement') {
-                    node.body.body.forEach(p => {
-                        if (p.type === 'VariableDeclaration') {
-                            for (const decl of p.declarations) {
-                                extractIdentifiers(decl.id).forEach(id => {
-                                    markScopeIdentifier(node, id, knownIds);
-                                });
-                            }
-                        }
-                    });
-                }
-                // walk function expressions and add its arguments to known identifiers
-                // so that we don't prefix them
-                node.params.forEach(p => estreeWalker.walk(p, {
-                    enter(child, parent) {
-                        if (child.type === 'Identifier' &&
-                            // do not record as scope variable if is a destructured key
-                            !isStaticPropertyKey(child, parent) &&
-                            // do not record if this is a default value
-                            // assignment of a destructured variable
-                            !(parent &&
-                                parent.type === 'AssignmentPattern' &&
-                                parent.right === child)) {
-                            markScopeIdentifier(node, child, knownIds);
-                        }
-                    }
-                }));
-            }
-            else if (node.type === 'ObjectProperty' &&
-                parent.type === 'ObjectPattern') {
-                node.inPattern = true;
-            }
-        },
-        leave(node, parent) {
-            parent && parentStack.pop();
-            if (node.scopeIds) {
-                node.scopeIds.forEach((id) => {
-                    knownIds[id]--;
-                    if (knownIds[id] === 0) {
-                        delete knownIds[id];
-                    }
-                });
-            }
-        }
-    });
-}
-function isRefIdentifier(id, parent, parentStack) {
-    if (!parent) {
-        return true;
-    }
-    // declaration id
-    if ((parent.type === 'VariableDeclarator' ||
-        parent.type === 'ClassDeclaration') &&
-        parent.id === id) {
-        return false;
-    }
-    if (isFunction(parent)) {
-        // function decalration/expression id
-        if (parent.id === id) {
-            return false;
-        }
-        // params list
-        if (parent.params.includes(id)) {
-            return false;
-        }
-    }
-    // property key
-    // this also covers object destructure pattern
-    if (isStaticPropertyKey(id, parent)) {
-        return false;
-    }
-    // non-assignment array destructure pattern
-    if (parent.type === 'ArrayPattern' &&
-        !isInDestructureAssignment(parent, parentStack)) {
-        return false;
-    }
-    // member expression property
-    if ((parent.type === 'MemberExpression' ||
-        parent.type === 'OptionalMemberExpression') &&
-        parent.property === id &&
-        !parent.computed) {
-        return false;
-    }
-    // is a special keyword but parsed as identifier
-    if (id.name === 'arguments') {
-        return false;
-    }
-    return true;
-}
-const isStaticProperty = (node) => node &&
-    (node.type === 'ObjectProperty' || node.type === 'ObjectMethod') &&
-    !node.computed;
-const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
-function isFunction(node) {
-    return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-}
 function isCallOf(node, test) {
     return !!(node &&
         node.type === 'CallExpression' &&
@@ -2679,25 +2332,6 @@ function canNeverBeRef(node, userReactiveImport) {
             return false;
     }
 }
-function isInDestructureAssignment(parent, parentStack) {
-    if (parent &&
-        (parent.type === 'ObjectProperty' || parent.type === 'ArrayPattern')) {
-        let i = parentStack.length;
-        while (i--) {
-            const p = parentStack[i];
-            if (p.type === 'AssignmentExpression') {
-                const root = parentStack[0];
-                // if this is a ref: destructure, it should be treated like a
-                // variable decalration!
-                return !(root.type === 'LabeledStatement' && root.label.name === 'ref');
-            }
-            else if (p.type !== 'ObjectProperty' && !p.type.endsWith('Pattern')) {
-                break;
-            }
-        }
-    }
-    return false;
-}
 /**
  * Analyze bindings in normal `<script>`
  * Note that `compileScriptSetup` already analyzes bindings as part of its
@@ -2808,49 +2442,6 @@ function getObjectOrArrayExpressionKeys(value) {
     }
     return [];
 }
-function extractIdentifiers(param, nodes = []) {
-    switch (param.type) {
-        case 'Identifier':
-            nodes.push(param);
-            break;
-        case 'MemberExpression':
-            let object = param;
-            while (object.type === 'MemberExpression') {
-                object = object.object;
-            }
-            nodes.push(object);
-            break;
-        case 'ObjectPattern':
-            param.properties.forEach(prop => {
-                if (prop.type === 'RestElement') {
-                    extractIdentifiers(prop.argument, nodes);
-                }
-                else {
-                    extractIdentifiers(prop.value, nodes);
-                }
-            });
-            break;
-        case 'ArrayPattern':
-            param.elements.forEach(element => {
-                if (element)
-                    extractIdentifiers(element, nodes);
-            });
-            break;
-        case 'RestElement':
-            extractIdentifiers(param.argument, nodes);
-            break;
-        case 'AssignmentPattern':
-            extractIdentifiers(param.left, nodes);
-            break;
-    }
-    return nodes;
-}
-function toTextRange(node) {
-    return {
-        start: node.start,
-        end: node.end
-    };
-}
 const templateUsageCheckCache = createCache();
 function resolveTemplateUsageCheckString(sfc) {
     const { content, ast } = sfc.template;
@@ -2865,7 +2456,7 @@ function resolveTemplateUsageCheckString(sfc) {
                 if (node.type === 1 /* ELEMENT */) {
                     if (!CompilerDOM.parserOptions.isNativeTag(node.tag) &&
                         !CompilerDOM.parserOptions.isBuiltInComponent(node.tag)) {
-                        code += `,${shared.capitalize(shared.camelize(node.tag))}`;
+                        code += `,${shared.camelize(node.tag)},${shared.capitalize(shared.camelize(node.tag))}`;
                     }
                     for (let i = 0; i < node.props.length; i++) {
                         const prop = node.props[i];
@@ -2890,17 +2481,32 @@ function resolveTemplateUsageCheckString(sfc) {
     return code;
 }
 function stripStrings(exp) {
-    return exp.replace(/'[^']+'|"[^"]+"|`[^`]+`/g, '');
+    return exp
+        .replace(/'[^']+'|"[^"]+"/g, '')
+        .replace(/`[^`]+`/g, stripTemplateString);
+}
+function stripTemplateString(str) {
+    const interpMatch = str.match(/\${[^}]+}/g);
+    if (interpMatch) {
+        return interpMatch.map(m => m.slice(2, -1)).join(',');
+    }
+    return '';
 }
 
+exports.extractIdentifiers = compilerCore.extractIdentifiers;
 exports.generateCodeFrame = compilerCore.generateCodeFrame;
+exports.isInDestructureAssignment = compilerCore.isInDestructureAssignment;
+exports.isStaticProperty = compilerCore.isStaticProperty;
+exports.walkIdentifiers = compilerCore.walkIdentifiers;
 exports.MagicString = MagicString__default;
 exports.babelParse = parser.parse;
 exports.walk = estreeWalker.walk;
+exports.shouldTransformRef = refTransform.shouldTransform;
+exports.transformRef = refTransform.transform;
+exports.transformRefAST = refTransform.transformAST;
 exports.compileScript = compileScript;
 exports.compileStyle = compileStyle;
 exports.compileStyleAsync = compileStyleAsync;
 exports.compileTemplate = compileTemplate;
 exports.parse = parse;
 exports.rewriteDefault = rewriteDefault;
-exports.walkIdentifiers = walkIdentifiers;