@vue/compiler-sfc 3.4.0-alpha.2 → 3.4.0-alpha.4

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

@@ -7,8 +7,8 @@ const EMPTY_OBJ = Object.freeze({}) ;
 const NOOP = () => {
 };
 const NO = () => false;
-const onRE = /^on[^a-z]/;
-const isOn = (key) => onRE.test(key);
+const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter
+(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97);
 const extend = Object.assign;
 const hasOwnProperty$3 = Object.prototype.hasOwnProperty;
 const hasOwn = (val, key) => hasOwnProperty$3.call(val, key);
@@ -79,7 +79,7 @@ const slotFlagsText = {
   [3]: "FORWARDED"
 };
 
-const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console";
+const GLOBALS_ALLOWED = "Infinity,undefined,NaN,isFinite,isNaN,parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,BigInt,console,Error";
 const isGloballyAllowed = /* @__PURE__ */ makeMap(GLOBALS_ALLOWED);
 
 const range = 2;
@@ -374,6 +374,90 @@ function registerRuntimeHelpers(helpers) {
   });
 }
 
+const Namespaces = {
+  "HTML": 0,
+  "0": "HTML",
+  "SVG": 1,
+  "1": "SVG",
+  "MATH_ML": 2,
+  "2": "MATH_ML"
+};
+const NodeTypes = {
+  "ROOT": 0,
+  "0": "ROOT",
+  "ELEMENT": 1,
+  "1": "ELEMENT",
+  "TEXT": 2,
+  "2": "TEXT",
+  "COMMENT": 3,
+  "3": "COMMENT",
+  "SIMPLE_EXPRESSION": 4,
+  "4": "SIMPLE_EXPRESSION",
+  "INTERPOLATION": 5,
+  "5": "INTERPOLATION",
+  "ATTRIBUTE": 6,
+  "6": "ATTRIBUTE",
+  "DIRECTIVE": 7,
+  "7": "DIRECTIVE",
+  "COMPOUND_EXPRESSION": 8,
+  "8": "COMPOUND_EXPRESSION",
+  "IF": 9,
+  "9": "IF",
+  "IF_BRANCH": 10,
+  "10": "IF_BRANCH",
+  "FOR": 11,
+  "11": "FOR",
+  "TEXT_CALL": 12,
+  "12": "TEXT_CALL",
+  "VNODE_CALL": 13,
+  "13": "VNODE_CALL",
+  "JS_CALL_EXPRESSION": 14,
+  "14": "JS_CALL_EXPRESSION",
+  "JS_OBJECT_EXPRESSION": 15,
+  "15": "JS_OBJECT_EXPRESSION",
+  "JS_PROPERTY": 16,
+  "16": "JS_PROPERTY",
+  "JS_ARRAY_EXPRESSION": 17,
+  "17": "JS_ARRAY_EXPRESSION",
+  "JS_FUNCTION_EXPRESSION": 18,
+  "18": "JS_FUNCTION_EXPRESSION",
+  "JS_CONDITIONAL_EXPRESSION": 19,
+  "19": "JS_CONDITIONAL_EXPRESSION",
+  "JS_CACHE_EXPRESSION": 20,
+  "20": "JS_CACHE_EXPRESSION",
+  "JS_BLOCK_STATEMENT": 21,
+  "21": "JS_BLOCK_STATEMENT",
+  "JS_TEMPLATE_LITERAL": 22,
+  "22": "JS_TEMPLATE_LITERAL",
+  "JS_IF_STATEMENT": 23,
+  "23": "JS_IF_STATEMENT",
+  "JS_ASSIGNMENT_EXPRESSION": 24,
+  "24": "JS_ASSIGNMENT_EXPRESSION",
+  "JS_SEQUENCE_EXPRESSION": 25,
+  "25": "JS_SEQUENCE_EXPRESSION",
+  "JS_RETURN_STATEMENT": 26,
+  "26": "JS_RETURN_STATEMENT"
+};
+const ElementTypes = {
+  "ELEMENT": 0,
+  "0": "ELEMENT",
+  "COMPONENT": 1,
+  "1": "COMPONENT",
+  "SLOT": 2,
+  "2": "SLOT",
+  "TEMPLATE": 3,
+  "3": "TEMPLATE"
+};
+const ConstantTypes = {
+  "NOT_CONSTANT": 0,
+  "0": "NOT_CONSTANT",
+  "CAN_SKIP_PATCH": 1,
+  "1": "CAN_SKIP_PATCH",
+  "CAN_HOIST": 2,
+  "2": "CAN_HOIST",
+  "CAN_STRINGIFY": 3,
+  "3": "CAN_STRINGIFY"
+};
 const locStub = {
   start: { line: 1, column: 1, offset: 0 },
   end: { line: 1, column: 1, offset: 0 },
@@ -1166,7 +1250,9 @@ let Tokenizer$1 = class Tokenizer {
     this.inRCDATA = false;
     /** For disabling RCDATA tags handling */
     this.inXML = false;
-    /** Reocrd newline positions for fast line / column calculation */
+    /** For disabling interpolation parsing in v-pre */
+    this.inVPre = false;
+    /** Record newline positions for fast line / column calculation */
     this.newlines = [];
     this.mode = 0;
     this.delimiterOpen = defaultDelimitersOpen;
@@ -1191,6 +1277,7 @@ let Tokenizer$1 = class Tokenizer {
     this.sectionStart = 0;
     this.index = 0;
     this.baseState = 1;
+    this.inRCDATA = false;
     this.currentSequence = void 0;
     this.newlines.length = 0;
     this.delimiterOpen = defaultDelimitersOpen;
@@ -1231,7 +1318,7 @@ let Tokenizer$1 = class Tokenizer {
       this.sectionStart = this.index;
     } else if (c === 38) {
       this.startEntity();
-    } else if (c === this.delimiterOpen[0]) {
+    } else if (!this.inVPre && c === this.delimiterOpen[0]) {
       this.state = 2;
       this.delimiterIndex = 0;
       this.stateInterpolationOpen(c);
@@ -1967,6 +2054,16 @@ let Tokenizer$1 = class Tokenizer {
   }
 };
 
+const CompilerDeprecationTypes = {
+  "COMPILER_IS_ON_ELEMENT": "COMPILER_IS_ON_ELEMENT",
+  "COMPILER_V_BIND_SYNC": "COMPILER_V_BIND_SYNC",
+  "COMPILER_V_BIND_OBJECT_ORDER": "COMPILER_V_BIND_OBJECT_ORDER",
+  "COMPILER_V_ON_NATIVE": "COMPILER_V_ON_NATIVE",
+  "COMPILER_V_IF_V_FOR_PRECEDENCE": "COMPILER_V_IF_V_FOR_PRECEDENCE",
+  "COMPILER_NATIVE_TEMPLATE": "COMPILER_NATIVE_TEMPLATE",
+  "COMPILER_INLINE_TEMPLATE": "COMPILER_INLINE_TEMPLATE",
+  "COMPILER_FILTERS": "COMPILER_FILTER"
+};
 const deprecationData = {
   ["COMPILER_IS_ON_ELEMENT"]: {
     message: `Platform-native elements with "is" prop will no longer be treated as components in Vue 3 unless the "is" value is explicitly prefixed with "vue:".`,
@@ -2048,6 +2145,114 @@ function createCompilerError(code, loc, messages, additionalMessage) {
   error.loc = loc;
   return error;
 }
+const ErrorCodes = {
+  "ABRUPT_CLOSING_OF_EMPTY_COMMENT": 0,
+  "0": "ABRUPT_CLOSING_OF_EMPTY_COMMENT",
+  "CDATA_IN_HTML_CONTENT": 1,
+  "1": "CDATA_IN_HTML_CONTENT",
+  "DUPLICATE_ATTRIBUTE": 2,
+  "2": "DUPLICATE_ATTRIBUTE",
+  "END_TAG_WITH_ATTRIBUTES": 3,
+  "3": "END_TAG_WITH_ATTRIBUTES",
+  "END_TAG_WITH_TRAILING_SOLIDUS": 4,
+  "4": "END_TAG_WITH_TRAILING_SOLIDUS",
+  "EOF_BEFORE_TAG_NAME": 5,
+  "5": "EOF_BEFORE_TAG_NAME",
+  "EOF_IN_CDATA": 6,
+  "6": "EOF_IN_CDATA",
+  "EOF_IN_COMMENT": 7,
+  "7": "EOF_IN_COMMENT",
+  "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT": 8,
+  "8": "EOF_IN_SCRIPT_HTML_COMMENT_LIKE_TEXT",
+  "EOF_IN_TAG": 9,
+  "9": "EOF_IN_TAG",
+  "INCORRECTLY_CLOSED_COMMENT": 10,
+  "10": "INCORRECTLY_CLOSED_COMMENT",
+  "INCORRECTLY_OPENED_COMMENT": 11,
+  "11": "INCORRECTLY_OPENED_COMMENT",
+  "INVALID_FIRST_CHARACTER_OF_TAG_NAME": 12,
+  "12": "INVALID_FIRST_CHARACTER_OF_TAG_NAME",
+  "MISSING_ATTRIBUTE_VALUE": 13,
+  "13": "MISSING_ATTRIBUTE_VALUE",
+  "MISSING_END_TAG_NAME": 14,
+  "14": "MISSING_END_TAG_NAME",
+  "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES": 15,
+  "15": "MISSING_WHITESPACE_BETWEEN_ATTRIBUTES",
+  "NESTED_COMMENT": 16,
+  "16": "NESTED_COMMENT",
+  "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME": 17,
+  "17": "UNEXPECTED_CHARACTER_IN_ATTRIBUTE_NAME",
+  "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE": 18,
+  "18": "UNEXPECTED_CHARACTER_IN_UNQUOTED_ATTRIBUTE_VALUE",
+  "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME": 19,
+  "19": "UNEXPECTED_EQUALS_SIGN_BEFORE_ATTRIBUTE_NAME",
+  "UNEXPECTED_NULL_CHARACTER": 20,
+  "20": "UNEXPECTED_NULL_CHARACTER",
+  "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME": 21,
+  "21": "UNEXPECTED_QUESTION_MARK_INSTEAD_OF_TAG_NAME",
+  "UNEXPECTED_SOLIDUS_IN_TAG": 22,
+  "22": "UNEXPECTED_SOLIDUS_IN_TAG",
+  "X_INVALID_END_TAG": 23,
+  "23": "X_INVALID_END_TAG",
+  "X_MISSING_END_TAG": 24,
+  "24": "X_MISSING_END_TAG",
+  "X_MISSING_INTERPOLATION_END": 25,
+  "25": "X_MISSING_INTERPOLATION_END",
+  "X_MISSING_DIRECTIVE_NAME": 26,
+  "26": "X_MISSING_DIRECTIVE_NAME",
+  "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END": 27,
+  "27": "X_MISSING_DYNAMIC_DIRECTIVE_ARGUMENT_END",
+  "X_V_IF_NO_EXPRESSION": 28,
+  "28": "X_V_IF_NO_EXPRESSION",
+  "X_V_IF_SAME_KEY": 29,
+  "29": "X_V_IF_SAME_KEY",
+  "X_V_ELSE_NO_ADJACENT_IF": 30,
+  "30": "X_V_ELSE_NO_ADJACENT_IF",
+  "X_V_FOR_NO_EXPRESSION": 31,
+  "31": "X_V_FOR_NO_EXPRESSION",
+  "X_V_FOR_MALFORMED_EXPRESSION": 32,
+  "32": "X_V_FOR_MALFORMED_EXPRESSION",
+  "X_V_FOR_TEMPLATE_KEY_PLACEMENT": 33,
+  "33": "X_V_FOR_TEMPLATE_KEY_PLACEMENT",
+  "X_V_BIND_NO_EXPRESSION": 34,
+  "34": "X_V_BIND_NO_EXPRESSION",
+  "X_V_ON_NO_EXPRESSION": 35,
+  "35": "X_V_ON_NO_EXPRESSION",
+  "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET": 36,
+  "36": "X_V_SLOT_UNEXPECTED_DIRECTIVE_ON_SLOT_OUTLET",
+  "X_V_SLOT_MIXED_SLOT_USAGE": 37,
+  "37": "X_V_SLOT_MIXED_SLOT_USAGE",
+  "X_V_SLOT_DUPLICATE_SLOT_NAMES": 38,
+  "38": "X_V_SLOT_DUPLICATE_SLOT_NAMES",
+  "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN": 39,
+  "39": "X_V_SLOT_EXTRANEOUS_DEFAULT_SLOT_CHILDREN",
+  "X_V_SLOT_MISPLACED": 40,
+  "40": "X_V_SLOT_MISPLACED",
+  "X_V_MODEL_NO_EXPRESSION": 41,
+  "41": "X_V_MODEL_NO_EXPRESSION",
+  "X_V_MODEL_MALFORMED_EXPRESSION": 42,
+  "42": "X_V_MODEL_MALFORMED_EXPRESSION",
+  "X_V_MODEL_ON_SCOPE_VARIABLE": 43,
+  "43": "X_V_MODEL_ON_SCOPE_VARIABLE",
+  "X_V_MODEL_ON_PROPS": 44,
+  "44": "X_V_MODEL_ON_PROPS",
+  "X_INVALID_EXPRESSION": 45,
+  "45": "X_INVALID_EXPRESSION",
+  "X_KEEP_ALIVE_INVALID_CHILDREN": 46,
+  "46": "X_KEEP_ALIVE_INVALID_CHILDREN",
+  "X_VNODE_HOOKS": 47,
+  "47": "X_VNODE_HOOKS",
+  "X_PREFIX_ID_NOT_SUPPORTED": 48,
+  "48": "X_PREFIX_ID_NOT_SUPPORTED",
+  "X_MODULE_MODE_NOT_SUPPORTED": 49,
+  "49": "X_MODULE_MODE_NOT_SUPPORTED",
+  "X_CACHE_HANDLER_NOT_SUPPORTED": 50,
+  "50": "X_CACHE_HANDLER_NOT_SUPPORTED",
+  "X_SCOPE_ID_NOT_SUPPORTED": 51,
+  "51": "X_SCOPE_ID_NOT_SUPPORTED",
+  "__EXTEND_POINT__": 52,
+  "52": "__EXTEND_POINT__"
+};
 const errorMessages = {
   // parse errors
   [0]: "Illegal comment.",
@@ -2100,16 +2305,14 @@ const errorMessages = {
 Use a v-bind binding combined with a v-on listener that emits update:x event instead.`,
   [45]: `Error parsing JavaScript expression: `,
   [46]: `<KeepAlive> expects exactly one child component.`,
+  [47]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
   // generic errors
-  [47]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
-  [48]: `ES module mode is not supported in this build of compiler.`,
-  [49]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
-  [50]: `"scopeId" option is only supported in module mode.`,
-  // deprecations
-  [51]: `@vnode-* hooks in templates are deprecated. Use the vue: prefix instead. For example, @vnode-mounted should be changed to @vue:mounted. @vnode-* hooks support will be removed in 3.4.`,
-  [52]: `v-is="component-name" has been deprecated. Use is="vue:component-name" instead. v-is support will be removed in 3.4.`,
+  [48]: `"prefixIdentifiers" option is not supported in this build of compiler.`,
+  [49]: `ES module mode is not supported in this build of compiler.`,
+  [50]: `"cacheHandlers" option is only supported when the "prefixIdentifiers" option is enabled.`,
+  [51]: `"scopeId" option is only supported in module mode.`,
   // just to fulfill types
-  [53]: ``
+  [52]: ``
 };
 
 function getDefaultExportFromCjs (x) {
@@ -16918,7 +17121,8 @@ const defaultParserOptions = {
   isCustomElement: NO,
   onError: defaultOnError,
   onWarn: defaultOnWarn,
-  comments: true
+  comments: true,
+  prefixIdentifiers: false
 };
 let currentOptions = defaultParserOptions;
 let currentRoot = null;
@@ -16960,7 +17164,7 @@ const tokenizer$2 = new Tokenizer$1(stack, {
     }
     addNode({
       type: 5,
-      content: createSimpleExpression(exp, false, getLoc(innerStart, innerEnd)),
+      content: createExp(exp, false, getLoc(innerStart, innerEnd)),
       loc: getLoc(start, end)
     });
   },
@@ -17053,7 +17257,7 @@ const tokenizer$2 = new Tokenizer$1(stack, {
         loc: getLoc(start)
       };
       if (name === "pre") {
-        inVPre = true;
+        inVPre = tokenizer$2.inVPre = true;
         currentVPreBoundary = currentOpenTag;
         const props = currentOpenTag.props;
         for (let i = 0; i < props.length; i++) {
@@ -17065,13 +17269,15 @@ const tokenizer$2 = new Tokenizer$1(stack, {
     }
   },
   ondirarg(start, end) {
+    if (start === end)
+      return;
     const arg = getSlice(start, end);
     if (inVPre) {
       currentProp.name += arg;
       setLocEnd(currentProp.nameLoc, end);
     } else {
       const isStatic = arg[0] !== `[`;
-      currentProp.arg = createSimpleExpression(
+      currentProp.arg = createExp(
         isStatic ? arg : arg.slice(1, -1),
         isStatic,
         getLoc(start, end),
@@ -17138,10 +17344,22 @@ const tokenizer$2 = new Tokenizer$1(stack, {
             tokenizer$2.enterRCDATA(toCharCodes(`</template`), 0);
           }
         } else {
-          currentProp.exp = createSimpleExpression(
+          let expParseMode = 0 /* Normal */;
+          {
+            if (currentProp.name === "for") {
+              expParseMode = 3 /* Skip */;
+            } else if (currentProp.name === "slot") {
+              expParseMode = 1 /* Params */;
+            } else if (currentProp.name === "on" && currentAttrValue.includes(";")) {
+              expParseMode = 2 /* Statements */;
+            }
+          }
+          currentProp.exp = createExp(
             currentAttrValue,
             false,
-            getLoc(currentAttrStartIndex, currentAttrEndIndex)
+            getLoc(currentAttrStartIndex, currentAttrEndIndex),
+            0,
+            expParseMode
           );
           if (currentProp.name === "for") {
             currentProp.forParseResult = parseForExpression(currentProp.exp);
@@ -17234,10 +17452,16 @@ function parseForExpression(input) {
   if (!inMatch)
     return;
   const [, LHS, RHS] = inMatch;
-  const createAliasExpression = (content, offset) => {
+  const createAliasExpression = (content, offset, asParam = false) => {
     const start = loc.start.offset + offset;
     const end = start + content.length;
-    return createSimpleExpression(content, false, getLoc(start, end));
+    return createExp(
+      content,
+      false,
+      getLoc(start, end),
+      0,
+      asParam ? 1 /* Params */ : 0 /* Normal */
+    );
   };
   const result = {
     source: createAliasExpression(RHS.trim(), exp.indexOf(RHS, LHS.length)),
@@ -17255,7 +17479,7 @@ function parseForExpression(input) {
     let keyOffset;
     if (keyContent) {
       keyOffset = exp.indexOf(keyContent, trimmedOffset + valueContent.length);
-      result.key = createAliasExpression(keyContent, keyOffset);
+      result.key = createAliasExpression(keyContent, keyOffset, true);
     }
     if (iteratorMatch[2]) {
       const indexContent = iteratorMatch[2].trim();
@@ -17265,13 +17489,14 @@ function parseForExpression(input) {
           exp.indexOf(
             indexContent,
             result.key ? keyOffset + keyContent.length : trimmedOffset + valueContent.length
-          )
+          ),
+          true
         );
       }
     }
   }
   if (valueContent) {
-    result.value = createAliasExpression(valueContent, trimmedOffset);
+    result.value = createAliasExpression(valueContent, trimmedOffset, true);
   }
   return result;
 }
@@ -17342,7 +17567,7 @@ function onCloseTag(el, end, isImplied = false) {
     inPre--;
   }
   if (currentVPreBoundary === el) {
-    inVPre = false;
+    inVPre = tokenizer$2.inVPre = false;
     currentVPreBoundary = null;
   }
   if (tokenizer$2.inXML && (stack[0] ? stack[0].ns : currentOptions.ns) === 0) {
@@ -17506,8 +17731,36 @@ function dirToAttr(dir) {
   }
   return attr;
 }
-function emitError(code, index) {
-  currentOptions.onError(createCompilerError(code, getLoc(index, index)));
+function createExp(content, isStatic = false, loc, constType = 0, parseMode = 0 /* Normal */) {
+  const exp = createSimpleExpression(content, isStatic, loc, constType);
+  if (!isStatic && currentOptions.prefixIdentifiers && parseMode !== 3 /* Skip */ && content.trim()) {
+    if (isSimpleIdentifier(content)) {
+      exp.ast = null;
+      return exp;
+    }
+    try {
+      const plugins = currentOptions.expressionPlugins;
+      const options = {
+        plugins: plugins ? [...plugins, "typescript"] : ["typescript"]
+      };
+      if (parseMode === 2 /* Statements */) {
+        exp.ast = parse_1$1(` ${content} `, options).program;
+      } else if (parseMode === 1 /* Params */) {
+        exp.ast = parseExpression_1(`(${content})=>{}`, options);
+      } else {
+        exp.ast = parseExpression_1(`(${content})`, options);
+      }
+    } catch (e) {
+      exp.ast = false;
+      emitError(45, loc.start.offset, e.message);
+    }
+  }
+  return exp;
+}
+function emitError(code, index, message) {
+  currentOptions.onError(
+    createCompilerError(code, getLoc(index, index), void 0, message)
+  );
 }
 function reset() {
   tokenizer$2.reset();
@@ -17538,6 +17791,7 @@ function baseParse(input, options) {
     }
   }
   tokenizer$2.mode = currentOptions.parseMode === "html" ? 1 : currentOptions.parseMode === "sfc" ? 2 : 0;
+  tokenizer$2.inXML = currentOptions.ns === 1 || currentOptions.ns === 2;
   const delimiters = options == null ? void 0 : options.delimiters;
   if (delimiters) {
     tokenizer$2.delimiterOpen = toCharCodes(delimiters[0]);
@@ -22403,7 +22657,7 @@ function walk$1(ast, { enter, leave }) {
 }
 
 function walkIdentifiers(root, onIdentifier, includeAll = false, parentStack = [], knownIds = /* @__PURE__ */ Object.create(null)) {
-  const rootExp = root.type === "Program" && root.body[0].type === "ExpressionStatement" && root.body[0].expression;
+  const rootExp = root.type === "Program" ? root.body[0].type === "ExpressionStatement" && root.body[0].expression : root;
   walk$1(root, {
     enter(node, parent) {
       parent && parentStack.push(parent);
@@ -22476,7 +22730,7 @@ function isInDestructureAssignment(parent, parentStack) {
 }
 function walkFunctionParams(node, onIdent) {
   for (const p of node.params) {
-    for (const id of extractIdentifiers(p)) {
+    for (const id of extractIdentifiers$1(p)) {
       onIdent(id);
     }
   }
@@ -22487,7 +22741,7 @@ function walkBlockDeclarations(block, onIdent) {
       if (stmt.declare)
         continue;
       for (const decl of stmt.declarations) {
-        for (const id of extractIdentifiers(decl.id)) {
+        for (const id of extractIdentifiers$1(decl.id)) {
           onIdent(id);
         }
       }
@@ -22499,7 +22753,7 @@ function walkBlockDeclarations(block, onIdent) {
       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(decl.id)) {
+          for (const id of extractIdentifiers$1(decl.id)) {
             onIdent(id);
           }
         }
@@ -22507,7 +22761,7 @@ function walkBlockDeclarations(block, onIdent) {
     }
   }
 }
-function extractIdentifiers(param, nodes = []) {
+function extractIdentifiers$1(param, nodes = []) {
   switch (param.type) {
     case "Identifier":
       nodes.push(param);
@@ -22522,23 +22776,23 @@ function extractIdentifiers(param, nodes = []) {
     case "ObjectPattern":
       for (const prop of param.properties) {
         if (prop.type === "RestElement") {
-          extractIdentifiers(prop.argument, nodes);
+          extractIdentifiers$1(prop.argument, nodes);
         } else {
-          extractIdentifiers(prop.value, nodes);
+          extractIdentifiers$1(prop.value, nodes);
         }
       }
       break;
     case "ArrayPattern":
       param.elements.forEach((element) => {
         if (element)
-          extractIdentifiers(element, nodes);
+          extractIdentifiers$1(element, nodes);
       });
       break;
     case "RestElement":
-      extractIdentifiers(param.argument, nodes);
+      extractIdentifiers$1(param.argument, nodes);
       break;
     case "AssignmentPattern":
-      extractIdentifiers(param.left, nodes);
+      extractIdentifiers$1(param.left, nodes);
       break;
   }
   return nodes;
@@ -22752,7 +23006,11 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
   };
   const rawExp = node.content;
   const bailConstant = constantBailRE.test(rawExp);
-  if (isSimpleIdentifier(rawExp)) {
+  let ast = node.ast;
+  if (ast === false) {
+    return node;
+  }
+  if (ast === null || !ast && isSimpleIdentifier(rawExp)) {
     const isScopeVarReference = context.identifiers[rawExp];
     const isAllowedGlobal = isGloballyAllowed(rawExp);
     const isLiteral = isLiteralWhitelisted(rawExp);
@@ -22770,22 +23028,23 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
     }
     return node;
   }
-  let ast;
-  const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
-  try {
-    ast = parse_1$1(source, {
-      plugins: context.expressionPlugins
-    }).program;
-  } catch (e) {
-    context.onError(
-      createCompilerError(
-        45,
-        node.loc,
-        void 0,
-        e.message
-      )
-    );
-    return node;
+  if (!ast) {
+    const source = asRawStatements ? ` ${rawExp} ` : `(${rawExp})${asParams ? `=>{}` : ``}`;
+    try {
+      ast = parse_1$1(source, {
+        plugins: context.expressionPlugins
+      }).program;
+    } catch (e) {
+      context.onError(
+        createCompilerError(
+          45,
+          node.loc,
+          void 0,
+          e.message
+        )
+      );
+      return node;
+    }
   }
   const ids = [];
   const parentStack = [];
@@ -22825,15 +23084,15 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
     if (leadingText.length || id.prefix) {
       children.push(leadingText + (id.prefix || ``));
     }
-    const source2 = rawExp.slice(start, end);
+    const source = rawExp.slice(start, end);
     children.push(
       createSimpleExpression(
         id.name,
         false,
         {
-          start: advancePositionWithClone(node.loc.start, source2, start),
-          end: advancePositionWithClone(node.loc.start, source2, end),
-          source: source2
+          start: advancePositionWithClone(node.loc.start, source, start),
+          end: advancePositionWithClone(node.loc.start, source, end),
+          source
         },
         id.isConstant ? 3 : 0
       )
@@ -22845,6 +23104,7 @@ function processExpression(node, context, asParams = false, asRawStatements = fa
   let ret;
   if (children.length) {
     ret = createCompoundExpression(children, node.loc);
+    ret.ast = ast;
   } else {
     ret = node;
     ret.constType = bailConstant ? 0 : 3;
@@ -23798,6 +24058,10 @@ function resolveSetupReference(name, context) {
       `${context.helperString(UNREF)}(${fromMaybeRef})`
     ) : `$setup[${JSON.stringify(fromMaybeRef)}]`;
   }
+  const fromProps = checkType("props");
+  if (fromProps) {
+    return `${context.helperString(UNREF)}(${context.inline ? "__props" : "$props"}[${JSON.stringify(fromProps)}])`;
+  }
 }
 function buildProps(node, context, props = node.props, isComponent, isDynamicComponent, ssr = false) {
   const { tag, loc: elementLoc, children } = node;
@@ -23838,6 +24102,9 @@ function buildProps(node, context, props = node.props, isComponent, isDynamicCom
       if (isEventHandler && isReservedProp(name)) {
         hasVnodeHook = true;
       }
+      if (isEventHandler && value.type === 14) {
+        value = value.arguments[0];
+      }
       if (value.type === 20 || (value.type === 4 || value.type === 8) && getConstantType(value, context) > 0) {
         return;
       }
@@ -24269,9 +24536,7 @@ const transformOn$1 = (dir, node, context, augmentor) => {
     if (arg.isStatic) {
       let rawName = arg.content;
       if (rawName.startsWith("vnode")) {
-        context.onWarn(
-          createCompilerError(51, arg.loc)
-        );
+        context.onError(createCompilerError(47, arg.loc));
       }
       if (rawName.startsWith("vue:")) {
         rawName = `vnode-${rawName.slice(4)}`;
@@ -24658,10 +24923,10 @@ function baseCompile(source, options = {}) {
   const isModuleMode = options.mode === "module";
   const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
   if (!prefixIdentifiers && options.cacheHandlers) {
-    onError(createCompilerError(49));
+    onError(createCompilerError(50));
   }
   if (options.scopeId && !isModuleMode) {
-    onError(createCompilerError(50));
+    onError(createCompilerError(51));
   }
   const ast = isString$2(source) ? baseParse(source, options) : source;
   const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
@@ -24696,6 +24961,19 @@ function baseCompile(source, options = {}) {
   );
 }
 
+const BindingTypes = {
+  "DATA": "data",
+  "PROPS": "props",
+  "PROPS_ALIASED": "props-aliased",
+  "SETUP_LET": "setup-let",
+  "SETUP_CONST": "setup-const",
+  "SETUP_REACTIVE_CONST": "setup-reactive-const",
+  "SETUP_MAYBE_REF": "setup-maybe-ref",
+  "SETUP_REF": "setup-ref",
+  "OPTIONS": "options",
+  "LITERAL_CONST": "literal-const"
+};
+
 const noopDirectiveTransform = () => ({ props: [] });
 
 const V_MODEL_RADIO = Symbol(`vModelRadio` );
@@ -24800,6 +25078,32 @@ function createDOMCompilerError(code, loc) {
     DOMErrorMessages 
   );
 }
+const DOMErrorCodes = {
+  "X_V_HTML_NO_EXPRESSION": 53,
+  "53": "X_V_HTML_NO_EXPRESSION",
+  "X_V_HTML_WITH_CHILDREN": 54,
+  "54": "X_V_HTML_WITH_CHILDREN",
+  "X_V_TEXT_NO_EXPRESSION": 55,
+  "55": "X_V_TEXT_NO_EXPRESSION",
+  "X_V_TEXT_WITH_CHILDREN": 56,
+  "56": "X_V_TEXT_WITH_CHILDREN",
+  "X_V_MODEL_ON_INVALID_ELEMENT": 57,
+  "57": "X_V_MODEL_ON_INVALID_ELEMENT",
+  "X_V_MODEL_ARG_ON_ELEMENT": 58,
+  "58": "X_V_MODEL_ARG_ON_ELEMENT",
+  "X_V_MODEL_ON_FILE_INPUT_ELEMENT": 59,
+  "59": "X_V_MODEL_ON_FILE_INPUT_ELEMENT",
+  "X_V_MODEL_UNNECESSARY_VALUE": 60,
+  "60": "X_V_MODEL_UNNECESSARY_VALUE",
+  "X_V_SHOW_NO_EXPRESSION": 61,
+  "61": "X_V_SHOW_NO_EXPRESSION",
+  "X_TRANSITION_INVALID_CHILDREN": 62,
+  "62": "X_TRANSITION_INVALID_CHILDREN",
+  "X_IGNORED_SIDE_EFFECT_TAG": 63,
+  "63": "X_IGNORED_SIDE_EFFECT_TAG",
+  "__EXTEND_POINT__": 64,
+  "64": "__EXTEND_POINT__"
+};
 const DOMErrorMessages = {
   [53]: `v-html is missing expression.`,
   [54]: `v-html will override element children.`,
@@ -25362,6 +25666,7 @@ function parse$8(template, options = {}) {
 var CompilerDOM = /*#__PURE__*/Object.freeze({
   __proto__: null,
   BASE_TRANSITION: BASE_TRANSITION,
+  BindingTypes: BindingTypes,
   CAMELIZE: CAMELIZE,
   CAPITALIZE: CAPITALIZE,
   CREATE_BLOCK: CREATE_BLOCK,
@@ -25372,9 +25677,14 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   CREATE_STATIC: CREATE_STATIC,
   CREATE_TEXT: CREATE_TEXT,
   CREATE_VNODE: CREATE_VNODE,
+  CompilerDeprecationTypes: CompilerDeprecationTypes,
+  ConstantTypes: ConstantTypes,
   DOMDirectiveTransforms: DOMDirectiveTransforms,
+  DOMErrorCodes: DOMErrorCodes,
   DOMErrorMessages: DOMErrorMessages,
   DOMNodeTransforms: DOMNodeTransforms,
+  ElementTypes: ElementTypes,
+  ErrorCodes: ErrorCodes,
   FRAGMENT: FRAGMENT,
   GUARD_REACTIVE_PROPS: GUARD_REACTIVE_PROPS,
   IS_MEMO_SAME: IS_MEMO_SAME,
@@ -25384,6 +25694,8 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   NORMALIZE_CLASS: NORMALIZE_CLASS,
   NORMALIZE_PROPS: NORMALIZE_PROPS,
   NORMALIZE_STYLE: NORMALIZE_STYLE,
+  Namespaces: Namespaces,
+  NodeTypes: NodeTypes,
   OPEN_BLOCK: OPEN_BLOCK,
   POP_SCOPE_ID: POP_SCOPE_ID,
   PUSH_SCOPE_ID: PUSH_SCOPE_ID,
@@ -25449,7 +25761,7 @@ var CompilerDOM = /*#__PURE__*/Object.freeze({
   createTransformContext: createTransformContext,
   createVNodeCall: createVNodeCall,
   errorMessages: errorMessages,
-  extractIdentifiers: extractIdentifiers,
+  extractIdentifiers: extractIdentifiers$1,
   findDir: findDir,
   findProp: findProp,
   forAliasRE: forAliasRE,
@@ -25808,8 +26120,11 @@ function getEscapedPropName(key) {
   return propNameEscapeSymbolsRE.test(key) ? JSON.stringify(key) : key;
 }
 const cssVarNameEscapeSymbolsRE = /[ !"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g;
-function getEscapedCssVarName(key) {
-  return key.replace(cssVarNameEscapeSymbolsRE, (s) => `\\${s}`);
+function getEscapedCssVarName(key, doubleEscape) {
+  return key.replace(
+    cssVarNameEscapeSymbolsRE,
+    (s) => doubleEscape ? `\\\\${s}` : `\\${s}`
+  );
 }
 
 function pad$1 (hash, len) {
@@ -25886,15 +26201,15 @@ const CSS_VARS_HELPER = `useCssVars`;
 function genCssVarsFromList(vars, id, isProd, isSSR = false) {
   return `{
   ${vars.map(
-    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd)}": (${key})`
+    (key) => `"${isSSR ? `--` : ``}${genVarName(id, key, isProd, isSSR)}": (${key})`
   ).join(",\n  ")}
 }`;
 }
-function genVarName(id, raw, isProd) {
+function genVarName(id, raw, isProd, isSSR = false) {
   if (isProd) {
     return hash(id + raw);
   } else {
-    return `${id}-${getEscapedCssVarName(raw)}`;
+    return `${id}-${getEscapedCssVarName(raw, isSSR)}`;
   }
 }
 function normalizeExpression(exp) {
@@ -26248,11 +26563,7 @@ function createCache(max = 500) {
 }
 
 function isImportUsed(local, sfc) {
-  return new RegExp(
-    // #4274 escape $ since it's a special char in regex
-    // (and is the only regex special char that is valid in identifiers)
-    `[^\\w$_]${local.replace(/\$/g, "\\$")}[^\\w$_]`
-  ).test(resolveTemplateUsageCheckString(sfc));
+  return resolveTemplateUsageCheckString(sfc).has(local);
 }
 const templateUsageCheckCache = createCache();
 function resolveTemplateUsageCheckString(sfc) {
@@ -26261,80 +26572,51 @@ function resolveTemplateUsageCheckString(sfc) {
   if (cached) {
     return cached;
   }
-  let code = "";
+  const ids = /* @__PURE__ */ new Set();
   ast.children.forEach(walk);
   function walk(node) {
     var _a;
     switch (node.type) {
       case 1:
         if (!parserOptions.isNativeTag(node.tag) && !parserOptions.isBuiltInComponent(node.tag)) {
-          code += `,${camelize(node.tag)},${capitalize$1(camelize(node.tag))}`;
+          ids.add(camelize(node.tag));
+          ids.add(capitalize$1(camelize(node.tag)));
         }
         for (let i = 0; i < node.props.length; i++) {
           const prop = node.props[i];
           if (prop.type === 7) {
             if (!isBuiltInDirective(prop.name)) {
-              code += `,v${capitalize$1(camelize(prop.name))}`;
+              ids.add(`v${capitalize$1(camelize(prop.name))}`);
             }
             if (prop.arg && !prop.arg.isStatic) {
-              code += `,${stripStrings(
-                prop.arg.content
-              )}`;
+              extractIdentifiers(ids, prop.arg);
             }
-            if (prop.exp) {
-              code += `,${processExp(
-                prop.exp.content,
-                prop.name
-              )}`;
+            if (prop.name === "for") {
+              extractIdentifiers(ids, prop.forParseResult.source);
+            } else if (prop.exp) {
+              extractIdentifiers(ids, prop.exp);
             }
           }
           if (prop.type === 6 && prop.name === "ref" && ((_a = prop.value) == null ? void 0 : _a.content)) {
-            code += `,${prop.value.content}`;
+            ids.add(prop.value.content);
           }
         }
         node.children.forEach(walk);
         break;
       case 5:
-        code += `,${processExp(node.content.content)}`;
+        extractIdentifiers(ids, node.content);
         break;
     }
   }
-  code += ";";
-  templateUsageCheckCache.set(content, code);
-  return code;
+  templateUsageCheckCache.set(content, ids);
+  return ids;
 }
-function processExp(exp, dir) {
-  if (/ as\s+\w|<.*>|:/.test(exp)) {
-    if (dir === "slot") {
-      exp = `(${exp})=>{}`;
-    } else if (dir === "on") {
-      exp = `()=>{return ${exp}}`;
-    } else if (dir === "for") {
-      const inMatch = exp.match(forAliasRE);
-      if (inMatch) {
-        let [, LHS, RHS] = inMatch;
-        LHS = LHS.trim().replace(/^\(|\)$/g, "");
-        return processExp(`(${LHS})=>{}`) + processExp(RHS);
-      }
-    }
-    let ret = "";
-    const ast = parseExpression_1(exp, { plugins: ["typescript"] });
-    walkIdentifiers(ast, (node) => {
-      ret += `,` + node.name;
-    });
-    return ret;
+function extractIdentifiers(ids, node) {
+  if (node.ast) {
+    walkIdentifiers(node.ast, (n) => ids.add(n.name));
+  } else if (node.ast === null) {
+    ids.add(node.content);
   }
-  return stripStrings(exp);
-}
-function stripStrings(exp) {
-  return exp.replace(/'[^']*'|"[^"]*"/g, "").replace(/`[^`]+`/g, stripTemplateString);
-}
-function stripTemplateString(str) {
-  const interpMatch = str.match(/\${[^}]+}/g);
-  if (interpMatch) {
-    return interpMatch.map((m) => m.slice(2, -1)).join(",");
-  }
-  return "";
 }
 
 const DEFAULT_FILENAME = "anonymous.vue";
@@ -26345,7 +26627,8 @@ function parse$7(source, {
   sourceRoot = "",
   pad = false,
   ignoreEmpty = true,
-  compiler = CompilerDOM
+  compiler = CompilerDOM,
+  parseExpressions = true
 } = {}) {
   const sourceKey = source + sourceMap + filename + sourceRoot + pad + compiler.parse;
   const cache = parseCache$1.get(sourceKey);
@@ -26367,6 +26650,7 @@ function parse$7(source, {
   const errors = [];
   const ast = compiler.parse(source, {
     parseMode: "sfc",
+    prefixIdentifiers: parseExpressions,
     onError: (e) => {
       errors.push(e);
     }
@@ -26456,22 +26740,29 @@ function parse$7(source, {
       descriptor.script = null;
     }
   }
+  let templateColumnOffset = 0;
+  if (descriptor.template && (descriptor.template.lang === "pug" || descriptor.template.lang === "jade")) {
+    [descriptor.template.content, templateColumnOffset] = dedent(
+      descriptor.template.content
+    );
+  }
   if (sourceMap) {
-    const genMap = (block) => {
+    const genMap = (block, columnOffset = 0) => {
       if (block && !block.src) {
         block.map = generateSourceMap(
           filename,
           source,
           block.content,
           sourceRoot,
-          !pad || block.type === "template" ? block.loc.start.line - 1 : 0
+          !pad || block.type === "template" ? block.loc.start.line - 1 : 0,
+          columnOffset
         );
       }
     };
-    genMap(descriptor.template);
+    genMap(descriptor.template, templateColumnOffset);
     genMap(descriptor.script);
-    descriptor.styles.forEach(genMap);
-    descriptor.customBlocks.forEach(genMap);
+    descriptor.styles.forEach((s) => genMap(s));
+    descriptor.customBlocks.forEach((s) => genMap(s));
   }
   descriptor.cssVars = parseCssVars(descriptor);
   const slottedRE = /(?:::v-|:)slotted\(/;
@@ -26529,7 +26820,7 @@ function createBlock(node, source, pad) {
 const splitRE = /\r?\n/g;
 const emptyRE = /^(?:\/\/)?\s*$/;
 const replaceRE = /./g;
-function generateSourceMap(filename, source, generated, sourceRoot, lineOffset) {
+function generateSourceMap(filename, source, generated, sourceRoot, lineOffset, columnOffset) {
   const map = new SourceMapGenerator$6({
     file: filename.replace(/\\/g, "/"),
     sourceRoot: sourceRoot.replace(/\\/g, "/")
@@ -26544,7 +26835,7 @@ function generateSourceMap(filename, source, generated, sourceRoot, lineOffset)
         if (!/\s/.test(line[i])) {
           map._mappings.add({
             originalLine,
-            originalColumn: i,
+            originalColumn: i + columnOffset,
             generatedLine,
             generatedColumn: i,
             source: filename,
@@ -26595,6 +26886,26 @@ function hmrShouldReload(prevImports, next) {
   }
   return false;
 }
+function dedent(s) {
+  const lines = s.split("\n");
+  const minIndent = lines.reduce(function(minIndent2, line) {
+    var _a, _b;
+    if (line.trim() === "") {
+      return minIndent2;
+    }
+    const indent = ((_b = (_a = line.match(/^\s*/)) == null ? void 0 : _a[0]) == null ? void 0 : _b.length) || 0;
+    return Math.min(indent, minIndent2);
+  }, Infinity);
+  if (minIndent === 0) {
+    return [s, minIndent];
+  }
+  return [
+    lines.map(function(line) {
+      return line.slice(minIndent);
+    }).join("\n"),
+    minIndent
+  ];
+}
 
 /*! https://mths.be/punycode v1.4.1 by @mathias */
 
@@ -32142,7 +32453,7 @@ var _polyfillNode_fs$1 = /*#__PURE__*/Object.freeze({
 
 var require$$0$2 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_fs$1);
 
-var require$$2$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_path);
+var require$$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_path);
 
 var require$$0$1 = /*@__PURE__*/getAugmentedNamespace(_polyfillNode_util$1);
 
@@ -33712,7 +34023,7 @@ var nonSecure = { nanoid: nanoid$1, customAlphabet };
 
 let { SourceMapConsumer: SourceMapConsumer$4, SourceMapGenerator: SourceMapGenerator$5 } = sourceMap$2;
 let { existsSync, readFileSync } = require$$0$2;
-let { dirname: dirname$1, join } = require$$2$1;
+let { dirname: dirname$1, join } = require$$1;
 
 function fromBase64(str) {
   if (Buffer$1) {
@@ -33853,7 +34164,7 @@ PreviousMap$2.default = PreviousMap$2;
 
 let { SourceMapConsumer: SourceMapConsumer$3, SourceMapGenerator: SourceMapGenerator$4 } = sourceMap$2;
 let { fileURLToPath, pathToFileURL: pathToFileURL$1 } = require$$2;
-let { isAbsolute, resolve: resolve$1 } = require$$2$1;
+let { isAbsolute, resolve: resolve$1 } = require$$1;
 let { nanoid } = nonSecure;
 
 let terminalHighlight = terminalHighlight_1;
@@ -34099,7 +34410,7 @@ if (terminalHighlight && terminalHighlight.registerInput) {
 }
 
 let { SourceMapConsumer: SourceMapConsumer$2, SourceMapGenerator: SourceMapGenerator$3 } = sourceMap$2;
-let { dirname, relative, resolve, sep } = require$$2$1;
+let { dirname, relative, resolve, sep } = require$$1;
 let { pathToFileURL } = require$$2;
 
 let Input$3 = input;
@@ -36534,7 +36845,7 @@ let Root$2 = root$2;
 
 let Processor$1 = class Processor {
   constructor(plugins = []) {
-    this.version = '8.4.31';
+    this.version = '8.4.32';
     this.plugins = this.normalize(plugins);
   }
 
@@ -40326,14 +40637,19 @@ function rewriteSelector(id, selector, selectorRoot, slotted = false) {
         return false;
       }
     }
-    if (n.type !== "pseudo" && n.type !== "combinator") {
+    if (n.type !== "pseudo" && n.type !== "combinator" || n.type === "pseudo" && (n.value === ":is" || n.value === ":where")) {
       node = n;
     }
-    if (n.type === "pseudo" && (n.value === ":is" || n.value === ":where")) {
-      rewriteSelector(id, n.nodes[0], selectorRoot, slotted);
+  });
+  if (node) {
+    const { type, value } = node;
+    if (type === "pseudo" && (value === ":is" || value === ":where")) {
+      node.nodes.forEach(
+        (value2) => rewriteSelector(id, value2, selectorRoot, slotted)
+      );
       shouldInject = false;
     }
-  });
+  }
   if (node) {
     node.spaces.after = "";
   } else {
@@ -45493,33 +45809,39 @@ class TypeScope {
     this.exportedDeclares = /* @__PURE__ */ Object.create(null);
   }
 }
-function resolveTypeElements(ctx, node, scope) {
+function resolveTypeElements(ctx, node, scope, typeParameters) {
   if (node._resolvedElements) {
     return node._resolvedElements;
   }
   return node._resolvedElements = innerResolveTypeElements(
     ctx,
     node,
-    node._ownerScope || scope || ctxToScope(ctx)
+    node._ownerScope || scope || ctxToScope(ctx),
+    typeParameters
   );
 }
-function innerResolveTypeElements(ctx, node, scope) {
+function innerResolveTypeElements(ctx, node, scope, typeParameters) {
   var _a, _b;
   switch (node.type) {
     case "TSTypeLiteral":
-      return typeElementsToMap(ctx, node.members, scope);
+      return typeElementsToMap(ctx, node.members, scope, typeParameters);
     case "TSInterfaceDeclaration":
-      return resolveInterfaceMembers(ctx, node, scope);
+      return resolveInterfaceMembers(ctx, node, scope, typeParameters);
     case "TSTypeAliasDeclaration":
     case "TSParenthesizedType":
-      return resolveTypeElements(ctx, node.typeAnnotation, scope);
+      return resolveTypeElements(
+        ctx,
+        node.typeAnnotation,
+        scope,
+        typeParameters
+      );
     case "TSFunctionType": {
       return { props: {}, calls: [node] };
     }
     case "TSUnionType":
     case "TSIntersectionType":
       return mergeElements(
-        node.types.map((t) => resolveTypeElements(ctx, t, scope)),
+        node.types.map((t) => resolveTypeElements(ctx, t, scope, typeParameters)),
         node.type
       );
     case "TSMappedType":
@@ -45536,20 +45858,53 @@ function innerResolveTypeElements(ctx, node, scope) {
       const typeName = getReferenceName(node);
       if ((typeName === "ExtractPropTypes" || typeName === "ExtractPublicPropTypes") && node.typeParameters && ((_a = scope.imports[typeName]) == null ? void 0 : _a.source) === "vue") {
         return resolveExtractPropTypes(
-          resolveTypeElements(ctx, node.typeParameters.params[0], scope),
+          resolveTypeElements(
+            ctx,
+            node.typeParameters.params[0],
+            scope,
+            typeParameters
+          ),
           scope
         );
       }
       const resolved = resolveTypeReference(ctx, node, scope);
       if (resolved) {
-        return resolveTypeElements(ctx, resolved, resolved._ownerScope);
+        const typeParams = /* @__PURE__ */ Object.create(null);
+        if ((resolved.type === "TSTypeAliasDeclaration" || resolved.type === "TSInterfaceDeclaration") && resolved.typeParameters && node.typeParameters) {
+          resolved.typeParameters.params.forEach((p, i) => {
+            let param = typeParameters && typeParameters[p.name];
+            if (!param)
+              param = node.typeParameters.params[i];
+            typeParams[p.name] = param;
+          });
+        }
+        return resolveTypeElements(
+          ctx,
+          resolved,
+          resolved._ownerScope,
+          typeParams
+        );
       } else {
         if (typeof typeName === "string") {
+          if (typeParameters && typeParameters[typeName]) {
+            return resolveTypeElements(
+              ctx,
+              typeParameters[typeName],
+              scope,
+              typeParameters
+            );
+          }
           if (
             // @ts-ignore
             SupportedBuiltinsSet.has(typeName)
           ) {
-            return resolveBuiltin(ctx, node, typeName, scope);
+            return resolveBuiltin(
+              ctx,
+              node,
+              typeName,
+              scope,
+              typeParameters
+            );
           } else if (typeName === "ReturnType" && node.typeParameters) {
             const ret = resolveReturnType(
               ctx,
@@ -45598,10 +45953,14 @@ function innerResolveTypeElements(ctx, node, scope) {
   }
   return ctx.error(`Unresolvable type: ${node.type}`, node, scope);
 }
-function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx)) {
+function typeElementsToMap(ctx, elements, scope = ctxToScope(ctx), typeParameters) {
   const res = { props: {} };
   for (const e of elements) {
     if (e.type === "TSPropertySignature" || e.type === "TSMethodSignature") {
+      if (typeParameters) {
+        scope = createChildScope(scope);
+        Object.assign(scope.types, typeParameters);
+      }
       e._ownerScope = scope;
       const name = getId(e.key);
       if (name && !e.computed) {
@@ -45664,8 +46023,13 @@ function createProperty(key, typeAnnotation, scope, optional) {
     _ownerScope: scope
   };
 }
-function resolveInterfaceMembers(ctx, node, scope) {
-  const base = typeElementsToMap(ctx, node.body.body, node._ownerScope);
+function resolveInterfaceMembers(ctx, node, scope, typeParameters) {
+  const base = typeElementsToMap(
+    ctx,
+    node.body.body,
+    node._ownerScope,
+    typeParameters
+  );
   if (node.extends) {
     for (const ext of node.extends) {
       if (ext.leadingComments && ext.leadingComments.some((c) => c.value.includes("@vue-ignore"))) {
@@ -45839,8 +46203,13 @@ const SupportedBuiltinsSet = /* @__PURE__ */ new Set([
   "Pick",
   "Omit"
 ]);
-function resolveBuiltin(ctx, node, name, scope) {
-  const t = resolveTypeElements(ctx, node.typeParameters.params[0], scope);
+function resolveBuiltin(ctx, node, name, scope, typeParameters) {
+  const t = resolveTypeElements(
+    ctx,
+    node.typeParameters.params[0],
+    scope,
+    typeParameters
+  );
   switch (name) {
     case "Partial": {
       const res2 = { props: {}, calls: t.calls };
@@ -45968,7 +46337,21 @@ function resolveGlobalScope(ctx) {
 let ts;
 let loadTS;
 function registerTS(_loadTS) {
-  loadTS = _loadTS;
+  loadTS = () => {
+    try {
+      return _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.'
+        );
+      } else {
+        throw new Error(
+          "Failed to load TypeScript for resolving imported types."
+        );
+      }
+    }
+  };
 }
 function resolveFS(ctx) {
   if (ctx.fs) {
@@ -46002,7 +46385,12 @@ function resolveTypeFromImport(ctx, node, name, scope) {
   return resolveTypeReference(ctx, node, sourceScope, imported, true);
 }
 function importSourceToScope(ctx, node, scope, source) {
-  const fs = resolveFS(ctx);
+  let fs;
+  try {
+    fs = resolveFS(ctx);
+  } catch (err) {
+    return ctx.error(err.message, node, scope);
+  }
   if (!fs) {
     return ctx.error(
       `No fs option provided to \`compileScript\` in non-Node environment. File system access is required for resolving imported types.`,
@@ -46127,14 +46515,7 @@ function moduleDeclToScope(ctx, node, parentScope) {
   if (node._resolvedChildScope) {
     return node._resolvedChildScope;
   }
-  const scope = new TypeScope(
-    parentScope.filename,
-    parentScope.source,
-    parentScope.offset,
-    Object.create(parentScope.imports),
-    Object.create(parentScope.types),
-    Object.create(parentScope.declares)
-  );
+  const scope = createChildScope(parentScope);
   if (node.body.type === "TSModuleDeclaration") {
     const decl = node.body;
     decl._ownerScope = scope;
@@ -46145,6 +46526,16 @@ function moduleDeclToScope(ctx, node, parentScope) {
   }
   return node._resolvedChildScope = scope;
 }
+function createChildScope(parentScope) {
+  return new TypeScope(
+    parentScope.filename,
+    parentScope.source,
+    parentScope.offset,
+    Object.create(parentScope.imports),
+    Object.create(parentScope.types),
+    Object.create(parentScope.declares)
+  );
+}
 const importExportRE = /^Import|^Export/;
 function recordTypes(ctx, body, scope, asGlobal = false) {
   const { types, declares, exportedTypes, exportedDeclares, imports } = scope;
@@ -46266,7 +46657,7 @@ function recordType(node, types, declares, overwriteId) {
         types[overwriteId || getId(node.id)] = node;
       break;
     case "TSTypeAliasDeclaration":
-      types[node.id.name] = node.typeAnnotation;
+      types[node.id.name] = node.typeParameters ? node : node.typeAnnotation;
       break;
     case "TSDeclareFunction":
       if (node.id)
@@ -46806,7 +47197,7 @@ function genRuntimeProps(ctx) {
           );
       }
       if (defaults.length) {
-        propsDecls = `${ctx.helper(
+        propsDecls = `/*#__PURE__*/${ctx.helper(
           `mergeDefaults`
         )}(${propsDecls}, {
   ${defaults.join(",\n  ")}
@@ -46818,7 +47209,9 @@ function genRuntimeProps(ctx) {
   }
   const modelsDecls = genModelProps(ctx);
   if (propsDecls && modelsDecls) {
-    return `${ctx.helper("mergeModels")}(${propsDecls}, ${modelsDecls})`;
+    return `/*#__PURE__*/${ctx.helper(
+      "mergeModels"
+    )}(${propsDecls}, ${modelsDecls})`;
   } else {
     return modelsDecls || propsDecls;
   }
@@ -46840,9 +47233,9 @@ function extractRuntimeProps(ctx) {
     ${propStrings.join(",\n    ")}
   }`;
   if (ctx.propsRuntimeDefaults && !hasStaticDefaults) {
-    propsDecls = `${ctx.helper("mergeDefaults")}(${propsDecls}, ${ctx.getString(
-      ctx.propsRuntimeDefaults
-    )})`;
+    propsDecls = `/*#__PURE__*/${ctx.helper(
+      "mergeDefaults"
+    )}(${propsDecls}, ${ctx.getString(ctx.propsRuntimeDefaults)})`;
   }
   return propsDecls;
 }
@@ -47060,7 +47453,7 @@ function transformDestructuredProps(ctx, vueImportAliases) {
     }
     for (const decl of stmt.declarations) {
       const isDefineProps = isRoot && decl.init && isCallOf(unwrapTSNode(decl.init), "defineProps");
-      for (const id of extractIdentifiers(decl.id)) {
+      for (const id of extractIdentifiers$1(decl.id)) {
         if (isDefineProps) {
           excludedIds.add(id);
         } else {
@@ -47179,7 +47572,9 @@ function genRuntimeEmits(ctx) {
   }
   if (ctx.hasDefineModelCall) {
     let modelEmitsDecl = `[${Object.keys(ctx.modelDecls).map((n) => JSON.stringify(`update:${n}`)).join(", ")}]`;
-    emitsDecl = emitsDecl ? `${ctx.helper("mergeModels")}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
+    emitsDecl = emitsDecl ? `/*#__PURE__*/${ctx.helper(
+      "mergeModels"
+    )}(${emitsDecl}, ${modelEmitsDecl})` : modelEmitsDecl;
   }
   return emitsDecl;
 }
@@ -48131,9 +48526,9 @@ function isStaticNode(node) {
   return false;
 }
 
-const version = "3.4.0-alpha.2";
+const version = "3.4.0-alpha.4";
 const parseCache = parseCache$1;
 const walk = walk$1;
 const shouldTransformRef = () => false;
 
-export { MagicString, parse_1$1 as babelParse, compileScript, compileStyle, compileStyleAsync, compileTemplate, extractIdentifiers, extractRuntimeEmits, extractRuntimeProps, generateCodeFrame, inferRuntimeType, invalidateTypeCache, isInDestructureAssignment, isStaticProperty, parse$7 as parse, parseCache, registerTS, resolveTypeElements, rewriteDefault, rewriteDefaultAST, shouldTransformRef, version, walk, walkIdentifiers };
+export { MagicString, parse_1$1 as babelParse, compileScript, compileStyle, compileStyleAsync, compileTemplate, extractIdentifiers$1 as extractIdentifiers, extractRuntimeEmits, extractRuntimeProps, generateCodeFrame, inferRuntimeType, invalidateTypeCache, isInDestructureAssignment, isStaticProperty, parse$7 as parse, parseCache, registerTS, resolveTypeElements, rewriteDefault, rewriteDefaultAST, shouldTransformRef, version, walk, walkIdentifiers };