@vue/compiler-sfc 3.5.42 → 3.5.44

package/dist/compiler-sfc.cjs.js

@@ -1,5 +1,5 @@
 /**
-* @vue/compiler-sfc v3.5.42
+* @vue/compiler-sfc v3.5.44
 * (c) 2018-present Yuxi (Evan) You and Vue contributors
 * @license MIT
 **/
@@ -157,7 +157,7 @@ function parseCssVars(sfc) {
   const vars = [];
   sfc.styles.forEach((style) => {
     let match;
-    const content = style.content.replace(/\/\*([\s\S]*?)\*\/|\/\/.*/g, "");
+    const content = stripComments$2(style.content);
     while (match = vBindRE.exec(content)) {
       const start = match.index + match[0].length;
       const end = lexBinding(content, start);
@@ -171,6 +171,80 @@ function parseCssVars(sfc) {
   });
   return vars;
 }
+const cssSpecialRE = /[/"'\\(]/g;
+function stripComments$2(content) {
+  const len = content.length;
+  let out = "";
+  let last = 0;
+  let i = 0;
+  cssSpecialRE.lastIndex = 0;
+  while (cssSpecialRE.test(content)) {
+    i = cssSpecialRE.lastIndex - 1;
+    const c = content.charCodeAt(i);
+    if (c === 47) {
+      const next = content.charCodeAt(i + 1);
+      if (next === 42 /* Asterisk */) {
+        out += content.slice(last, i);
+        const end = content.indexOf("*/", i + 2);
+        i = last = end === -1 ? len : end + 2;
+      } else if (next === 47) {
+        out += content.slice(last, i);
+        i += 2;
+        while (i < len && !isNewline(content.charCodeAt(i))) i++;
+        last = i;
+      } else {
+        i++;
+      }
+    } else if (c === 34 || c === 39) {
+      i = skipString(content, i + 1, c);
+    } else if (c === 92 /* Backslash */) {
+      i += 2;
+    } else if (isUrlFunction(content, i)) {
+      i = skipUrl(content, i + 1);
+    } else {
+      i++;
+    }
+    cssSpecialRE.lastIndex = i;
+  }
+  return last === 0 ? content : out + content.slice(last);
+}
+function skipString(s, i, quote) {
+  while (i < s.length) {
+    const c = s.charCodeAt(i);
+    if (c === quote) return i + 1;
+    if (isNewline(c)) return i;
+    if (c === 92 /* Backslash */) {
+      i += s.charCodeAt(i + 1) === 13 && s.charCodeAt(i + 2) === 10 ? 3 : 2;
+    } else {
+      i++;
+    }
+  }
+  return i;
+}
+function isUrlFunction(s, i) {
+  const prev = s.charCodeAt(i - 4);
+  return (s.charCodeAt(i - 3) | 32) === 117 /* LowerU */ && (s.charCodeAt(i - 2) | 32) === 114 /* LowerR */ && (s.charCodeAt(i - 1) | 32) === 108 /* LowerL */ && prev !== 92 /* Backslash */ && !isIdentChar(prev);
+}
+function skipUrl(s, i) {
+  while (isWhitespace(s.charCodeAt(i))) i++;
+  const c = s.charCodeAt(i);
+  if (c === 34 || c === 39) return i;
+  while (i < s.length) {
+    const c2 = s.charCodeAt(i);
+    if (c2 === 41 /* RightParen */) return i + 1;
+    i += c2 === 92 /* Backslash */ ? 2 : 1;
+  }
+  return i;
+}
+function isIdentChar(c) {
+  return c >= 97 && c <= 122 || c >= 65 && c <= 90 || c >= 48 && c <= 57 || c === 45 || c === 95 /* Underscore */ || c >= 128;
+}
+function isNewline(c) {
+  return c === 10 || c === 13;
+}
+function isWhitespace(c) {
+  return c === 32 || c === 9 || c === 12 || isNewline(c);
+}
 function lexBinding(content, start) {
   let state = 0 /* inParens */;
   let parenDepth = 0;
@@ -250,12 +324,7 @@ function genNormalScriptCssVarsCode(cssVars, bindings, id, isProd, defaultVar) {
   return `
 import { ${CSS_VARS_HELPER} as _${CSS_VARS_HELPER} } from 'vue'
 const __injectCSSVars__ = () => {
-${genCssVarsCode(
-    cssVars,
-    bindings,
-    id,
-    isProd
-  )}}
+${genCssVarsCode(cssVars, bindings, id, isProd)}}
 const __setup__ = ${defaultVar}.setup
 ${defaultVar}.setup = __setup__
   ? (props, ctx) => { __injectCSSVars__();return __setup__(props, ctx) }
@@ -7093,8 +7162,9 @@ function requireParser$2 () {
 	    return indexes;
 	}
 	function uniqs() {
-	    var list = Array.prototype.concat.apply([], arguments);
-	    return list.filter(function (item, i) { return i === list.indexOf(item); });
+	    // A Set keeps the first-occurrence order the previous filter/indexOf pass
+	    // produced, without its quadratic cost on long index lists.
+	    return Array.from(new Set(Array.prototype.concat.apply([], arguments)));
 	}
 	var Parser = /** @class */ (function () {
 	    function Parser(rule, options) {
@@ -7139,6 +7209,11 @@ function requireParser$2 () {
 	            attr.push(this.currToken);
 	            this.position++;
 	        }
+	        if (!this.currToken) {
+	            // Ran off the end of the token stream: the attribute was never closed.
+	            // Point at the opening bracket, which is where the author needs to look.
+	            return this.expected("closing square bracket", startingToken[tokenize_1.FIELDS.START_POS]);
+	        }
 	        if (this.currToken[tokenize_1.FIELDS.TYPE] !== tokens.closeSquare) {
 	            return this.expected("closing square bracket", this.currToken[tokenize_1.FIELDS.START_POS]);
 	        }
@@ -7199,7 +7274,7 @@ function requireParser$2 () {
 	                        }
 	                        if (commentBefore) {
 	                            (0, util_1.ensureObject)(node, "raws", "spaces", "attribute");
-	                            node.raws.spaces.attribute.before = spaceBefore;
+	                            node.raws.spaces.attribute.before = commentBefore;
 	                            commentBefore = "";
 	                        }
 	                        node.namespace = (node.namespace || "") + content;
@@ -7623,7 +7698,21 @@ function requireParser$2 () {
 	        return this.error("Unexpected '|'.", this.currToken[tokenize_1.FIELDS.START_POS]);
 	    };
 	    Parser.prototype.namespace = function () {
-	        var before = (this.prevToken && this.content(this.prevToken)) || true;
+	        var prev = this.prevToken;
+	        // Only treat the previous token as a namespace prefix when it can actually
+	        // be one (a type/word or the universal `*`). A comment, comma, combinator
+	        // or whitespace before `|` means an empty namespace, not a prefix.
+	        var before = prev &&
+	            (prev[tokenize_1.FIELDS.TYPE] === tokens.word ||
+	                prev[tokenize_1.FIELDS.TYPE] === tokens.asterisk ||
+	                prev[tokenize_1.FIELDS.TYPE] === tokens.ampersand)
+	            ? this.content(prev)
+	            : true;
+	        if (!this.nextToken) {
+	            // A trailing `|` with nothing after it. `unexpectedPipe` reports against
+	            // `currToken`, which is the pipe itself and always present here.
+	            return this.unexpectedPipe();
+	        }
 	        if (this.nextToken[tokenize_1.FIELDS.TYPE] === tokens.word) {
 	            this.position++;
 	            return this.word(before);
@@ -7653,6 +7742,7 @@ function requireParser$2 () {
 	    Parser.prototype.parentheses = function () {
 	        var last = this.current.last;
 	        var unbalanced = 1;
+	        var openingToken = this.currToken;
 	        this.position++;
 	        if (last && last.type === types.PSEUDO) {
 	            var selector = new selector_1.default({
@@ -7722,7 +7812,9 @@ function requireParser$2 () {
 	            }
 	        }
 	        if (unbalanced) {
-	            return this.expected("closing parenthesis", this.currToken[tokenize_1.FIELDS.START_POS]);
+	            // `currToken` is undefined when the token stream ran out before the
+	            // parenthesis was closed; fall back to the opening one.
+	            return this.expected("closing parenthesis", (this.currToken || openingToken)[tokenize_1.FIELDS.START_POS]);
 	        }
 	    };
 	    Parser.prototype.pseudo = function () {
@@ -7827,8 +7919,14 @@ function requireParser$2 () {
 	        // Eliminate Sass interpolations from the list of id indexes
 	        var interpolations = indexesOf(word, "#{");
 	        if (interpolations.length) {
-	            hasId = hasId.filter(function (hashIndex) { return !~interpolations.indexOf(hashIndex); });
+	            var interpolationIndexes_1 = new Set(interpolations);
+	            hasId = hasId.filter(function (hashIndex) { return !interpolationIndexes_1.has(hashIndex); });
 	        }
+	        // Membership tests are built once. Scanning the arrays per index would make
+	        // a flat selector such as `.a.a.a...` quadratic in its number of class/id
+	        // indexes, which is enough to pin a CPU core on attacker-supplied input.
+	        var classIndexes = new Set(hasClass);
+	        var idIndexes = new Set(hasId);
 	        var indices = (0, sortAscending_1.default)(uniqs(__spreadArray(__spreadArray([0], __read(hasClass), false), __read(hasId), false)));
 	        indices.forEach(function (ind, i) {
 	            var index = indices[i + 1] || word.length;
@@ -7840,7 +7938,7 @@ function requireParser$2 () {
 	            var current = _this.currToken;
 	            var sourceIndex = current[tokenize_1.FIELDS.START_POS] + indices[i];
 	            var source = getSource(current[1], current[2] + ind, current[3], current[2] + (index - 1));
-	            if (~hasClass.indexOf(ind)) {
+	            if (classIndexes.has(ind)) {
 	                var classNameOpts = {
 	                    value: value.slice(1),
 	                    source: source,
@@ -7848,7 +7946,7 @@ function requireParser$2 () {
 	                };
 	                node = new className_1.default(unescapeProp(classNameOpts, "value"));
 	            }
-	            else if (~hasId.indexOf(ind)) {
+	            else if (idIndexes.has(ind)) {
 	                var idOpts = {
 	                    value: value.slice(1),
 	                    source: source,
@@ -23666,6 +23764,7 @@ function resolveExt(filename, fs) {
 }
 const tsConfigCache = createCache();
 const tsConfigRefMap = /* @__PURE__ */ new Map();
+const extendedConfigCache = /* @__PURE__ */ new Map();
 function resolveWithTS(containingFile, source, ts2, fs) {
   var _a, _b;
   const configPath = ts2.findConfigFile(containingFile, fs.fileExists);
@@ -23739,7 +23838,10 @@ function loadTSConfig(configPath, ts2, fs, visited = /* @__PURE__ */ new Set())
     parseConfigHost,
     path$1.dirname(configPath),
     void 0,
-    configPath
+    configPath,
+    void 0,
+    void 0,
+    extendedConfigCache
   );
   const res = [config];
   visited.add(configPath);
@@ -23762,6 +23864,10 @@ function invalidateTypeCache(filename) {
   fileToScopeCache.delete(filename);
   fileToGlobalScopeCache.delete(filename);
   tsConfigCache.delete(filename);
+  if (filename.endsWith(".json")) {
+    extendedConfigCache.clear();
+    tsConfigCache.clear();
+  }
   const affectedConfig = tsConfigRefMap.get(filename);
   if (affectedConfig) tsConfigCache.delete(affectedConfig);
 }
@@ -25003,11 +25109,18 @@ function transformDestructuredProps(ctx, vueImportAliases) {
   const excludedIds = /* @__PURE__ */ new WeakSet();
   const parentStack = [];
   const propsLocalToPublicMap = /* @__PURE__ */ Object.create(null);
+  const modelOptionNodes = /* @__PURE__ */ new Set();
+  let currentModelOption = null;
   for (const key in ctx.propsDestructuredBindings) {
     const { local } = ctx.propsDestructuredBindings[key];
     rootScope[local] = true;
     propsLocalToPublicMap[local] = key;
   }
+  for (const { runtimeOptionNodes } of Object.values(ctx.modelDecls)) {
+    for (const node of runtimeOptionNodes) {
+      modelOptionNodes.add(node);
+    }
+  }
   function pushScope(isFunctionScope = false) {
     const scope = currentScope = Object.create(currentScope);
     scopeStack.push(scope);
@@ -25079,6 +25192,18 @@ function transformDestructuredProps(ctx, vueImportAliases) {
     });
   }
   function rewriteId(id, parent, parentStack2) {
+    if (currentModelOption) {
+      const isDefault = (currentModelOption.type === "ObjectProperty" || currentModelOption.type === "ObjectMethod") && resolveObjectKey(
+        currentModelOption.key,
+        currentModelOption.computed
+      ) === "default";
+      ctx.error(
+        `\`${DEFINE_MODEL}()\` prop options cannot reference destructured props because they are hoisted outside of the setup() function.` + (isDefault ? ` Use the props argument of the default factory instead, e.g. default: props => props${shared.genPropsAccessExp(
+          propsLocalToPublicMap[id.name]
+        ).slice(`__props`.length)}` : ``),
+        id
+      );
+    }
     if (parent.type === "AssignmentExpression" && id === parent.left || parent.type === "UpdateExpression") {
       ctx.error(`Cannot assign to destructured props as they are readonly.`, id);
     }
@@ -25117,6 +25242,9 @@ function transformDestructuredProps(ctx, vueImportAliases) {
       if (parent && parent.type.startsWith("TS") && !CompilerDOM.TS_NODE_TYPES.includes(parent.type)) {
         return this.skip();
       }
+      if (modelOptionNodes.has(node)) {
+        currentModelOption = node;
+      }
       checkUsage(node, "watch", vueImportAliases.watch);
       checkUsage(node, "toRef", vueImportAliases.toRef);
       if (CompilerDOM.isFunctionType(node)) {
@@ -25162,6 +25290,9 @@ function transformDestructuredProps(ctx, vueImportAliases) {
     },
     leave(node, parent) {
       parent && parentStack.pop();
+      if (node === currentModelOption) {
+        currentModelOption = null;
+      }
       if (CompilerDOM.isFunctionType(node)) {
         popScope(true);
       } else if (node.type === "BlockStatement" && !CompilerDOM.isFunctionType(parent)) {
@@ -25714,6 +25845,8 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
           }
           if (child.type === "BlockStatement") {
             scope.push(child.body);
+          } else if (child.type === "SwitchCase") {
+            scope.push(child.consequent);
           }
           if (child.type === "AwaitExpression") {
             hasAwait = true;
@@ -25729,8 +25862,10 @@ const ${normalScriptDefaultVar} = ${defaultSpecifier.local.name}
             );
           }
         },
-        exit(node2) {
-          if (node2.type === "BlockStatement") scope.pop();
+        leave(node2) {
+          if (node2.type === "BlockStatement" || node2.type === "SwitchCase") {
+            scope.pop();
+          }
         }
       });
     }
@@ -26261,7 +26396,7 @@ function mergeSourceMaps(scriptMap, templateMap, templateLineOffset) {
   return generator.toJSON();
 }
 
-const version = "3.5.42";
+const version = "3.5.44";
 const parseCache = parseCache$1;
 const errorMessages = {
   ...CompilerDOM.errorMessages,