@vue/compiler-sfc 3.5.42 → 3.5.44

package/dist/compiler-sfc.esm-browser.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
 **/
@@ -160,10 +160,10 @@ function normalizeStyle(value) {
 }
 const listDelimiterRE = /;(?![^(]*\))/g;
 const propertyDelimiterRE = /:([^]+)/;
-const styleCommentRE = /\/\*[^]*?\*\//g;
+const styleCommentRE = /"(?:[^"\\]|\\[^])*"|'(?:[^'\\]|\\[^])*'|\\[^]|\/\*[^]*?\*\//g;
 function parseStringStyle(cssText) {
   const ret = {};
-  cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => {
+  cssText.replace(styleCommentRE, (match) => match.startsWith("/*") ? "" : match).split(listDelimiterRE).forEach((item) => {
     if (item) {
       const tmp = item.split(propertyDelimiterRE);
       tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim());
@@ -214,7 +214,7 @@ const isSVGTag = /* @__PURE__ */ makeMap(SVG_TAGS);
 const isMathMLTag = /* @__PURE__ */ makeMap(MATH_TAGS);
 const isVoidTag = /* @__PURE__ */ makeMap(VOID_TAGS);
 
-const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,readonly`;
+const specialBooleanAttrs = `itemscope,allowfullscreen,formnovalidate,ismap,nomodule,novalidate,playsinline,readonly`;
 const isBooleanAttr = /* @__PURE__ */ makeMap(
   specialBooleanAttrs + `,async,autofocus,autoplay,controls,default,defer,disabled,inert,loop,open,required,reversed,scoped,seamless,checked,muted,multiple,selected`
 );
@@ -3347,11 +3347,11 @@ const defaultDelimitersClose = new Uint8Array([125, 125]);
 function isTagStartChar(c) {
   return c >= 97 && c <= 122 || c >= 65 && c <= 90;
 }
-function isWhitespace(c) {
+function isWhitespace$1(c) {
   return c === 32 || c === 10 || c === 9 || c === 12 || c === 13;
 }
 function isEndOfTagSection(c) {
-  return c === 47 || c === 62 || isWhitespace(c);
+  return c === 47 || c === 62 || isWhitespace$1(c);
 }
 function toCharCodes(str) {
   const ret = new Uint8Array(str.length);
@@ -3562,7 +3562,7 @@ class Tokenizer {
   /** Look for an end tag. For <title> and <textarea>, also decode entities. */
   stateInRCDATA(c) {
     if (this.sequenceIndex === this.currentSequence.length) {
-      if (c === 62 || isWhitespace(c)) {
+      if (c === 62 || isWhitespace$1(c)) {
         const endOfText = this.index - this.currentSequence.length;
         if (this.sectionStart < endOfText) {
           const actualIndex = this.index;
@@ -3715,7 +3715,7 @@ class Tokenizer {
     this.stateBeforeAttrName(c);
   }
   stateBeforeClosingTagName(c) {
-    if (isWhitespace(c)) ; else if (c === 62) {
+    if (isWhitespace$1(c)) ; else if (c === 62) {
       {
         this.cbs.onerr(14, this.index);
       }
@@ -3727,7 +3727,7 @@ class Tokenizer {
     }
   }
   stateInClosingTagName(c) {
-    if (c === 62 || isWhitespace(c)) {
+    if (c === 62 || isWhitespace$1(c)) {
       this.cbs.onclosetag(this.sectionStart, this.index);
       this.sectionStart = -1;
       this.state = 10;
@@ -3758,7 +3758,7 @@ class Tokenizer {
       this.cbs.onopentagend(this.index);
       this.state = 5;
       this.sectionStart = this.index;
-    } else if (!isWhitespace(c)) {
+    } else if (!isWhitespace$1(c)) {
       if (c === 61) {
         this.cbs.onerr(
           19,
@@ -3787,7 +3787,7 @@ class Tokenizer {
       this.state = 1;
       this.sectionStart = this.index + 1;
       this.inRCDATA = false;
-    } else if (!isWhitespace(c)) {
+    } else if (!isWhitespace$1(c)) {
       this.state = 11;
       this.stateBeforeAttrName(c);
     }
@@ -3866,7 +3866,7 @@ class Tokenizer {
       this.sectionStart = -1;
       this.state = 11;
       this.stateBeforeAttrName(c);
-    } else if (!isWhitespace(c)) {
+    } else if (!isWhitespace$1(c)) {
       this.cbs.onattribend(0, this.sectionStart);
       this.handleAttrStart(c);
     }
@@ -3878,7 +3878,7 @@ class Tokenizer {
     } else if (c === 39) {
       this.state = 20;
       this.sectionStart = this.index + 1;
-    } else if (!isWhitespace(c)) {
+    } else if (!isWhitespace$1(c)) {
       this.sectionStart = this.index;
       this.state = 21;
       this.stateInAttrValueNoQuotes(c);
@@ -3904,7 +3904,7 @@ class Tokenizer {
     this.handleInAttrValue(c, 39);
   }
   stateInAttrValueNoQuotes(c) {
-    if (isWhitespace(c) || c === 62) {
+    if (isWhitespace$1(c) || c === 62) {
       this.cbs.onattribdata(this.sectionStart, this.index);
       this.sectionStart = -1;
       this.cbs.onattribend(1, this.index);
@@ -4474,7 +4474,8 @@ const errorMessages$1 = {
   [42]: `v-model value must be a valid JavaScript member expression.`,
   [43]: `v-model cannot be used on v-for or v-slot scope variables because they are not writable.`,
   [44]: `v-model cannot be used on a prop, because local prop bindings are not writable.
-Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
+Use a v-bind binding combined with a v-on listener that emits update:x event instead.
+For props declared with defineModel(), assign the returned ref to a variable and use v-model on that variable.`,
   [45]: `v-model cannot be used on a const binding because it is not writable.`,
   [46]: `Error parsing JavaScript expression: `,
   [47]: `<KeepAlive> expects exactly one child component.`,
@@ -7578,13 +7579,15 @@ function requireLib () {
 	    const arrows = [];
 	    while (stack.length !== 0) {
 	      const node = stack.pop();
-	      if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+	      if (node.type === "ArrowFunctionExpression") {
 	        if (node.typeParameters || !node.returnType) {
 	          this.finishArrowValidation(node);
 	        } else {
 	          arrows.push(node);
 	        }
-	        stack.push(node.body);
+	        if (node.body.type !== "BlockStatement") {
+	          stack.push(node.body);
+	        }
 	      } else if (node.type === "ConditionalExpression") {
 	        stack.push(node.consequent);
 	        stack.push(node.alternate);
@@ -14754,8 +14757,11 @@ function requireLib () {
 	    }
 	  }
 	  fillOptionalPropertiesForTSESLint(node) {
-	    var _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out;
+	    var _node$phase, _node$directive, _node$decorators, _node$optional, _node$typeAnnotation, _node$accessibility, _node$decorators2, _node$override, _node$readonly, _node$static, _node$declare, _node$returnType, _node$typeParameters, _node$optional2, _node$optional3, _node$accessibility2, _node$readonly2, _node$static2, _node$declare2, _node$definite, _node$readonly3, _node$typeAnnotation2, _node$accessibility3, _node$decorators3, _node$override2, _node$optional4, _node$id, _node$abstract, _node$declare3, _node$decorators4, _node$implements, _node$superTypeArgume, _node$typeParameters2, _node$declare4, _node$definite2, _node$const, _node$declare5, _node$computed, _node$qualifier, _node$options, _node$declare6, _node$extends, _node$optional5, _node$readonly4, _node$declare7, _node$global, _node$const2, _node$in, _node$out;
 	    switch (node.type) {
+	      case "ImportDeclaration":
+	        (_node$phase = node.phase) != null ? _node$phase : node.phase = null;
+	        return;
 	      case "ExpressionStatement":
 	        (_node$directive = node.directive) != null ? _node$directive : node.directive = undefined;
 	        return;
@@ -20089,7 +20095,7 @@ function getMemoedVNodeCall(node) {
 const forAliasRE = /([\s\S]*?)\s+(?:in|of)\s+(\S[\s\S]*)/;
 function isAllWhitespace(str) {
   for (let i = 0; i < str.length; i++) {
-    if (!isWhitespace(str.charCodeAt(i))) {
+    if (!isWhitespace$1(str.charCodeAt(i))) {
       return false;
     }
   }
@@ -20142,10 +20148,10 @@ const tokenizer = new Tokenizer(stack, {
     }
     let innerStart = start + tokenizer.delimiterOpen.length;
     let innerEnd = end - tokenizer.delimiterClose.length;
-    while (isWhitespace(currentInput.charCodeAt(innerStart))) {
+    while (isWhitespace$1(currentInput.charCodeAt(innerStart))) {
       innerStart++;
     }
-    while (isWhitespace(currentInput.charCodeAt(innerEnd - 1))) {
+    while (isWhitespace$1(currentInput.charCodeAt(innerEnd - 1))) {
       innerEnd--;
     }
     let exp = getSlice(innerStart, innerEnd);
@@ -20650,7 +20656,7 @@ function condense(str) {
   let ret = "";
   let prevCharIsWhitespace = false;
   for (let i = 0; i < str.length; i++) {
-    if (isWhitespace(str.charCodeAt(i))) {
+    if (isWhitespace$1(str.charCodeAt(i))) {
       if (!prevCharIsWhitespace) {
         ret += " ";
         prevCharIsWhitespace = true;
@@ -22808,10 +22814,12 @@ function requireSourceMapGenerator$1 () {
 
 	      if (mapping.generatedLine !== previousGeneratedLine) {
 	        previousGeneratedColumn = 0;
-	        while (mapping.generatedLine !== previousGeneratedLine) {
-	          next += ';';
-	          previousGeneratedLine++;
-	        }
+	        // One ';' per skipped line. Build large gaps with a single flat
+	        // string: appending ';' one by one creates a rope node per line, which
+	        // can exhaust the heap for a big gap (CVE-2026-93749).
+	        var lineDelta = mapping.generatedLine - previousGeneratedLine;
+	        next += lineDelta === 1 ? ';' : ';'.repeat(lineDelta);
+	        previousGeneratedLine = mapping.generatedLine;
 	      }
 	      else {
 	        if (i > 0) {
@@ -23153,6 +23161,15 @@ function requireQuickSort$1 () {
 	  return templateFn(comparator);
 	}
 
+	let isEvalAllowed = (function () {
+	  try {
+	    new Function('return 0')();
+	    return true;
+	  } catch {
+	    return false;
+	  }
+	})();
+
 	/**
 	 * Sort the given array in-place with the given comparator function.
 	 *
@@ -23164,7 +23181,7 @@ function requireQuickSort$1 () {
 
 	let sortCache = new WeakMap();
 	quickSort$1.quickSort = function (ary, comparator, start = 0) {
-	  let doQuickSort = sortCache.get(comparator);
+	  let doQuickSort = isEvalAllowed ? sortCache.get(comparator) : SortTemplate();
 	  if (doQuickSort === void 0) {
 	    doQuickSort = cloneSort(comparator);
 	    sortCache.set(comparator, doQuickSort);
@@ -23193,6 +23210,14 @@ function requireSourceMapConsumer$1 () {
 	var base64VLQ = /*@__PURE__*/ requireBase64Vlq$1();
 	var quickSort = /*@__PURE__*/ requireQuickSort$1().quickSort;
 
+	// Upper bound for a section's `offset.line` in an indexed source map. A flat
+	// map spends one ';' per generated line, so a tiny indexed map with a huge
+	// offset.line turns into a huge amount of work and memory once its mappings
+	// are copied into a SourceMapGenerator (CVE-2026-93749). Ten million lines is
+	// far beyond any real generated file. Columns are VLQ-encoded as deltas and
+	// don't amplify, so they only need to be valid integers.
+	var MAX_SECTION_OFFSET_LINE = 1e7;
+
 	function SourceMapConsumer(aSourceMap, aSourceMapURL) {
 	  var sourceMap = aSourceMap;
 	  if (typeof aSourceMap === 'string') {
@@ -24116,6 +24141,7 @@ function requireSourceMapConsumer$1 () {
 	    line: -1,
 	    column: 0
 	  };
+	  var maxOffsetLine = 0;
 	  this._sections = sections.map(function (s) {
 	    if (s.url) {
 	      // The url field will require support for asynchronicity.
@@ -24126,12 +24152,32 @@ function requireSourceMapConsumer$1 () {
 	    var offsetLine = util.getArg(offset, 'line');
 	    var offsetColumn = util.getArg(offset, 'column');
 
+	    if (!isValidOffset(offsetLine) || !isValidOffset(offsetColumn)) {
+	      throw new Error('Section offset line and column must be non-negative integers.');
+	    }
+	    if (offsetLine > MAX_SECTION_OFFSET_LINE) {
+	      throw new Error('Section offset line must not exceed ' + MAX_SECTION_OFFSET_LINE + '.');
+	    }
+
 	    if (offsetLine < lastOffset.line ||
 	        (offsetLine === lastOffset.line && offsetColumn < lastOffset.column)) {
 	      throw new Error('Section offsets must be ordered and non-overlapping.');
 	    }
 	    lastOffset = offset;
 
+	    var consumer = new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL);
+
+	    // Offsets of a nested indexed map add up with this one, so apply the
+	    // bound to the total.
+	    var totalOffsetLine = offsetLine + (consumer._maxOffsetLine || 0);
+	    if (totalOffsetLine > MAX_SECTION_OFFSET_LINE) {
+	      throw new Error('Section offset line must not exceed ' + MAX_SECTION_OFFSET_LINE +
+	                      ', including offsets of nested sections.');
+	    }
+	    if (totalOffsetLine > maxOffsetLine) {
+	      maxOffsetLine = totalOffsetLine;
+	    }
+
 	    return {
 	      generatedOffset: {
 	        // The offset fields are 0-based, but we use 1-based indices when
@@ -24139,9 +24185,24 @@ function requireSourceMapConsumer$1 () {
 	        generatedLine: offsetLine + 1,
 	        generatedColumn: offsetColumn + 1
 	      },
-	      consumer: new SourceMapConsumer(util.getArg(s, 'map'), aSourceMapURL)
+	      consumer: consumer
 	    }
 	  });
+
+	  // The largest offset.line of any section, including nested sections.
+	  this._maxOffsetLine = maxOffsetLine;
+	}
+
+	/**
+	 * Section offsets come from untrusted input and are used as line/column
+	 * numbers, so only accept non-negative safe integers (rejects NaN, Infinity,
+	 * strings, fractions, etc).
+	 */
+	function isValidOffset(aValue) {
+	  return typeof aValue === 'number' &&
+	    aValue >= 0 &&
+	    aValue <= 9007199254740991 && // Number.MAX_SAFE_INTEGER
+	    Math.floor(aValue) === aValue;
 	}
 
 	IndexedSourceMapConsumer.prototype = Object.create(SourceMapConsumer.prototype);
@@ -24159,8 +24220,12 @@ function requireSourceMapConsumer$1 () {
 	  get: function () {
 	    var sources = [];
 	    for (var i = 0; i < this._sections.length; i++) {
-	      for (var j = 0; j < this._sections[i].consumer.sources.length; j++) {
-	        sources.push(this._sections[i].consumer.sources[j]);
+	      // Read the getter once per section: for a nested indexed map it is
+	      // itself this getter, and re-reading it per item is exponential in the
+	      // nesting depth (CVE-2026-93749).
+	      var sectionSources = this._sections[i].consumer.sources;
+	      for (var j = 0; j < sectionSources.length; j++) {
+	        sources.push(sectionSources[j]);
 	      }
 	    }
 	    return sources;
@@ -24493,6 +24558,13 @@ function requireSourceNode$1 () {
 	      // to the SourceNode without any mapping.
 	      // Each line is added as separate string.
 	      while (lastGeneratedLine < mapping.generatedLine) {
+	        if (remainingLinesIndex >= remainingLines.length) {
+	          // The generated code is exhausted. Skip the rest instead of adding
+	          // empty lines one by one: a mapping may point far past the end of
+	          // the code (e.g. an indexed map section with a huge offset.line).
+	          lastGeneratedLine = mapping.generatedLine;
+	          break;
+	        }
 	        node.add(shiftNextLine());
 	        lastGeneratedLine++;
 	      }
@@ -26151,7 +26223,7 @@ const transformFor = createStructuralDirectiveTransform(
             createCompoundExpression([`const _memo = (`, memo.exp, `)`]),
             createCompoundExpression([
               `if (_cached && _cached.el`,
-              ...keyExp ? [` && _cached.key === `, keyExp] : [],
+              ...keyExp ? [` && _cached.key === (`, keyExp, `)`] : [],
               ` && ${context.helperString(
                 IS_MEMO_SAME
               )}(_cached, _memo)) return _cached`
@@ -28093,7 +28165,8 @@ const transformTransition = (node, context) => {
         if (!node.children.length) {
           return;
         }
-        if (hasMultipleChildren(node)) {
+        const multipleChildren = hasMultipleChildren(node);
+        if (multipleChildren) {
           context.onError(
             createDOMCompilerError(
               63,
@@ -28288,8 +28361,9 @@ function stringifyNode(node, context) {
   }
 }
 function stringifyElement(node, context) {
+  var _a;
   let res = `<${node.tag}`;
-  let innerHTML = "";
+  let innerHTML = void 0;
   for (let i = 0; i < node.props.length; i++) {
     const p = node.props[i];
     if (p.type === 6) {
@@ -28323,7 +28397,7 @@ function stringifyElement(node, context) {
           )}"`;
         }
       } else if (p.name === "html") {
-        innerHTML = evaluateConstant(p.exp);
+        innerHTML = (_a = evaluateConstant(p.exp)) != null ? _a : "";
       } else if (p.name === "text") {
         innerHTML = escapeHtml(
           toDisplayString(evaluateConstant(p.exp))
@@ -28335,7 +28409,7 @@ function stringifyElement(node, context) {
     res += ` ${context.scopeId}`;
   }
   res += `>`;
-  if (innerHTML) {
+  if (innerHTML !== void 0) {
     res += innerHTML;
   } else {
     for (let i = 0; i < node.children.length; i++) {
@@ -28557,7 +28631,8 @@ const validateHtmlNesting = (node, context) => {
 
 const DOMNodeTransforms = [
   transformStyle,
-  ...[transformTransition, validateHtmlNesting] 
+  transformTransition,
+  ...[validateHtmlNesting] 
 ];
 const DOMDirectiveTransforms = {
   cloak: noopDirectiveTransform,
@@ -28876,7 +28951,7 @@ function parseCssVars(sfc) {
   const vars = [];
   sfc.styles.forEach((style) => {
     let match;
-    const content = style.content.replace(/\/\*([\s\S]*?)\*\/|\/\/.*/g, "");
+    const content = stripComments$1(style.content);
     while (match = vBindRE.exec(content)) {
       const start = match.index + match[0].length;
       const end = lexBinding(content, start);
@@ -28890,6 +28965,80 @@ function parseCssVars(sfc) {
   });
   return vars;
 }
+const cssSpecialRE = /[/"'\\(]/g;
+function stripComments$1(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;
@@ -28969,12 +29118,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) }
@@ -34393,22 +34537,10 @@ function requireStringifier () {
 	if (hasRequiredStringifier) return stringifier;
 	hasRequiredStringifier = 1;
 
-	// Escapes sequences that could break out of an HTML <style> context.
-	// Uses CSS unicode escaping (\3c = '<') which is valid CSS and parsed
-	// correctly by all compliant CSS consumers.
-	const STYLE_TAG = /(<)(\/?style\b)/gi;
-	const COMMENT_OPEN = /(<)(!--)/g;
-
 	// Characters that end an at-rule name, mirroring RE_AT_END in the tokenizer.
 	// Params starting with anything else need a space to stay separate tokens.
 	const AT_NAME_END = /[\t\n\f\r "#'()/;[\\\]{}]/;
 
-	function escapeHTMLInCSS(str) {
-	  if (typeof str !== 'string') return str
-	  if (!str.includes('<')) return str
-	  return str.replace(STYLE_TAG, '\\3c $2').replace(COMMENT_OPEN, '\\3c $2')
-	}
-
 	const DEFAULT_RAW = {
 	  after: '\n',
 	  beforeClose: '\n',
@@ -34442,6 +34574,15 @@ function requireStringifier () {
 	  return name + afterName + params
 	}
 
+	// `*--x` is not a custom property: the parser checks the first token, and the
+	// `*`/`_` hack prefix moves from `prop` into `before` only after that. A free
+	// semicolon in front of the declaration also ends up in `before`.
+	function isCustomProperty(node) {
+	  if (!node.prop.startsWith('--')) return false
+	  let before = node.raws.before;
+	  return typeof before === 'undefined' || !/[^\s;]$/.test(before)
+	}
+
 	function pushBody(str, stack, node) {
 	  let nodes = node.nodes;
 	  let last = nodes.length - 1;
@@ -34463,7 +34604,7 @@ function requireStringifier () {
 	      !childSemicolon &&
 	      i < nodes.length - 1 &&
 	      ((child.type === 'atrule' && !child.nodes) ||
-	        (child.type === 'decl' && child.prop.startsWith('--')))
+	        (child.type === 'decl' && isCustomProperty(child)))
 	    ) {
 	      childSemicolon = true;
 	    }
@@ -34477,17 +34618,17 @@ function requireStringifier () {
 
 	function pushBlock(str, stack, node, start) {
 	  let between = str.raw(node, 'between', 'beforeOpen');
-	  str.builder(escapeHTMLInCSS(start + between) + '{', node, 'start');
+	  str.builder(start + between + '{', node, 'start');
 
 	  let hasNodes = node.nodes && node.nodes.length;
 	  let close = () => {
 	    let after = hasNodes
 	      ? str.raw(node, 'after')
 	      : str.raw(node, 'after', 'emptyBody');
-	    if (after) str.builder(escapeHTMLInCSS(after));
+	    if (after) str.builder(after);
 	    str.builder('}', node, 'end');
 	    if (node.type === 'rule' && node.raws.ownSemicolon) {
-	      str.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end');
+	      str.builder(node.raws.ownSemicolon, node, 'end');
 	    }
 	  };
 
@@ -34510,7 +34651,7 @@ function requireStringifier () {
 	      this.block(node, start);
 	    } else {
 	      let end = (node.raws.between || '') + (semicolon ? ';' : '');
-	      this.builder(escapeHTMLInCSS(start + end), node);
+	      this.builder(start + end, node);
 	    }
 	  }
 
@@ -34545,7 +34686,7 @@ function requireStringifier () {
 
 	  block(node, start) {
 	    let between = this.raw(node, 'between', 'beforeOpen');
-	    this.builder(escapeHTMLInCSS(start + between) + '{', node, 'start');
+	    this.builder(start + between + '{', node, 'start');
 
 	    let after;
 	    if (node.nodes && node.nodes.length) {
@@ -34555,7 +34696,7 @@ function requireStringifier () {
 	      after = this.raw(node, 'after', 'emptyBody');
 	    }
 
-	    if (after) this.builder(escapeHTMLInCSS(after));
+	    if (after) this.builder(after);
 	    this.builder('}', node, 'end');
 	  }
 
@@ -34582,7 +34723,7 @@ function requireStringifier () {
 	      let child = entry.node;
 	      let before = this.raw(child, 'before');
 	      if (before) {
-	        this.builder(entry.document ? before : escapeHTMLInCSS(before));
+	        this.builder(before);
 	      }
 
 	      if (expandable && child.type === 'rule') {
@@ -34598,7 +34739,7 @@ function requireStringifier () {
 	  comment(node) {
 	    let left = this.raw(node, 'left', 'commentLeft');
 	    let right = this.raw(node, 'right', 'commentRight');
-	    this.builder(escapeHTMLInCSS('/*' + left + node.text + right + '*/'), node);
+	    this.builder('/*' + left + node.text + right + '*/', node);
 	  }
 
 	  decl(node, semicolon) {
@@ -34612,7 +34753,7 @@ function requireStringifier () {
 	    }
 
 	    if (semicolon) string += ';';
-	    this.builder(escapeHTMLInCSS(string), node);
+	    this.builder(string, node);
 	  }
 
 	  document(node) {
@@ -34817,18 +34958,20 @@ function requireStringifier () {
 	  }
 
 	  root(node) {
+	    let inDocument = node.parent && node.parent.type === 'document';
+	    if (!inDocument && node.source && node.source.input.hasBOM) {
+	      this.builder('\uFEFF', node, 'start');
+	    }
 	    this.body(node);
 	    if (node.raws.after) {
-	      let after = node.raws.after;
-	      let isDocument = node.parent && node.parent.type === 'document';
-	      this.builder(isDocument ? after : escapeHTMLInCSS(after));
+	      this.builder(node.raws.after);
 	    }
 	  }
 
 	  rule(node) {
 	    this.block(node, this.rawValue(node, 'selector'));
 	    if (node.raws.ownSemicolon) {
-	      this.builder(escapeHTMLInCSS(node.raws.ownSemicolon), node, 'end');
+	      this.builder(node.raws.ownSemicolon, node, 'end');
 	    }
 	  }
 
@@ -34861,9 +35004,67 @@ function requireStringify () {
 
 	let Stringifier = /*@__PURE__*/ requireStringifier();
 
+	const STYLE_TAG = /(<)(\/?style\b)/gi;
+	const COMMENT_OPEN = /(<)(!--)/g;
+
+	function escapeHTMLInCSS(str) {
+	  if (!str.includes('<')) return str
+	  return str.replace(STYLE_TAG, '\\3c $2').replace(COMMENT_OPEN, '\\3c $2')
+	}
+
+	class SafeStringifier extends Stringifier {
+	  escapeHTML(node, print) {
+	    let builder = this.builder;
+	    let chunks, css;
+	    this.builder = (str, child, type) => {
+	      if (chunks) {
+	        css += str;
+	        chunks.push(str, child, type);
+	      } else if (str.includes('<')) {
+	        // Dangerous sequences start with `<`, so everything before
+	        // the first `<` is safe to pass through. The rest is buffered
+	        // to escape it as a whole.
+	        css = str;
+	        chunks = [str, child, type];
+	      } else {
+	        builder(str, child, type);
+	      }
+	    };
+	    print();
+	    this.builder = builder;
+	    if (!chunks) return
+
+	    let escaped = escapeHTMLInCSS(css);
+	    if (escaped === css) {
+	      // Keep the chunks to get a precise source map
+	      for (let i = 0; i < chunks.length; i += 3) {
+	        builder(chunks[i], chunks[i + 1], chunks[i + 2]);
+	      }
+	    } else {
+	      // Escaping happens only on a hack attempt, source map is not important
+	      builder(escaped, node);
+	    }
+	  }
+
+	  root(node) {
+	    if (node.parent && node.parent.type === 'document') {
+	      // Document raws around the Root hold markup and are kept as is since CSS in Document can be marked with <style>
+	      this.escapeHTML(node, () => this.body(node));
+	      if (node.raws.after) this.builder(node.raws.after);
+	    } else {
+	      this.escapeHTML(node, () => super.root(node));
+	    }
+	  }
+	}
+
 	function stringify(node, builder) {
-	  let str = new Stringifier(builder);
-	  str.stringify(node);
+	  let str = new SafeStringifier(builder);
+	  // Root escapes its own output and keeps markup in Document raws
+	  if (node.type === 'root' || node.type === 'document') {
+	    str.stringify(node);
+	  } else {
+	    str.escapeHTML(node, () => str.stringify(node));
+	  }
 	}
 
 	stringify_1 = stringify;
@@ -36058,10 +36259,20 @@ function requirePreviousMap () {
 	if (hasRequiredPreviousMap) return previousMap;
 	hasRequiredPreviousMap = 1;
 
-	let { existsSync, readFileSync } = require$$0$1;
+	let { existsSync, readFileSync, realpathSync } = require$$0$1;
 	let { dirname, isAbsolute, join, relative, sep } = require$$1;
 	let { SourceMapConsumer, SourceMapGenerator } = /*@__PURE__*/ requireSourceMap$1();
 
+	function realPath(path) {
+	  try {
+	    return realpathSync(path)
+	  } catch {
+	    // Missing or dangling: keep the literal path. The existsSync() check below
+	    // still gates the read, and a path that does not exist cannot escape.
+	    return path
+	  }
+	}
+
 	function fromBase64(str) {
 	  if (Buffer$1) {
 	    return Buffer$1.from(str, 'base64').toString()
@@ -36147,7 +36358,9 @@ function requirePreviousMap () {
 	      if (!/\.map$/i.test(path)) return undefined
 	      if (!cssFile) return undefined
 
-	      let rel = relative(dirname(cssFile), path);
+	      // Compare *resolved* paths: relative() is textual, so without this a
+	      // symlink at or below the CSS file's directory points the map outside it.
+	      let rel = relative(realPath(dirname(cssFile)), realPath(path));
 	      if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) {
 	        return undefined
 	      }
@@ -36615,6 +36828,7 @@ function requireList () {
 	  },
 
 	  split(string, separators, last) {
+	    if (typeof string !== 'string') return []
 	    let array = [];
 	    let current = '';
 	    let split = false;
@@ -36623,8 +36837,21 @@ function requireList () {
 	    let inQuote = false;
 	    let prevQuote = '';
 	    let escape = false;
+	    let inComment = false;
+
+	    for (let i = 0; i < string.length; i++) {
+	      let letter = string[i];
+
+	      if (inComment) {
+	        current += letter;
+	        if (letter === '*' && string[i + 1] === '/') {
+	          current += '/';
+	          i += 1;
+	          inComment = false;
+	        }
+	        continue
+	      }
 
-	    for (let letter of string) {
 	      if (escape) {
 	        escape = false;
 	      } else if (letter === '\\') {
@@ -36636,6 +36863,11 @@ function requireList () {
 	      } else if (letter === '"' || letter === "'") {
 	        inQuote = true;
 	        prevQuote = letter;
+	      } else if (letter === '/' && string[i + 1] === '*') {
+	        current += '/*';
+	        i += 1;
+	        inComment = true;
+	        continue
 	      } else if (letter === '(') {
 	        func += 1;
 	      } else if (letter === ')') {
@@ -36645,7 +36877,8 @@ function requireList () {
 	      }
 
 	      if (split) {
-	        if (current !== '') array.push(current.trim());
+	        let value = current.trim();
+	        if (last || value !== '') array.push(value);
 	        current = '';
 	        split = false;
 	      } else {
@@ -36653,7 +36886,8 @@ function requireList () {
 	      }
 	    }
 
-	    if (last || current !== '') array.push(current.trim());
+	    let value = current.trim();
+	    if (last || value !== '') array.push(value);
 	    return array
 	  }
 	};
@@ -36895,15 +37129,22 @@ function requireMapGenerator () {
 	        }
 	      }
 	    } else if (this.css) {
+	      // Single forward pass. Removing every annotation from the whole
+	      // string separately would be O(n^2) on many annotations.
+	      let annotation = '/*# sourceMappingURL=';
+	      let css = '';
+	      let cursor = 0;
 	      let startIndex;
-	      while ((startIndex = this.css.lastIndexOf('/*#')) !== -1) {
-	        let endIndex = this.css.indexOf('*/', startIndex + 3);
+	      while ((startIndex = this.css.indexOf(annotation, cursor)) !== -1) {
+	        let endIndex = this.css.indexOf('*/', startIndex + annotation.length);
 	        if (endIndex === -1) break
-	        while (startIndex > 0 && this.css[startIndex - 1] === '\n') {
+	        while (startIndex > cursor && this.css[startIndex - 1] === '\n') {
 	          startIndex--;
 	        }
-	        this.css = this.css.slice(0, startIndex) + this.css.slice(endIndex + 2);
+	        css += this.css.slice(cursor, startIndex);
+	        cursor = endIndex + 2;
 	      }
+	      if (cursor > 0) this.css = css + this.css.slice(cursor);
 	    }
 	  }
 
@@ -37558,8 +37799,11 @@ function requireParser$1 () {
 	      if (prev && prev.type === 'rule' && !prev.raws.ownSemicolon) {
 	        prev.raws.ownSemicolon = this.spaces;
 	        this.spaces = '';
+	        // `ownSemicolon` also holds the spaces before the semicolon, but
+	        // the position above is the semicolon itself, so the node ends
+	        // right after it.
 	        prev.source.end = this.getPosition(token[2]);
-	        prev.source.end.offset += prev.raws.ownSemicolon.length;
+	        prev.source.end.offset++;
 	      }
 	    }
 	  }
@@ -37695,6 +37939,9 @@ function requireParser$1 () {
 	    let token, type;
 	    let length = tokens.length;
 	    let value = '';
+	    // Last character of `value`. Reading it from `value` would flatten
+	    // the string concatenation on every comment and make parsing O(n^2).
+	    let last = '';
 	    let clean = true;
 	    let next, prev;
 
@@ -37707,16 +37954,18 @@ function requireParser$1 () {
 	        prev = tokens[i - 1] ? tokens[i - 1][0] : 'empty';
 	        next = tokens[i + 1] ? tokens[i + 1][0] : 'empty';
 	        if (!SAFE_COMMENT_NEIGHBOR[prev] && !SAFE_COMMENT_NEIGHBOR[next]) {
-	          if (value.slice(-1) === ',') {
+	          if (last === ',') {
 	            clean = false;
 	          } else {
 	            value += token[1];
+	            last = token[1].slice(-1);
 	          }
 	        } else {
 	          clean = false;
 	        }
 	      } else {
 	        value += token[1];
+	        last = token[1].slice(-1);
 	      }
 	    }
 	    if (!clean) {
@@ -38510,14 +38759,24 @@ function requireLazyResult () {
 
 	    if (visit.iterator !== 0) {
 	      let iterator = visit.iterator;
+	      // Advance past the child we just finished visiting. Like
+	      // `Container#each`, the index is incremented only after a child has
+	      // been fully processed, so a node inserted right after the current
+	      // child is not skipped by the `existIndex < index` adjustment in
+	      // `Container#insertAfter()` (which would fire exit events too early).
+	      if (visit.descending) {
+	        visit.descending = false;
+	        node.indexes[iterator] += 1;
+	      }
 	      let child;
 	      while ((child = node.nodes[node.indexes[iterator]])) {
-	        node.indexes[iterator] += 1;
 	        if (!child[isClean]) {
 	          child[isClean] = true;
+	          visit.descending = true;
 	          stack.push(toStack(child));
 	          return
 	        }
+	        node.indexes[iterator] += 1;
 	      }
 	      visit.iterator = 0;
 	      delete node.indexes[iterator];
@@ -38555,12 +38814,22 @@ function requireLazyResult () {
 
 	      if (visit.iterator !== 0) {
 	        let iterator = visit.iterator;
+	        // Advance past the child we just finished visiting. Like
+	        // `Container#each`, the index is incremented only after a child has
+	        // been fully processed. Incrementing before (as this loop used to)
+	        // makes a node inserted right after the current child get skipped by
+	        // the `existIndex < index` adjustment in `Container#insertAfter()`,
+	        // which fires exit events before those new siblings are visited.
+	        if (visit.descending) {
+	          visit.descending = false;
+	          visitNode.indexes[iterator] += 1;
+	        }
 	        let child;
 	        let descended = false;
 	        while ((child = visitNode.nodes[visitNode.indexes[iterator]])) {
-	          visitNode.indexes[iterator] += 1;
 	          if (!child[isClean]) {
 	            child[isClean] = true;
+	            visit.descending = true;
 	            stack.push({
 	              eventIndex: 0,
 	              events: getEvents(child),
@@ -38570,6 +38839,7 @@ function requireLazyResult () {
 	            descended = true;
 	            break
 	          }
+	          visitNode.indexes[iterator] += 1;
 	        }
 	        if (descended) continue
 	        visit.iterator = 0;
@@ -38772,7 +39042,7 @@ function requireProcessor$1 () {
 
 	class Processor {
 	  constructor(plugins = []) {
-	    this.version = '8.5.23';
+	    this.version = '8.5.29';
 	    this.plugins = this.normalize(plugins);
 	  }
 
@@ -38878,7 +39148,7 @@ function requirePostcss () {
 	          ': postcss.plugin was deprecated. Migration guide:\n' +
 	          'https://evilmartians.com/chronicles/postcss-8-plugin-migration'
 	      );
-	      if (browser$1.env.LANG && browser$1.env.LANG.startsWith('cn')) {
+	      if (browser$1.env.LANG && browser$1.env.LANG.startsWith('zh')) {
 	        /* c8 ignore next 7 */
 	        // eslint-disable-next-line no-console
 	        console.warn(
@@ -41636,8 +41906,9 @@ function requireParser () {
 	    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) {
@@ -41682,6 +41953,11 @@ function requireParser () {
 	            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]);
 	        }
@@ -41742,7 +42018,7 @@ function requireParser () {
 	                        }
 	                        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;
@@ -42166,7 +42442,21 @@ function requireParser () {
 	        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);
@@ -42196,6 +42486,7 @@ function requireParser () {
 	    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({
@@ -42265,7 +42556,9 @@ function requireParser () {
 	            }
 	        }
 	        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 () {
@@ -42370,8 +42663,14 @@ function requireParser () {
 	        // 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;
@@ -42383,7 +42682,7 @@ function requireParser () {
 	            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,
@@ -42391,7 +42690,7 @@ function requireParser () {
 	                };
 	                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,
@@ -49337,6 +49636,7 @@ function resolveExt(filename, fs) {
 }
 const tsConfigCache = createCache();
 const tsConfigRefMap = /* @__PURE__ */ new Map();
+const extendedConfigCache = /* @__PURE__ */ new Map();
 function resolveWithTS(containingFile, source, ts2, fs) {
   return;
 }
@@ -49347,6 +49647,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);
 }
@@ -50588,11 +50892,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);
@@ -50664,6 +50975,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${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);
     }
@@ -50702,6 +51025,9 @@ function transformDestructuredProps(ctx, vueImportAliases) {
       if (parent && parent.type.startsWith("TS") && !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 (isFunctionType(node)) {
@@ -50747,6 +51073,9 @@ function transformDestructuredProps(ctx, vueImportAliases) {
     },
     leave(node, parent) {
       parent && parentStack.pop();
+      if (node === currentModelOption) {
+        currentModelOption = null;
+      }
       if (isFunctionType(node)) {
         popScope(true);
       } else if (node.type === "BlockStatement" && !isFunctionType(parent)) {
@@ -51318,6 +51647,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;
@@ -51333,8 +51664,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();
+          }
         }
       });
     }
@@ -51876,7 +52209,7 @@ var __spreadValues = (a, b) => {
     }
   return a;
 };
-const version = "3.5.42";
+const version = "3.5.44";
 const parseCache = parseCache$1;
 const errorMessages = __spreadValues(__spreadValues({}, errorMessages$1), DOMErrorMessages);
 const walk = walk$2;