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

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.2
 * (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);
@@ -19144,7 +19143,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"];
@@ -20856,7 +20855,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.5.0-beta.1";
+const version = "3.5.0-beta.2";
 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.2
 * (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]);
@@ -16921,8 +16920,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 +16983,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 +16995,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(
     {
@@ -24296,7 +24316,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 +24359,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 +24530,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 +25703,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 +26588,7 @@ function parse$7(source, options = {}) {
     pad = false,
     ignoreEmpty = true,
     compiler = CompilerDOM,
-    templateParseOptions = {},
-    parseExpressions = true
+    templateParseOptions = {}
   } = options;
   const descriptor = {
     filename,
@@ -26584,7 +26605,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);
@@ -47024,7 +47045,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"];
@@ -48766,7 +48787,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.0-beta.1";
+const version = "3.5.0-beta.2";
 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.2",
   "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.2",
+    "@vue/compiler-ssr": "3.5.0-beta.2",
+    "@vue/compiler-dom": "3.5.0-beta.2",
+    "@vue/shared": "3.5.0-beta.2"
   },
   "devDependencies": {
     "@babel/types": "^7.25.2",