@vue/compiler-sfc 3.4.36 → 3.4.38

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.36
+* @vue/compiler-sfc v3.4.38
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -19144,7 +19144,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"];
@@ -20857,7 +20857,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.4.36";
+const version = "3.4.38";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

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

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.36
+* @vue/compiler-sfc v3.4.38
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -725,13 +725,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;
@@ -743,9 +743,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;
 }
@@ -766,7 +765,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";
@@ -867,32 +866,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);
             }
         }
     }
@@ -901,28 +900,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;
         }
     }
@@ -931,23 +930,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;
     }
     /**
@@ -955,23 +954,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;
     }
     /**
@@ -1015,17 +1014,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 ||
@@ -1132,28 +1131,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;
     };
 }
@@ -1167,31 +1166,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 {
@@ -1205,12 +1204,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]);
@@ -16884,8 +16883,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;
@@ -16946,10 +16946,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";
@@ -16958,6 +16958,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(
     {
@@ -23674,7 +23694,7 @@ function resolveComponentType(node, context, ssr = false) {
       } else {
         exp = isProp.exp;
         if (!exp) {
-          exp = createSimpleExpression(`is`, false, isProp.loc);
+          exp = createSimpleExpression(`is`, false, isProp.arg.loc);
           {
             exp = isProp.exp = processExpression(exp, context);
           }
@@ -24218,7 +24238,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) {
@@ -24262,8 +24281,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`);
@@ -24433,7 +24452,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)
     );
@@ -25410,6 +25429,9 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   helperNameMap: helperNameMap,
   injectProp: injectProp,
   isCoreComponent: isCoreComponent,
+  isFnExpression: isFnExpression,
+  isFnExpressionBrowser: isFnExpressionBrowser,
+  isFnExpressionNode: isFnExpressionNode,
   isFunctionType: isFunctionType,
   isInDestructureAssignment: isInDestructureAssignment,
   isInNewExpression: isInNewExpression,
@@ -43979,6 +44001,20 @@ for (let i = 0; i < chars.length; i++) {
     intToChar[i] = c;
     charToInt[c] = i;
 }
+function encodeInteger(builder, num, relative) {
+    let delta = num - relative;
+    delta = delta < 0 ? (-delta << 1) | 1 : delta << 1;
+    do {
+        let clamped = delta & 0b011111;
+        delta >>>= 5;
+        if (delta > 0)
+            clamped |= 0b100000;
+        builder.write(intToChar[clamped]);
+    } while (delta > 0);
+    return num;
+}
+
+const bufLength = 1024 * 16;
 // Provide a fallback for older environments.
 const td = typeof TextDecoder !== 'undefined'
     ? /* #__PURE__ */ new TextDecoder()
@@ -43998,63 +44034,54 @@ const td = typeof TextDecoder !== 'undefined'
                 return out;
             },
         };
