@vue/compiler-sfc 3.5.0-beta.1 → 3.5.0-beta.3

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.0-beta.1
+* @vue/compiler-sfc v3.5.0-beta.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -1831,8 +1831,7 @@ function parse$2(source, options = {}) {
     pad = false,
     ignoreEmpty = true,
     compiler = CompilerDOM__namespace,
-    templateParseOptions = {},
-    parseExpressions = true
+    templateParseOptions = {}
   } = options;
   const descriptor = {
     filename,
@@ -1849,7 +1848,7 @@ function parse$2(source, options = {}) {
   const errors = [];
   const ast = compiler.parse(source, {
     parseMode: "sfc",
-    prefixIdentifiers: parseExpressions,
+    prefixIdentifiers: true,
     ...templateParseOptions,
     onError: (e) => {
       errors.push(e);
@@ -6941,7 +6940,7 @@ tokenTypes.combinator = combinator$1;
 	    }
 	    // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
 	    var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
-	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
 	      var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
 	      if (nodes.length > 0) {
 	        var last = this.current.last;
@@ -17974,6 +17973,7 @@ function innerResolveTypeElements(ctx, node, scope, typeParameters) {
       );
     }
     case "TSExpressionWithTypeArguments":
+    // referenced by interface extends
     case "TSTypeReference": {
       const typeName = getReferenceName(node);
       if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
@@ -19022,6 +19022,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
               case "ConstructorParameters":
               case "ReadonlyArray":
                 return ["String", "Number"];
+              // TS built-in utility types
               case "Record":
               case "Partial":
               case "Required":
@@ -19075,6 +19076,8 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
               case "Promise":
               case "Error":
                 return [node.typeName.name];
+              // TS built-in utility types
+              // https://www.typescriptlang.org/docs/handbook/utility-types.html
               case "Partial":
               case "Required":
               case "Readonly":
@@ -19144,7 +19147,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         return ["Symbol"];
       case "TSIndexedAccessType": {
         const types = resolveIndexType(ctx, node, scope);
-        return flattenTypes(ctx, types, scope);
+        return flattenTypes(ctx, types, scope, isKeyOf);
       }
       case "ClassDeclaration":
         return ["Object"];
@@ -19171,6 +19174,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         }
         break;
       }
+      // e.g. readonly
       case "TSTypeOperator": {
         return inferRuntimeType(
           ctx,
@@ -20836,12 +20840,14 @@ function isStaticNode(node) {
     case "UnaryExpression":
       return isStaticNode(node.argument);
     case "LogicalExpression":
+    // 1 > 2
     case "BinaryExpression":
       return isStaticNode(node.left) && isStaticNode(node.right);
     case "ConditionalExpression": {
       return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate);
     }
     case "SequenceExpression":
+    // (1, 2)
     case "TemplateLiteral":
       return node.expressions.every((expr) => isStaticNode(expr));
     case "ParenthesizedExpression":
@@ -20856,7 +20862,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.5.0-beta.1";
+const version = "3.5.0-beta.3";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

package/dist/compiler-sfc.d.ts

@@ -160,11 +160,6 @@ export interface SFCParseOptions {
     ignoreEmpty?: boolean;
     compiler?: TemplateCompiler;
     templateParseOptions?: ParserOptions;
-    /**
-     * TODO remove in 3.5
-     * @deprecated use `templateParseOptions: { prefixIdentifiers: false }` instead
-     */
-    parseExpressions?: boolean;
 }
 export interface SFCBlock {
     type: string;

package/dist/compiler-sfc.esm-browser.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.0-beta.1
+* @vue/compiler-sfc v3.5.0-beta.3
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -764,13 +764,13 @@ const decodeMap = new Map([
  * Polyfill for `String.fromCodePoint`. It is used to create a string from a Unicode code point.
  */
 const fromCodePoint = 
-// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, node/no-unsupported-features/es-builtins
 (_a$1 = String.fromCodePoint) !== null && _a$1 !== void 0 ? _a$1 : function (codePoint) {
     let output = "";
-    if (codePoint > 65535) {
-        codePoint -= 65536;
-        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);
-        codePoint = 56320 | (codePoint & 1023);
+    if (codePoint > 0xffff) {
+        codePoint -= 0x10000;
+        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
+        codePoint = 0xdc00 | (codePoint & 0x3ff);
     }
     output += String.fromCharCode(codePoint);
     return output;
@@ -782,9 +782,8 @@ const fromCodePoint =
  */
 function replaceCodePoint(codePoint) {
     var _a;
-    if ((codePoint >= 55296 && codePoint <= 57343) ||
-        codePoint > 1114111) {
-        return 65533;
+    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
+        return 0xfffd;
     }
     return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
 }
@@ -805,7 +804,7 @@ var CharCodes;
     CharCodes[CharCodes["UPPER_Z"] = 90] = "UPPER_Z";
 })(CharCodes || (CharCodes = {}));
 /** Bit that needs to be set to convert an upper case ASCII character to lower case */
-const TO_LOWER_BIT = 32;
+const TO_LOWER_BIT = 0b100000;
 var BinTrieFlags;
 (function (BinTrieFlags) {
     BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
@@ -906,32 +905,32 @@ class EntityDecoder {
      * Mirrors the implementation of `getDecoder`, but with the ability to stop decoding if the
      * entity is incomplete, and resume when the next string is written.
      *
-     * @param input The string containing the entity (or a continuation of the entity).
+     * @param string The string containing the entity (or a continuation of the entity).
      * @param offset The offset at which the entity begins. Should be 0 if this is not the first call.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    write(input, offset) {
+    write(str, offset) {
         switch (this.state) {
             case EntityDecoderState.EntityStart: {
-                if (input.charCodeAt(offset) === CharCodes.NUM) {
+                if (str.charCodeAt(offset) === CharCodes.NUM) {
                     this.state = EntityDecoderState.NumericStart;
                     this.consumed += 1;
-                    return this.stateNumericStart(input, offset + 1);
+                    return this.stateNumericStart(str, offset + 1);
                 }
                 this.state = EntityDecoderState.NamedEntity;
-                return this.stateNamedEntity(input, offset);
+                return this.stateNamedEntity(str, offset);
             }
             case EntityDecoderState.NumericStart: {
-                return this.stateNumericStart(input, offset);
+                return this.stateNumericStart(str, offset);
             }
             case EntityDecoderState.NumericDecimal: {
-                return this.stateNumericDecimal(input, offset);
+                return this.stateNumericDecimal(str, offset);
             }
             case EntityDecoderState.NumericHex: {
-                return this.stateNumericHex(input, offset);
+                return this.stateNumericHex(str, offset);
             }
             case EntityDecoderState.NamedEntity: {
-                return this.stateNamedEntity(input, offset);
+                return this.stateNamedEntity(str, offset);
             }
         }
     }
@@ -940,28 +939,28 @@ class EntityDecoder {
      *
      * Equivalent to the `Numeric character reference state` in the HTML spec.
      *
-     * @param input The string containing the entity (or a continuation of the entity).
+     * @param str The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    stateNumericStart(input, offset) {
-        if (offset >= input.length) {
+    stateNumericStart(str, offset) {
+        if (offset >= str.length) {
             return -1;
         }
-        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
             this.state = EntityDecoderState.NumericHex;
             this.consumed += 1;
-            return this.stateNumericHex(input, offset + 1);
+            return this.stateNumericHex(str, offset + 1);
         }
         this.state = EntityDecoderState.NumericDecimal;
-        return this.stateNumericDecimal(input, offset);
+        return this.stateNumericDecimal(str, offset);
     }
-    addToNumericResult(input, start, end, base) {
+    addToNumericResult(str, start, end, base) {
         if (start !== end) {
             const digitCount = end - start;
             this.result =
                 this.result * Math.pow(base, digitCount) +
-                    Number.parseInt(input.substr(start, digitCount), base);
+                    parseInt(str.substr(start, digitCount), base);
             this.consumed += digitCount;
         }
     }
@@ -970,23 +969,23 @@ class EntityDecoder {
      *
      * Equivalent to the `Hexademical character reference state` in the HTML spec.
      *
-     * @param input The string containing the entity (or a continuation of the entity).
+     * @param str The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    stateNumericHex(input, offset) {
-        const startIndex = offset;
-        while (offset < input.length) {
-            const char = input.charCodeAt(offset);
+    stateNumericHex(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
             if (isNumber$2(char) || isHexadecimalCharacter(char)) {
                 offset += 1;
             }
             else {
-                this.addToNumericResult(input, startIndex, offset, 16);
+                this.addToNumericResult(str, startIdx, offset, 16);
                 return this.emitNumericEntity(char, 3);
             }
         }
-        this.addToNumericResult(input, startIndex, offset, 16);
+        this.addToNumericResult(str, startIdx, offset, 16);
         return -1;
     }
     /**
@@ -994,23 +993,23 @@ class EntityDecoder {
      *
      * Equivalent to the `Decimal character reference state` in the HTML spec.
      *
-     * @param input The string containing the entity (or a continuation of the entity).
+     * @param str The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    stateNumericDecimal(input, offset) {
-        const startIndex = offset;
-        while (offset < input.length) {
-            const char = input.charCodeAt(offset);
+    stateNumericDecimal(str, offset) {
+        const startIdx = offset;
+        while (offset < str.length) {
+            const char = str.charCodeAt(offset);
             if (isNumber$2(char)) {
                 offset += 1;
             }
             else {
-                this.addToNumericResult(input, startIndex, offset, 10);
+                this.addToNumericResult(str, startIdx, offset, 10);
                 return this.emitNumericEntity(char, 2);
             }
         }
-        this.addToNumericResult(input, startIndex, offset, 10);
+        this.addToNumericResult(str, startIdx, offset, 10);
         return -1;
     }
     /**
@@ -1054,17 +1053,17 @@ class EntityDecoder {
      *
      * Equivalent to the `Named character reference state` in the HTML spec.
      *
-     * @param input The string containing the entity (or a continuation of the entity).
+     * @param str The string containing the entity (or a continuation of the entity).
      * @param offset The current offset.
      * @returns The number of characters that were consumed, or -1 if the entity is incomplete.
      */
-    stateNamedEntity(input, offset) {
+    stateNamedEntity(str, offset) {
         const { decodeTree } = this;
         let current = decodeTree[this.treeIndex];
         // The mask is the number of bytes of the value, including the current byte.
         let valueLength = (current & BinTrieFlags.VALUE_LENGTH) >> 14;
-        for (; offset < input.length; offset++, this.excess++) {
-            const char = input.charCodeAt(offset);
+        for (; offset < str.length; offset++, this.excess++) {
+            const char = str.charCodeAt(offset);
             this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
             if (this.treeIndex < 0) {
                 return this.result === 0 ||
@@ -1171,28 +1170,28 @@ class EntityDecoder {
  * @returns A function that decodes entities in a string.
  */
 function getDecoder(decodeTree) {
-    let returnValue = "";
-    const decoder = new EntityDecoder(decodeTree, (data) => (returnValue += fromCodePoint(data)));
-    return function decodeWithTrie(input, decodeMode) {
+    let ret = "";
+    const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str)));
+    return function decodeWithTrie(str, decodeMode) {
         let lastIndex = 0;
         let offset = 0;
-        while ((offset = input.indexOf("&", offset)) >= 0) {
-            returnValue += input.slice(lastIndex, offset);
+        while ((offset = str.indexOf("&", offset)) >= 0) {
+            ret += str.slice(lastIndex, offset);
             decoder.startEntity(decodeMode);
-            const length = decoder.write(input, 
+            const len = decoder.write(str, 
             // Skip the "&"
             offset + 1);
-            if (length < 0) {
+            if (len < 0) {
                 lastIndex = offset + decoder.end();
                 break;
             }
-            lastIndex = offset + length;
-            // If `length` is 0, skip the current `&` and continue.
-            offset = length === 0 ? lastIndex + 1 : lastIndex;
+            lastIndex = offset + len;
+            // If `len` is 0, skip the current `&` and continue.
+            offset = len === 0 ? lastIndex + 1 : lastIndex;
         }
-        const result = returnValue + input.slice(lastIndex);
+        const result = ret + str.slice(lastIndex);
         // Make sure we don't keep a reference to the final string.
-        returnValue = "";
+        ret = "";
         return result;
     };
 }
@@ -1206,31 +1205,31 @@ function getDecoder(decodeTree) {
  * @param char The current character.
  * @returns The index of the next node, or -1 if no branch is taken.
  */
-function determineBranch(decodeTree, current, nodeIndex, char) {
+function determineBranch(decodeTree, current, nodeIdx, char) {
     const branchCount = (current & BinTrieFlags.BRANCH_LENGTH) >> 7;
     const jumpOffset = current & BinTrieFlags.JUMP_TABLE;
     // Case 1: Single branch encoded in jump offset
     if (branchCount === 0) {
-        return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
+        return jumpOffset !== 0 && char === jumpOffset ? nodeIdx : -1;
     }
     // Case 2: Multiple branches encoded in jump table
     if (jumpOffset) {
         const value = char - jumpOffset;
         return value < 0 || value >= branchCount
             ? -1
-            : decodeTree[nodeIndex + value] - 1;
+            : decodeTree[nodeIdx + value] - 1;
     }
     // Case 3: Multiple branches encoded in dictionary
     // Binary search for the character.
-    let lo = nodeIndex;
+    let lo = nodeIdx;
     let hi = lo + branchCount - 1;
     while (lo <= hi) {
         const mid = (lo + hi) >>> 1;
-        const midValue = decodeTree[mid];
-        if (midValue < char) {
+        const midVal = decodeTree[mid];
+        if (midVal < char) {
             lo = mid + 1;
         }
-        else if (midValue > char) {
+        else if (midVal > char) {
             hi = mid - 1;
         }
         else {
@@ -1244,12 +1243,12 @@ getDecoder(xmlDecodeTree);
 /**
  * Decodes an HTML string.
  *
- * @param htmlString The string to decode.
+ * @param str The string to decode.
  * @param mode The decoding mode.
  * @returns The decoded string.
  */
-function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
-    return htmlDecoder(htmlString, mode);
+function decodeHTML(str, mode = DecodingMode.Legacy) {
+    return htmlDecoder(str, mode);
 }
 
 const defaultDelimitersOpen = new Uint8Array([123, 123]);
@@ -16797,6 +16796,9 @@ const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || no
 const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
 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) {
@@ -16805,12 +16807,23 @@ function isReferenced(node, parent, grandparent) {
       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":
@@ -16818,11 +16831,18 @@ function isReferenced(node, parent, grandparent) {
         return !!parent.computed;
       }
       return false;
+    // yes: { [NODE]: "" }
+    // no: { NODE: "" }
+    // depends: { NODE }
+    // depends: { key: NODE }
     case "ObjectProperty":
       if (parent.key === node) {
         return !!parent.computed;
       }
       return !grandparent;
+    // no: class { NODE = value; }
+    // yes: class { [NODE] = value; }
+    // yes: class { key = NODE; }
     case "ClassProperty":
       if (parent.key === node) {
         return !!parent.computed;
@@ -16830,47 +16850,80 @@ function isReferenced(node, parent, grandparent) {
       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":
       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 = { someProperty: 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;
@@ -16921,8 +16974,9 @@ const isSimpleIdentifier = (name) => !nonIdentifierRE.test(name);
 const validFirstIdentCharRE = /[A-Za-z_$\xA0-\uFFFF]/;
 const validIdentCharRE = /[\.\?\w$\xA0-\uFFFF]/;
 const whitespaceRE = /\s+[.[]\s*|\s*[.[]\s+/g;
-const isMemberExpressionBrowser = (path) => {
-  path = path.trim().replace(whitespaceRE, (s) => s.trim());
+const getExpSource = (exp) => exp.type === 4 ? exp.content : exp.loc.source;
+const isMemberExpressionBrowser = (exp) => {
+  const path = getExpSource(exp).trim().replace(whitespaceRE, (s) => s.trim());
   let state = 0 /* inMemberExp */;
   let stateStack = [];
   let currentOpenBracketCount = 0;
@@ -16983,10 +17037,10 @@ const isMemberExpressionBrowser = (path) => {
   }
   return !currentOpenBracketCount && !currentOpenParensCount;
 };
-const isMemberExpressionNode = (path, context) => {
+const isMemberExpressionNode = (exp, context) => {
   try {
-    let ret = parseExpression_1(path, {
-      plugins: context.expressionPlugins
+    let ret = exp.ast || parseExpression_1(getExpSource(exp), {
+      plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"]
     });
     ret = unwrapTSNode(ret);
     return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier" && ret.name !== "undefined";
@@ -16995,6 +17049,26 @@ const isMemberExpressionNode = (path, context) => {
   }
 };
 const isMemberExpression = isMemberExpressionNode;
+const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
+const isFnExpressionBrowser = (exp) => fnExpRE.test(getExpSource(exp));
+const isFnExpressionNode = (exp, context) => {
+  try {
+    let ret = exp.ast || parseExpression_1(getExpSource(exp), {
+      plugins: context.expressionPlugins ? [...context.expressionPlugins, "typescript"] : ["typescript"]
+    });
+    if (ret.type === "Program") {
+      ret = ret.body[0];
+      if (ret.type === "ExpressionStatement") {
+        ret = ret.expression;
+      }
+    }
+    ret = unwrapTSNode(ret);
+    return ret.type === "FunctionExpression" || ret.type === "ArrowFunctionExpression";
+  } catch (e) {
+    return false;
+  }
+};
+const isFnExpression = isFnExpressionNode;
 function advancePositionWithClone(pos, source, numberOfCharacters = source.length) {
   return advancePositionWithMutation(
     {
@@ -17499,7 +17573,9 @@ const tokenizer$2 = new Tokenizer$1(stack, {
         case 17:
         case 18:
         case 19:
+        // "
         case 20:
+        // '
         case 21:
           emitError(9, end);
           break;
@@ -18448,6 +18524,7 @@ function traverseNode(node, context) {
         context.helper(TO_DISPLAY_STRING);
       }
       break;
+    // for container types, further traverse downwards
     case 9:
       for (let i2 = 0; i2 < node.branches.length; i2++) {
         traverseNode(node.branches[i2], context);
@@ -22263,6 +22340,7 @@ function genNode(node, context) {
     case 21:
       genNodeList(node.body, context, true, false);
       break;
+    // SSR only types
     case 22:
       genTemplateLiteral(node, context);
       break;
@@ -22278,6 +22356,7 @@ function genNode(node, context) {
     case 26:
       genReturnStatement(node, context);
       break;
+    /* istanbul ignore next */
     case 10:
       break;
     default:
@@ -24296,7 +24375,6 @@ function processSlotOutlet(node, context) {
   };
 }
 
-const fnExpRE = /^\s*(async\s*)?(\([^)]*?\)|[\w$_]+)\s*(:[^=]+)?=>|^\s*(async\s+)?function(?:\s+[\w$]+)?\s*\(/;
 const transformOn$1 = (dir, node, context, augmentor) => {
   const { loc, modifiers, arg } = dir;
   if (!dir.exp && !modifiers.length) {
@@ -24340,8 +24418,8 @@ const transformOn$1 = (dir, node, context, augmentor) => {
   }
   let shouldCache = context.cacheHandlers && !exp && !context.inVOnce;
   if (exp) {
-    const isMemberExp = isMemberExpression(exp.content, context);
-    const isInlineStatement = !(isMemberExp || fnExpRE.test(exp.content));
+    const isMemberExp = isMemberExpression(exp, context);
+    const isInlineStatement = !(isMemberExp || isFnExpression(exp, context));
     const hasMultipleStatements = exp.content.includes(`;`);
     if (context.prefixIdentifiers) {
       isInlineStatement && context.addIdentifiers(`$event`);
@@ -24511,7 +24589,7 @@ const transformModel$1 = (dir, node, context) => {
     return createTransformProps();
   }
   const maybeRef = context.inline && (bindingType === "setup-let" || bindingType === "setup-ref" || bindingType === "setup-maybe-ref");
-  if (!expString.trim() || !isMemberExpression(expString, context) && !maybeRef) {
+  if (!expString.trim() || !isMemberExpression(exp, context) && !maybeRef) {
     context.onError(
       createCompilerError(42, exp.loc)
     );
@@ -25684,6 +25762,9 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   helperNameMap: helperNameMap,
   injectProp: injectProp,
   isCoreComponent: isCoreComponent,
+  isFnExpression: isFnExpression,
+  isFnExpressionBrowser: isFnExpressionBrowser,
+  isFnExpressionNode: isFnExpressionNode,
   isFunctionType: isFunctionType,
   isInDestructureAssignment: isInDestructureAssignment,
   isInNewExpression: isInNewExpression,
@@ -26566,8 +26647,7 @@ function parse$7(source, options = {}) {
     pad = false,
     ignoreEmpty = true,
     compiler = CompilerDOM,
-    templateParseOptions = {},
-    parseExpressions = true
+    templateParseOptions = {}
   } = options;
   const descriptor = {
     filename,
@@ -26584,7 +26664,7 @@ function parse$7(source, options = {}) {
   const errors = [];
   const ast = compiler.parse(source, __spreadProps$9(__spreadValues$a({
     parseMode: "sfc",
-    prefixIdentifiers: parseExpressions
+    prefixIdentifiers: true
   }, templateParseOptions), {
     onError: (e) => {
       errors.push(e);
@@ -39645,7 +39725,7 @@ tokenTypes.combinator = combinator$1;
 	    }
 	    // We need to decide between a space that's a descendant combinator and meaningless whitespace at the end of a selector.
 	    var nextSigTokenPos = this.locateNextMeaningfulToken(this.position);
-	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma) {
+	    if (nextSigTokenPos < 0 || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.comma || this.tokens[nextSigTokenPos][_tokenize.FIELDS.TYPE] === tokens.closeParenthesis) {
 	      var nodes = this.parseWhitespaceEquivalentTokens(nextSigTokenPos);
 	      if (nodes.length > 0) {
 	        var last = this.current.last;
@@ -45942,6 +46022,7 @@ function innerResolveTypeElements(ctx, node, scope, typeParameters) {
       );
     }
     case "TSExpressionWithTypeArguments":
+    // referenced by interface extends
     case "TSTypeReference": {
       const typeName = getReferenceName(node);
       if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
@@ -46902,6 +46983,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
               case "ConstructorParameters":
               case "ReadonlyArray":
                 return ["String", "Number"];
+              // TS built-in utility types
               case "Record":
               case "Partial":
               case "Required":
@@ -46955,6 +47037,8 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
               case "Promise":
               case "Error":
                 return [node.typeName.name];
+              // TS built-in utility types
+              // https://www.typescriptlang.org/docs/handbook/utility-types.html
               case "Partial":
               case "Required":
               case "Readonly":
@@ -47024,7 +47108,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         return ["Symbol"];
       case "TSIndexedAccessType": {
         const types = resolveIndexType(ctx, node, scope);
-        return flattenTypes(ctx, types, scope);
+        return flattenTypes(ctx, types, scope, isKeyOf);
       }
       case "ClassDeclaration":
         return ["Object"];
@@ -47051,6 +47135,7 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
         }
         break;
       }
+      // e.g. readonly
       case "TSTypeOperator": {
         return inferRuntimeType(
           ctx,
@@ -48730,12 +48815,14 @@ function isStaticNode(node) {
     case "UnaryExpression":
       return isStaticNode(node.argument);
     case "LogicalExpression":
+    // 1 > 2
     case "BinaryExpression":
       return isStaticNode(node.left) && isStaticNode(node.right);
     case "ConditionalExpression": {
       return isStaticNode(node.test) && isStaticNode(node.consequent) && isStaticNode(node.alternate);
     }
     case "SequenceExpression":
+    // (1, 2)
     case "TemplateLiteral":
       return node.expressions.every((expr) => isStaticNode(expr));
     case "ParenthesizedExpression":
@@ -48766,7 +48853,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.0-beta.1";
+const version = "3.5.0-beta.3";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vue/compiler-sfc",
-  "version": "3.5.0-beta.1",
+  "version": "3.5.0-beta.3",
   "description": "@vue/compiler-sfc",
   "main": "dist/compiler-sfc.cjs.js",
   "module": "dist/compiler-sfc.esm-browser.js",
@@ -45,12 +45,12 @@
     "@babel/parser": "^7.25.3",
     "estree-walker": "^2.0.2",
     "magic-string": "^0.30.11",
-    "postcss": "^8.4.40",
+    "postcss": "^8.4.41",
     "source-map-js": "^1.2.0",
-    "@vue/compiler-core": "3.5.0-beta.1",
-    "@vue/compiler-dom": "3.5.0-beta.1",
-    "@vue/compiler-ssr": "3.5.0-beta.1",
-    "@vue/shared": "3.5.0-beta.1"
+    "@vue/compiler-core": "3.5.0-beta.3",
+    "@vue/compiler-ssr": "3.5.0-beta.3",
+    "@vue/shared": "3.5.0-beta.3",
+    "@vue/compiler-dom": "3.5.0-beta.3"
   },
   "devDependencies": {
     "@babel/types": "^7.25.2",
@@ -60,7 +60,7 @@
     "merge-source-map": "^1.1.0",
     "minimatch": "~9.0.5",
     "postcss-modules": "^6.0.0",
-    "postcss-selector-parser": "^6.1.1",
+    "postcss-selector-parser": "^6.1.2",
     "pug": "^3.0.3",
     "sass": "^1.77.8"
   }