@vue/compiler-sfc 3.5.21 → 3.5.23

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.21
+* @vue/compiler-sfc v3.5.23
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -140,7 +140,7 @@ function genCssVarsFromList(vars, id, isProd, isSSR = false) {
 }
 function genVarName(id, raw, isProd, isSSR = false) {
   if (isProd) {
-    return hash(id + raw);
+    return hash(id + raw).replace(/^\d/, (r) => `v${r}`);
   } else {
     return `${id}-${shared.getEscapedCssVarName(raw, isSSR)}`;
   }
@@ -19591,6 +19591,9 @@ function getImportedName(specifier) {
 function getId(node) {
   return node.type === "Identifier" ? node.name : node.type === "StringLiteral" ? node.value : null;
 }
+function getStringLiteralKey(node) {
+  return node.computed ? node.key.type === "TemplateLiteral" && !node.key.expressions.length ? node.key.quasis.map((q) => q.value.cooked).join("") : null : node.key.type === "Identifier" ? node.key.name : node.key.type === "StringLiteral" ? node.key.value : node.key.type === "NumericLiteral" ? String(node.key.value) : null;
+}
 const identity = (str) => str;
 const fileNameLowerCaseRegExp = /[^\u0130\u0131\u00DFa-z0-9\\/:\-_\. ]+/g;
 const toLowerCase = (str) => str.toLowerCase();
@@ -20336,21 +20339,35 @@ const parseClass = (glob, position) => {
 /**
  * Un-escape a string that has been escaped with {@link escape}.
  *
- * If the {@link windowsPathsNoEscape} option is used, then square-brace
- * escapes are removed, but not backslash escapes.  For example, it will turn
- * the string `'[*]'` into `*`, but it will not turn `'\\*'` into `'*'`,
- * becuase `\` is a path separator in `windowsPathsNoEscape` mode.
+ * If the {@link MinimatchOptions.windowsPathsNoEscape} option is used, then
+ * square-bracket escapes are removed, but not backslash escapes.
+ *
+ * For example, it will turn the string `'[*]'` into `*`, but it will not
+ * turn `'\\*'` into `'*'`, because `\` is a path separator in
+ * `windowsPathsNoEscape` mode.
  *
- * When `windowsPathsNoEscape` is not set, then both brace escapes and
+ * When `windowsPathsNoEscape` is not set, then both square-bracket escapes and
  * backslash escapes are removed.
  *
  * Slashes (and backslashes in `windowsPathsNoEscape` mode) cannot be escaped
  * or unescaped.
+ *
+ * When `magicalBraces` is not set, escapes of braces (`{` and `}`) will not be
+ * unescaped.
  */
-const unescape = (s, { windowsPathsNoEscape = false, } = {}) => {
+const unescape = (s, { windowsPathsNoEscape = false, magicalBraces = true, } = {}) => {
+    if (magicalBraces) {
+        return windowsPathsNoEscape
+            ? s.replace(/\[([^\/\\])\]/g, '$1')
+            : s
+                .replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2')
+                .replace(/\\([^\/])/g, '$1');
+    }
     return windowsPathsNoEscape
-        ? s.replace(/\[([^\/\\])\]/g, '$1')
-        : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, '$1$2').replace(/\\([^\/])/g, '$1');
+        ? s.replace(/\[([^\/\\{}])\]/g, '$1')
+        : s
+            .replace(/((?!\\).|^)\[([^\/\\{}])\]/g, '$1$2')
+            .replace(/\\([^\/{}])/g, '$1');
 };
 
 // parse a single path portion
@@ -20765,7 +20782,9 @@ class AST {
         if (this.#root === this)
             this.#fillNegs();
         if (!this.type) {
-            const noEmpty = this.isStart() && this.isEnd();
+            const noEmpty = this.isStart() &&
+                this.isEnd() &&
+                !this.#parts.some(s => typeof s !== 'string');
             const src = this.#parts
                 .map(p => {
                 const [re, _, hasMagic, uflag] = typeof p === 'string'
@@ -20921,10 +20940,7 @@ class AST {
                 }
             }
             if (c === '*') {
-                if (noEmpty && glob === '*')
-                    re += starNoEmpty;
-                else
-                    re += star$1;
+                re += noEmpty && glob === '*' ? starNoEmpty : star$1;
                 hasMagic = true;
                 continue;
             }
@@ -20942,16 +20958,24 @@ class AST {
 /**
  * Escape all magic characters in a glob pattern.
  *
- * If the {@link windowsPathsNoEscape | GlobOptions.windowsPathsNoEscape}
+ * If the {@link MinimatchOptions.windowsPathsNoEscape}
  * option is used, then characters are escaped by wrapping in `[]`, because
  * a magic character wrapped in a character class can only be satisfied by
  * that exact character.  In this mode, `\` is _not_ escaped, because it is
  * not interpreted as a magic character, but instead as a path separator.
+ *
+ * If the {@link MinimatchOptions.magicalBraces} option is used,
+ * then braces (`{` and `}`) will be escaped.
  */
-const escape = (s, { windowsPathsNoEscape = false, } = {}) => {
+const escape = (s, { windowsPathsNoEscape = false, magicalBraces = false, } = {}) => {
     // don't need to escape +@! because we escape the parens
     // that make those magic, and escaping ! as [!] isn't valid,
     // because [!]] is a valid glob class meaning not ']'.
+    if (magicalBraces) {
+        return windowsPathsNoEscape
+            ? s.replace(/[?*()[\]{}]/g, '[$&]')
+            : s.replace(/[?*()[\]\\{}]/g, '\\$&');
+    }
     return windowsPathsNoEscape
         ? s.replace(/[?*()[\]]/g, '[$&]')
         : s.replace(/[?*()[\]\\]/g, '\\$&');
@@ -21585,7 +21609,7 @@ class Minimatch {
             }
         }
         // resolve and reduce . and .. portions in the file as well.
-        // dont' need to do the second phase, because it's only one string[]
+        // don't need to do the second phase, because it's only one string[]
         const { optimizationLevel = 1 } = this.options;
         if (optimizationLevel >= 2) {
             file = this.levelTwoFileOptimize(file);
@@ -21838,14 +21862,25 @@ class Minimatch {
                     }
                 }
                 else if (next === undefined) {
-                    pp[i - 1] = prev + '(?:\\/|' + twoStar + ')?';
+                    pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + ')?';
                 }
                 else if (next !== GLOBSTAR) {
                     pp[i - 1] = prev + '(?:\\/|\\/' + twoStar + '\\/)' + next;
                     pp[i + 1] = GLOBSTAR;
                 }
             });
-            return pp.filter(p => p !== GLOBSTAR).join('/');
+            const filtered = pp.filter(p => p !== GLOBSTAR);
+            // For partial matches, we need to make the pattern match
+            // any prefix of the full path. We do this by generating
+            // alternative patterns that match progressively longer prefixes.
+            if (this.partial && filtered.length >= 1) {
+                const prefixes = [];
+                for (let i = 1; i <= filtered.length; i++) {
+                    prefixes.push(filtered.slice(0, i).join('/'));
+                }
+                return '(?:' + prefixes.join('|') + ')';
+            }
+            return filtered.join('/');
         })
             .join('|');
         // need to wrap in parens if we had more than one thing with |,
@@ -21854,6 +21889,10 @@ class Minimatch {
         // must match entire pattern
         // ending in a * or ** will make it less strict.
         re = '^' + open + re + close + '$';
+        // In partial mode, '/' should always match as it's a valid prefix for any pattern
+        if (this.partial) {
+            re = '^(?:\\/|' + open + re.slice(1, -1) + close + ')$';
+        }
         // can match anything, as long as it's not this.
         if (this.negate)
             re = '^(?!' + re + ').+$';
@@ -22124,13 +22163,9 @@ function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx), typeParameter
         Object.assign(scope.types, typeParameters);
       }
       e._ownerScope = scope;
-      const name = getId(e.key);
-      if (name && !e.computed) {
+      const name = getStringLiteralKey(e);
+      if (name !== null) {
         res.props[name] = e;
-      } else if (e.key.type === "TemplateLiteral") {
-        for (const key of resolveTemplateKeys(ctx, e.key, scope)) {
-          res.props[key] = e;
-        }
       } else {
         ctx.error(
           `Unsupported computed key in type referenced by a macro`,
@@ -22529,7 +22564,7 @@ function registerTS(_loadTS) {
     } catch (err) {
       if (typeof err.message === "string" && err.message.includes("Cannot find module")) {
         throw new Error(
-          'Failed to load TypeScript, which is required for resolving imported types. Please make sure "typescript" is installed as a project dependency.'
+          'Failed to load TypeScript, which is required for resolving imported types. Please make sure "TypeScript" is installed as a project dependency.'
         );
       } else {
         throw new Error(
@@ -22599,7 +22634,7 @@ function importSourceToScope(ctx, node, scope, source) {
         if (loadTS) ts = loadTS();
         if (!ts) {
           return ctx.error(
-            `Failed to resolve import source ${JSON.stringify(source)}. typescript is required as a peer dep for vue in order to support resolving types from module imports.`,
+            `Failed to resolve import source ${JSON.stringify(source)}. TypeScript is required as a peer dep for vue in order to support resolving types from module imports.`,
             node,
             scope
           );
@@ -23015,6 +23050,9 @@ function recordImport(node, imports) {
   }
 }
 function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx), isKeyOf = false, typeParameters) {
+  if (node.leadingComments && node.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
+    return [UNKNOWN_TYPE];
+  }
   try {
     switch (node.type) {
       case "TSStringKeyword":
@@ -23251,6 +23289,24 @@ function inferRuntimeType(ctx, node, scope = node._ownerScope || ctxToScope(ctx)
           typeParameters
         ).filter((t) => t !== UNKNOWN_TYPE);
       }
+      case "TSMappedType": {
+        const { typeAnnotation, typeParameter } = node;
+        if (typeAnnotation && typeAnnotation.type === "TSIndexedAccessType" && typeParameter && typeParameter.constraint && typeParameters) {
+          const constraint = typeParameter.constraint;
+          if (constraint.type === "TSTypeOperator" && constraint.operator === "keyof" && constraint.typeAnnotation && constraint.typeAnnotation.type === "TSTypeReference" && constraint.typeAnnotation.typeName.type === "Identifier") {
+            const typeName = constraint.typeAnnotation.typeName.name;
+            const index = typeAnnotation.indexType;
+            const obj = typeAnnotation.objectType;
+            if (obj && obj.type === "TSTypeReference" && obj.typeName.type === "Identifier" && obj.typeName.name === typeName && index && index.type === "TSTypeReference" && index.typeName.type === "Identifier" && index.typeName.name === typeParameter.name) {
+              const targetType = typeParameters[typeName];
+              if (targetType) {
+                return inferRuntimeType(ctx, targetType, scope);
+              }
+            }
+          }
+        }
+        return [UNKNOWN_TYPE];
+      }
       case "TSEnumDeclaration":
         return inferEnumType(node);
       case "TSSymbolKeyword":
@@ -23399,7 +23455,7 @@ function ctorToType(ctorType) {
 }
 function findStaticPropertyType(node, key) {
   const prop = node.members.find(
-    (m) => m.type === "TSPropertySignature" && !m.computed && getId(m.key) === key && m.typeAnnotation
+    (m) => m.type === "TSPropertySignature" && getStringLiteralKey(m) === key && m.typeAnnotation
   );
   return prop && prop.typeAnnotation.typeAnnotation;
 }
@@ -24653,6 +24709,7 @@ let __temp${any}, __restore${any}
   }
   let templateMap;
   let returned;
+  const propsDecl = genRuntimeProps(ctx);
   if (!options.inlineTemplate || !sfc.template && ctx.hasDefaultExportRender) {
     const allBindings = {
       ...scriptBindings,
@@ -24759,7 +24816,6 @@ return ${returned}
     runtimeOptions += `
   __ssrInlineRender: true,`;
   }
-  const propsDecl = genRuntimeProps(ctx);
   if (propsDecl) runtimeOptions += `
   props: ${propsDecl},`;
   const emitsDecl = genRuntimeEmits(ctx);
@@ -25027,7 +25083,7 @@ function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
   return generator.toJSON();
 }
 
-const version = "3.5.21";
+const version = "3.5.23";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,