@vue/compiler-sfc 3.4.35 → 3.4.37

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.35
+* @vue/compiler-sfc v3.4.37
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -20857,7 +20857,7 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.4.35";
+const version = "3.4.37";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,

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

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.4.35
+* @vue/compiler-sfc v3.4.37
 * (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, node/no-unsupported-features/es-builtins
+// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition, n/no-unsupported-features/es-builtins
 (_a$1 = String.fromCodePoint) !== null && _a$1 !== void 0 ? _a$1 : function (codePoint) {
     let output = "";
-    if (codePoint > 0xffff) {
-        codePoint -= 0x10000;
-        output += String.fromCharCode(((codePoint >>> 10) & 0x3ff) | 0xd800);
-        codePoint = 0xdc00 | (codePoint & 0x3ff);
+    if (codePoint > 65535) {
+        codePoint -= 65536;
+        output += String.fromCharCode(((codePoint >>> 10) & 1023) | 55296);
+        codePoint = 56320 | (codePoint & 1023);
     }
     output += String.fromCharCode(codePoint);
     return output;
@@ -743,8 +743,9 @@ const fromCodePoint =
  */
 function replaceCodePoint(codePoint) {
     var _a;
-    if ((codePoint >= 0xd800 && codePoint <= 0xdfff) || codePoint > 0x10ffff) {
-        return 0xfffd;
+    if ((codePoint >= 55296 && codePoint <= 57343) ||
+        codePoint > 1114111) {
+        return 65533;
     }
     return (_a = decodeMap.get(codePoint)) !== null && _a !== void 0 ? _a : codePoint;
 }
@@ -765,7 +766,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 = 0b100000;
+const TO_LOWER_BIT = 32;
 var BinTrieFlags;
 (function (BinTrieFlags) {
     BinTrieFlags[BinTrieFlags["VALUE_LENGTH"] = 49152] = "VALUE_LENGTH";
@@ -866,32 +867,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 string The string containing the entity (or a continuation of the entity).
+     * @param input 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(str, offset) {
+    write(input, offset) {
         switch (this.state) {
             case EntityDecoderState.EntityStart: {
-                if (str.charCodeAt(offset) === CharCodes.NUM) {
+                if (input.charCodeAt(offset) === CharCodes.NUM) {
                     this.state = EntityDecoderState.NumericStart;
                     this.consumed += 1;
-                    return this.stateNumericStart(str, offset + 1);
+                    return this.stateNumericStart(input, offset + 1);
                 }
                 this.state = EntityDecoderState.NamedEntity;
-                return this.stateNamedEntity(str, offset);
+                return this.stateNamedEntity(input, offset);
             }
             case EntityDecoderState.NumericStart: {
-                return this.stateNumericStart(str, offset);
+                return this.stateNumericStart(input, offset);
             }
             case EntityDecoderState.NumericDecimal: {
-                return this.stateNumericDecimal(str, offset);
+                return this.stateNumericDecimal(input, offset);
             }
             case EntityDecoderState.NumericHex: {
-                return this.stateNumericHex(str, offset);
+                return this.stateNumericHex(input, offset);
             }
             case EntityDecoderState.NamedEntity: {
-                return this.stateNamedEntity(str, offset);
+                return this.stateNamedEntity(input, offset);
             }
         }
     }
@@ -900,28 +901,28 @@ class EntityDecoder {
      *
      * Equivalent to the `Numeric character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input 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(str, offset) {
-        if (offset >= str.length) {
+    stateNumericStart(input, offset) {
+        if (offset >= input.length) {
             return -1;
         }
-        if ((str.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
+        if ((input.charCodeAt(offset) | TO_LOWER_BIT) === CharCodes.LOWER_X) {
             this.state = EntityDecoderState.NumericHex;
             this.consumed += 1;
-            return this.stateNumericHex(str, offset + 1);
+            return this.stateNumericHex(input, offset + 1);
         }
         this.state = EntityDecoderState.NumericDecimal;
-        return this.stateNumericDecimal(str, offset);
+        return this.stateNumericDecimal(input, offset);
     }
-    addToNumericResult(str, start, end, base) {
+    addToNumericResult(input, start, end, base) {
         if (start !== end) {
             const digitCount = end - start;
             this.result =
                 this.result * Math.pow(base, digitCount) +
-                    parseInt(str.substr(start, digitCount), base);
+                    Number.parseInt(input.substr(start, digitCount), base);
             this.consumed += digitCount;
         }
     }
@@ -930,23 +931,23 @@ class EntityDecoder {
      *
      * Equivalent to the `Hexademical character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input 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(str, offset) {
-        const startIdx = offset;
-        while (offset < str.length) {
-            const char = str.charCodeAt(offset);
+    stateNumericHex(input, offset) {
+        const startIndex = offset;
+        while (offset < input.length) {
+            const char = input.charCodeAt(offset);
             if (isNumber$2(char) || isHexadecimalCharacter(char)) {
                 offset += 1;
             }
             else {
-                this.addToNumericResult(str, startIdx, offset, 16);
+                this.addToNumericResult(input, startIndex, offset, 16);
                 return this.emitNumericEntity(char, 3);
             }
         }
-        this.addToNumericResult(str, startIdx, offset, 16);
+        this.addToNumericResult(input, startIndex, offset, 16);
         return -1;
     }
     /**
@@ -954,23 +955,23 @@ class EntityDecoder {
      *
      * Equivalent to the `Decimal character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input 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(str, offset) {
-        const startIdx = offset;
-        while (offset < str.length) {
-            const char = str.charCodeAt(offset);
+    stateNumericDecimal(input, offset) {
+        const startIndex = offset;
+        while (offset < input.length) {
+            const char = input.charCodeAt(offset);
             if (isNumber$2(char)) {
                 offset += 1;
             }
             else {
-                this.addToNumericResult(str, startIdx, offset, 10);
+                this.addToNumericResult(input, startIndex, offset, 10);
                 return this.emitNumericEntity(char, 2);
             }
         }
-        this.addToNumericResult(str, startIdx, offset, 10);
+        this.addToNumericResult(input, startIndex, offset, 10);
         return -1;
     }
     /**
@@ -1014,17 +1015,17 @@ class EntityDecoder {
      *
      * Equivalent to the `Named character reference state` in the HTML spec.
      *
-     * @param str The string containing the entity (or a continuation of the entity).
+     * @param input 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(str, offset) {
+    stateNamedEntity(input, 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 < str.length; offset++, this.excess++) {
-            const char = str.charCodeAt(offset);
+        for (; offset < input.length; offset++, this.excess++) {
+            const char = input.charCodeAt(offset);
             this.treeIndex = determineBranch(decodeTree, current, this.treeIndex + Math.max(1, valueLength), char);
             if (this.treeIndex < 0) {
                 return this.result === 0 ||
@@ -1131,28 +1132,28 @@ class EntityDecoder {
  * @returns A function that decodes entities in a string.
  */
 function getDecoder(decodeTree) {
-    let ret = "";
-    const decoder = new EntityDecoder(decodeTree, (str) => (ret += fromCodePoint(str)));
-    return function decodeWithTrie(str, decodeMode) {
+    let returnValue = "";
+    const decoder = new EntityDecoder(decodeTree, (data) => (returnValue += fromCodePoint(data)));
+    return function decodeWithTrie(input, decodeMode) {
         let lastIndex = 0;
         let offset = 0;
-        while ((offset = str.indexOf("&", offset)) >= 0) {
-            ret += str.slice(lastIndex, offset);
+        while ((offset = input.indexOf("&", offset)) >= 0) {
+            returnValue += input.slice(lastIndex, offset);
             decoder.startEntity(decodeMode);
-            const len = decoder.write(str, 
+            const length = decoder.write(input, 
             // Skip the "&"
             offset + 1);
-            if (len < 0) {
+            if (length < 0) {
                 lastIndex = offset + decoder.end();
                 break;
             }
-            lastIndex = offset + len;
-            // If `len` is 0, skip the current `&` and continue.
-            offset = len === 0 ? lastIndex + 1 : lastIndex;
+            lastIndex = offset + length;
+            // If `length` is 0, skip the current `&` and continue.
+            offset = length === 0 ? lastIndex + 1 : lastIndex;
         }
-        const result = ret + str.slice(lastIndex);
+        const result = returnValue + input.slice(lastIndex);
         // Make sure we don't keep a reference to the final string.
-        ret = "";
+        returnValue = "";
         return result;
     };
 }
@@ -1166,31 +1167,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, nodeIdx, char) {
+function determineBranch(decodeTree, current, nodeIndex, 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 ? nodeIdx : -1;
+        return jumpOffset !== 0 && char === jumpOffset ? nodeIndex : -1;
     }
     // Case 2: Multiple branches encoded in jump table
     if (jumpOffset) {
         const value = char - jumpOffset;
         return value < 0 || value >= branchCount
             ? -1
-            : decodeTree[nodeIdx + value] - 1;
+            : decodeTree[nodeIndex + value] - 1;
     }
     // Case 3: Multiple branches encoded in dictionary
     // Binary search for the character.
-    let lo = nodeIdx;
+    let lo = nodeIndex;
     let hi = lo + branchCount - 1;
     while (lo <= hi) {
         const mid = (lo + hi) >>> 1;
-        const midVal = decodeTree[mid];
-        if (midVal < char) {
+        const midValue = decodeTree[mid];
+        if (midValue < char) {
             lo = mid + 1;
         }
-        else if (midVal > char) {
+        else if (midValue > char) {
             hi = mid - 1;
         }
         else {
@@ -1204,12 +1205,12 @@ getDecoder(xmlDecodeTree);
 /**
  * Decodes an HTML string.
  *
- * @param str The string to decode.
+ * @param htmlString The string to decode.
  * @param mode The decoding mode.
  * @returns The decoded string.
  */
-function decodeHTML(str, mode = DecodingMode.Legacy) {
-    return htmlDecoder(str, mode);
+function decodeHTML(htmlString, mode = DecodingMode.Legacy) {
+    return htmlDecoder(htmlString, mode);
 }
 
 const defaultDelimitersOpen = new Uint8Array([123, 123]);
@@ -16594,6 +16595,16 @@ function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [
             (id) => markScopeIdentifier(node, id, knownIds)
           );
         }
+      } else if (node.type === "CatchClause" && node.param) {
+        for (const id of extractIdentifiers$1(node.param)) {
+          markScopeIdentifier(node, id, knownIds);
+        }
+      } else if (isForStatement(node)) {
+        walkForStatement(
+          node,
+          false,
+          (id) => markScopeIdentifier(node, id, knownIds)
+        );
       }
     },
     leave(node, parent) {
@@ -16674,14 +16685,20 @@ function walkBlockDeclarations(block, onIdent) {
     } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
       if (stmt.declare || !stmt.id) continue;
       onIdent(stmt.id);
-    } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
-      const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
-      if (variable && variable.type === "VariableDeclaration") {
-        for (const decl of variable.declarations) {
-          for (const id of extractIdentifiers$1(decl.id)) {
-            onIdent(id);
-          }
-        }
+    } else if (isForStatement(stmt)) {
+      walkForStatement(stmt, true, onIdent);
+    }
+  }
+}
+function isForStatement(stmt) {
+  return stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement";
+}
+function walkForStatement(stmt, isVar, onIdent) {
+  const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+  if (variable && variable.type === "VariableDeclaration" && (variable.kind === "var" ? isVar : !isVar)) {
+    for (const decl of variable.declarations) {
+      for (const id of extractIdentifiers$1(decl.id)) {
+        onIdent(id);
       }
     }
   }
@@ -23657,7 +23674,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);
           }
@@ -31059,6 +31076,25 @@ const ssrTransformElement = (node, context) => {
               ])
             ];
           }
+        } else if (directives.length && !node.children.length) {
+          const tempId = `_temp${context.temps++}`;
+          propsExp.arguments = [
+            createAssignmentExpression(
+              createSimpleExpression(tempId, false),
+              mergedProps
+            )
+          ];
+          rawChildrenMap.set(
+            node,
+            createConditionalExpression(
+              createSimpleExpression(`"textContent" in ${tempId}`, false),
+              createCallExpression(context.helper(SSR_INTERPOLATE), [
+                createSimpleExpression(`${tempId}.textContent`, false)
+              ]),
+              createSimpleExpression(`${tempId}.innerHTML ?? ''`, false),
+              false
+            )
+          );
         }
         if (needTagForRuntime) {
           propsExp.arguments.push(`"${node.tag}"`);
@@ -31347,7 +31383,7 @@ function ssrProcessTransitionGroup(node, context) {
         context.pushStringPart(` ${scopeId}`);
       }
       context.pushStringPart(`>`);
-      processChildren(node, context, false, true);
+      processChildren(node, context, false, true, true);
       context.pushStringPart(`</${tag.value.content}>`);
     }
   } else {
@@ -48439,7 +48475,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.4.35";
+const version = "3.4.37";
 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.35",
+  "version": "3.4.37",
   "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.35",
-    "@vue/shared": "3.4.35",
-    "@vue/compiler-ssr": "3.4.35",
-    "@vue/compiler-dom": "3.4.35"
+    "@vue/compiler-core": "3.4.37",
+    "@vue/compiler-dom": "3.4.37",
+    "@vue/shared": "3.4.37",
+    "@vue/compiler-ssr": "3.4.37"
   },
   "devDependencies": {
     "@babel/types": "^7.24.7",
@@ -58,7 +58,7 @@
     "hash-sum": "^2.0.0",
     "lru-cache": "10.1.0",
     "merge-source-map": "^1.1.0",
-    "minimatch": "^9.0.5",
+    "minimatch": "~9.0.5",
     "postcss-modules": "^6.0.0",
     "postcss-selector-parser": "^6.1.1",
     "pug": "^3.0.3",