+class StringWriter {
+    constructor() {
+        this.pos = 0;
+        this.out = '';
+        this.buffer = new Uint8Array(bufLength);
+    }
+    write(v) {
+        const { buffer } = this;
+        buffer[this.pos++] = v;
+        if (this.pos === bufLength) {
+            this.out += td.decode(buffer);
+            this.pos = 0;
+        }
+    }
+    flush() {
+        const { buffer, out, pos } = this;
+        return pos > 0 ? out + td.decode(buffer.subarray(0, pos)) : out;
+    }
+}
 function encode(decoded) {
-    const state = new Int32Array(5);
-    const bufLength = 1024 * 16;
-    const subLength = bufLength - 36;
-    const buf = new Uint8Array(bufLength);
-    const sub = buf.subarray(0, subLength);
-    let pos = 0;
-    let out = '';
+    const writer = new StringWriter();
+    let sourcesIndex = 0;
+    let sourceLine = 0;
+    let sourceColumn = 0;
+    let namesIndex = 0;
     for (let i = 0; i < decoded.length; i++) {
         const line = decoded[i];
-        if (i > 0) {
-            if (pos === bufLength) {
-                out += td.decode(buf);
-                pos = 0;
-            }
-            buf[pos++] = semicolon;
-        }
+        if (i > 0)
+            writer.write(semicolon);
         if (line.length === 0)
             continue;
-        state[0] = 0;
+        let genColumn = 0;
         for (let j = 0; j < line.length; j++) {
             const segment = line[j];
-            // We can push up to 5 ints, each int can take at most 7 chars, and we
-            // may push a comma.
-            if (pos > subLength) {
-                out += td.decode(sub);
-                buf.copyWithin(0, subLength, pos);
-                pos -= subLength;
-            }
             if (j > 0)
-                buf[pos++] = comma;
-            pos = encodeInteger(buf, pos, state, segment, 0); // genColumn
+                writer.write(comma);
+            genColumn = encodeInteger(writer, segment[0], genColumn);
             if (segment.length === 1)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 1); // sourcesIndex
-            pos = encodeInteger(buf, pos, state, segment, 2); // sourceLine
-            pos = encodeInteger(buf, pos, state, segment, 3); // sourceColumn
+            sourcesIndex = encodeInteger(writer, segment[1], sourcesIndex);
+            sourceLine = encodeInteger(writer, segment[2], sourceLine);
+            sourceColumn = encodeInteger(writer, segment[3], sourceColumn);
             if (segment.length === 4)
                 continue;
-            pos = encodeInteger(buf, pos, state, segment, 4); // namesIndex
+            namesIndex = encodeInteger(writer, segment[4], namesIndex);
         }
     }
-    return out + td.decode(buf.subarray(0, pos));
-}
-function encodeInteger(buf, pos, state, segment, j) {
-    const next = segment[j];
-    let num = next - state[j];
-    state[j] = next;
-    num = num < 0 ? (-num << 1) | 1 : num << 1;
-    do {
-        let clamped = num & 0b011111;
-        num >>>= 5;
-        if (num > 0)
-            clamped |= 0b100000;
-        buf[pos++] = intToChar[clamped];
-    } while (num > 0);
-    return pos;
+    return writer.flush();
 }
 
 class BitSet {
@@ -44812,8 +44839,10 @@ class MagicString {
 	update(start, end, content, options) {
 		if (typeof content !== 'string') throw new TypeError('replacement content must be a string');
 
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (end > this.original.length) throw new Error('end is out of bounds');
 		if (start === end)
@@ -44909,8 +44938,10 @@ class MagicString {
 	}
 
 	remove(start, end) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (start === end) return this;
 
@@ -44933,8 +44964,10 @@ class MagicString {
 	}
 
 	reset(start, end) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		if (start === end) return this;
 
@@ -44996,8 +45029,10 @@ class MagicString {
 	}
 
 	slice(start = 0, end = this.original.length) {
-		while (start < 0) start += this.original.length;
-		while (end < 0) end += this.original.length;
+		if (this.original.length !== 0) {
+			while (start < 0) start += this.original.length;
+			while (end < 0) end += this.original.length;
+		}
 
 		let result = '';
 
@@ -46732,7 +46767,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"];
@@ -48475,7 +48510,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.4.36";
+const version = "3.4.38";
 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.4.36",
+  "version": "3.4.38",
   "description": "@vue/compiler-sfc",
   "main": "dist/compiler-sfc.cjs.js",
   "module": "dist/compiler-sfc.esm-browser.js",
@@ -47,10 +47,10 @@
     "magic-string": "^0.30.10",
     "postcss": "^8.4.40",
     "source-map-js": "^1.2.0",
-    "@vue/compiler-core": "3.4.36",
-    "@vue/compiler-ssr": "3.4.36",
-    "@vue/compiler-dom": "3.4.36",
-    "@vue/shared": "3.4.36"
+    "@vue/compiler-core": "3.4.38",
+    "@vue/compiler-dom": "3.4.38",
+    "@vue/compiler-ssr": "3.4.38",
+    "@vue/shared": "3.4.38"
   },
   "devDependencies": {
     "@babel/types": "^7.24.7",