@vue/compiler-core 3.4.0-alpha.4 → 3.4.0-beta.1

package/dist/compiler-core.cjs.js

@@ -5,8 +5,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var shared = require('@vue/shared');
 var decode_js = require('entities/lib/decode.js');
 var parser = require('@babel/parser');
-var sourceMapJs = require('source-map-js');
 var estreeWalker = require('estree-walker');
+var sourceMapJs = require('source-map-js');
 
 const FRAGMENT = Symbol(`Fragment` );
 const TELEPORT = Symbol(`Teleport` );
@@ -1424,16 +1424,16 @@ const ErrorCodes = {
   "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",
+  "X_PREFIX_ID_NOT_SUPPORTED": 47,
+  "47": "X_PREFIX_ID_NOT_SUPPORTED",
+  "X_MODULE_MODE_NOT_SUPPORTED": 48,
+  "48": "X_MODULE_MODE_NOT_SUPPORTED",
+  "X_CACHE_HANDLER_NOT_SUPPORTED": 49,
+  "49": "X_CACHE_HANDLER_NOT_SUPPORTED",
+  "X_SCOPE_ID_NOT_SUPPORTED": 50,
+  "50": "X_SCOPE_ID_NOT_SUPPORTED",
+  "X_VNODE_HOOKS": 51,
+  "51": "X_VNODE_HOOKS",
   "__EXTEND_POINT__": 52,
   "52": "__EXTEND_POINT__"
 };
@@ -1489,16 +1489,281 @@ 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.`,
+  [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.`,
   // generic errors
-  [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.`,
+  [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.`,
   // just to fulfill types
   [52]: ``
 };
 
+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 : root;
+  estreeWalker.walk(root, {
+    enter(node, parent) {
+      parent && parentStack.push(parent);
+      if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
+        return this.skip();
+      }
+      if (node.type === "Identifier") {
+        const isLocal = !!knownIds[node.name];
+        const isRefed = isReferencedIdentifier(node, parent, parentStack);
+        if (includeAll || isRefed && !isLocal) {
+          onIdentifier(node, parent, parentStack, isRefed, isLocal);
+        }
+      } else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
+        node.inPattern = true;
+      } else if (isFunctionType(node)) {
+        walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
+      } else if (node.type === "BlockStatement") {
+        walkBlockDeclarations(
+          node,
+          (id) => markScopeIdentifier(node, id, knownIds)
+        );
+      }
+    },
+    leave(node, parent) {
+      parent && parentStack.pop();
+      if (node !== rootExp && node.scopeIds) {
+        for (const id of node.scopeIds) {
+          knownIds[id]--;
+          if (knownIds[id] === 0) {
+            delete knownIds[id];
+          }
+        }
+      }
+    }
+  });
+}
+function isReferencedIdentifier(id, parent, parentStack) {
+  if (!parent) {
+    return true;
+  }
+  if (id.name === "arguments") {
+    return false;
+  }
+  if (isReferenced(id, parent)) {
+    return true;
+  }
+  switch (parent.type) {
+    case "AssignmentExpression":
+    case "AssignmentPattern":
+      return true;
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return isInDestructureAssignment(parent, parentStack);
+  }
+  return false;
+}
+function isInDestructureAssignment(parent, parentStack) {
+  if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
+    let i = parentStack.length;
+    while (i--) {
+      const p = parentStack[i];
+      if (p.type === "AssignmentExpression") {
+        return true;
+      } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
+        break;
+      }
+    }
+  }
+  return false;
+}
+function walkFunctionParams(node, onIdent) {
+  for (const p of node.params) {
+    for (const id of extractIdentifiers(p)) {
+      onIdent(id);
+    }
+  }
+}
+function walkBlockDeclarations(block, onIdent) {
+  for (const stmt of block.body) {
+    if (stmt.type === "VariableDeclaration") {
+      if (stmt.declare)
+        continue;
+      for (const decl of stmt.declarations) {
+        for (const id of extractIdentifiers(decl.id)) {
+          onIdent(id);
+        }
+      }
+    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
+      if (stmt.declare || !stmt.id)
+        continue;
+      onIdent(stmt.id);
+    } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
+      const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
+      if (variable && variable.type === "VariableDeclaration") {
+        for (const decl of variable.declarations) {
+          for (const id of extractIdentifiers(decl.id)) {
+            onIdent(id);
+          }
+        }
+      }
+    }
+  }
+}
+function extractIdentifiers(param, nodes = []) {
+  switch (param.type) {
+    case "Identifier":
+      nodes.push(param);
+      break;
+    case "MemberExpression":
+      let object = param;
+      while (object.type === "MemberExpression") {
+        object = object.object;
+      }
+      nodes.push(object);
+      break;
+    case "ObjectPattern":
+      for (const prop of param.properties) {
+        if (prop.type === "RestElement") {
+          extractIdentifiers(prop.argument, nodes);
+        } else {
+          extractIdentifiers(prop.value, nodes);
+        }
+      }
+      break;
+    case "ArrayPattern":
+      param.elements.forEach((element) => {
+        if (element)
+          extractIdentifiers(element, nodes);
+      });
+      break;
+    case "RestElement":
+      extractIdentifiers(param.argument, nodes);
+      break;
+    case "AssignmentPattern":
+      extractIdentifiers(param.left, nodes);
+      break;
+  }
+  return nodes;
+}
+function markScopeIdentifier(node, child, knownIds) {
+  const { name } = child;
+  if (node.scopeIds && node.scopeIds.has(name)) {
+    return;
+  }
+  if (name in knownIds) {
+    knownIds[name]++;
+  } else {
+    knownIds[name] = 1;
+  }
+  (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
+}
+const isFunctionType = (node) => {
+  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
+};
+const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
+const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
+function isReferenced(node, parent, grandparent) {
+  switch (parent.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      if (parent.property === node) {
+        return !!parent.computed;
+      }
+      return parent.object === node;
+    case "JSXMemberExpression":
+      return parent.object === node;
+    case "VariableDeclarator":
+      return parent.init === node;
+    case "ArrowFunctionExpression":
+      return parent.body === node;
+    case "PrivateName":
+      return false;
+    case "ClassMethod":
+    case "ClassPrivateMethod":
+    case "ObjectMethod":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return false;
+    case "ObjectProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return !grandparent || grandparent.type !== "ObjectPattern";
+    case "ClassProperty":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return true;
+    case "ClassPrivateProperty":
+      return parent.key !== node;
+    case "ClassDeclaration":
+    case "ClassExpression":
+      return parent.superClass === node;
+    case "AssignmentExpression":
+      return parent.right === node;
+    case "AssignmentPattern":
+      return parent.right === node;
+    case "LabeledStatement":
+      return false;
+    case "CatchClause":
+      return false;
+    case "RestElement":
+      return false;
+    case "BreakStatement":
+    case "ContinueStatement":
+      return false;
+    case "FunctionDeclaration":
+    case "FunctionExpression":
+      return false;
+    case "ExportNamespaceSpecifier":
+    case "ExportDefaultSpecifier":
+      return false;
+    case "ExportSpecifier":
+      if (grandparent == null ? void 0 : grandparent.source) {
+        return false;
+      }
+      return parent.local === node;
+    case "ImportDefaultSpecifier":
+    case "ImportNamespaceSpecifier":
+    case "ImportSpecifier":
+      return false;
+    case "ImportAttribute":
+      return false;
+    case "JSXAttribute":
+      return false;
+    case "ObjectPattern":
+    case "ArrayPattern":
+      return false;
+    case "MetaProperty":
+      return false;
+    case "ObjectTypeProperty":
+      return parent.key !== node;
+    case "TSEnumMember":
+      return parent.id !== node;
+    case "TSPropertySignature":
+      if (parent.key === node) {
+        return !!parent.computed;
+      }
+      return true;
+  }
+  return true;
+}
+const TS_NODE_TYPES = [
+  "TSAsExpression",
+  // foo as number
+  "TSTypeAssertion",
+  // (<number>foo)
+  "TSNonNullExpression",
+  // foo!
+  "TSInstantiationExpression",
+  // foo<string>
+  "TSSatisfiesExpression"
+  // foo satisfies T
+];
+function unwrapTSNode(node) {
+  if (TS_NODE_TYPES.includes(node.type)) {
+    return unwrapTSNode(node.expression);
+  } else {
+    return node;
+  }
+}
+
 const isStaticExp = (p) => p.type === 4 && p.isStatic;
 function isCoreComponent(tag) {
   switch (tag) {
@@ -1588,9 +1853,7 @@ const isMemberExpressionNode = (path, context) => {
     let ret = parser.parseExpression(path, {
       plugins: context.expressionPlugins
     });
-    if (ret.type === "TSAsExpression" || ret.type === "TSTypeAssertion") {
-      ret = ret.expression;
-    }
+    ret = unwrapTSNode(ret);
     return ret.type === "MemberExpression" || ret.type === "OptionalMemberExpression" || ret.type === "Identifier";
   } catch (e) {
     return false;
@@ -2852,6 +3115,7 @@ function createTransformContext(root, {
   const nameMatch = filename.replace(/\?.*$/, "").match(/([^/\\]+)\.\w+$/);
   const context = {
     // options
+    filename,
     selfName: nameMatch && shared.capitalize(shared.camelize(nameMatch[1])),
     prefixIdentifiers,
     hoistStatic: hoistStatic2,
@@ -3850,338 +4114,80 @@ function genCacheExpression(node, context) {
     push(`${helper(SET_BLOCK_TRACKING)}(-1),`);
     newline();
   }
-  push(`_cache[${node.index}] = `);
-  genNode(node.value, context);
-  if (node.isVNode) {
-    push(`,`);
-    newline();
-    push(`${helper(SET_BLOCK_TRACKING)}(1),`);
-    newline();
-    push(`_cache[${node.index}]`);
-    deindent();
-  }
-  push(`)`);
-}
-function genTemplateLiteral(node, context) {
-  const { push, indent, deindent } = context;
-  push("`");
-  const l = node.elements.length;
-  const multilines = l > 3;
-  for (let i = 0; i < l; i++) {
-    const e = node.elements[i];
-    if (shared.isString(e)) {
-      push(e.replace(/(`|\$|\\)/g, "\\$1"), -3 /* Unknown */);
-    } else {
-      push("${");
-      if (multilines)
-        indent();
-      genNode(e, context);
-      if (multilines)
-        deindent();
-      push("}");
-    }
-  }
-  push("`");
-}
-function genIfStatement(node, context) {
-  const { push, indent, deindent } = context;
-  const { test, consequent, alternate } = node;
-  push(`if (`);
-  genNode(test, context);
-  push(`) {`);
-  indent();
-  genNode(consequent, context);
-  deindent();
-  push(`}`);
-  if (alternate) {
-    push(` else `);
-    if (alternate.type === 23) {
-      genIfStatement(alternate, context);
-    } else {
-      push(`{`);
-      indent();
-      genNode(alternate, context);
-      deindent();
-      push(`}`);
-    }
-  }
-}
-function genAssignmentExpression(node, context) {
-  genNode(node.left, context);
-  context.push(` = `);
-  genNode(node.right, context);
-}
-function genSequenceExpression(node, context) {
-  context.push(`(`);
-  genNodeList(node.expressions, context);
-  context.push(`)`);
-}
-function genReturnStatement({ returns }, context) {
-  context.push(`return `);
-  if (shared.isArray(returns)) {
-    genNodeListAsArray(returns, context);
-  } else {
-    genNode(returns, context);
-  }
-}
-
-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 : root;
-  estreeWalker.walk(root, {
-    enter(node, parent) {
-      parent && parentStack.push(parent);
-      if (parent && parent.type.startsWith("TS") && !TS_NODE_TYPES.includes(parent.type)) {
-        return this.skip();
-      }
-      if (node.type === "Identifier") {
-        const isLocal = !!knownIds[node.name];
-        const isRefed = isReferencedIdentifier(node, parent, parentStack);
-        if (includeAll || isRefed && !isLocal) {
-          onIdentifier(node, parent, parentStack, isRefed, isLocal);
-        }
-      } else if (node.type === "ObjectProperty" && parent.type === "ObjectPattern") {
-        node.inPattern = true;
-      } else if (isFunctionType(node)) {
-        walkFunctionParams(node, (id) => markScopeIdentifier(node, id, knownIds));
-      } else if (node.type === "BlockStatement") {
-        walkBlockDeclarations(
-          node,
-          (id) => markScopeIdentifier(node, id, knownIds)
-        );
-      }
-    },
-    leave(node, parent) {
-      parent && parentStack.pop();
-      if (node !== rootExp && node.scopeIds) {
-        for (const id of node.scopeIds) {
-          knownIds[id]--;
-          if (knownIds[id] === 0) {
-            delete knownIds[id];
-          }
-        }
-      }
-    }
-  });
-}
-function isReferencedIdentifier(id, parent, parentStack) {
-  if (!parent) {
-    return true;
-  }
-  if (id.name === "arguments") {
-    return false;
-  }
-  if (isReferenced(id, parent)) {
-    return true;
-  }
-  switch (parent.type) {
-    case "AssignmentExpression":
-    case "AssignmentPattern":
-      return true;
-    case "ObjectPattern":
-    case "ArrayPattern":
-      return isInDestructureAssignment(parent, parentStack);
+  push(`_cache[${node.index}] = `);
+  genNode(node.value, context);
+  if (node.isVNode) {
+    push(`,`);
+    newline();
+    push(`${helper(SET_BLOCK_TRACKING)}(1),`);
+    newline();
+    push(`_cache[${node.index}]`);
+    deindent();
   }
-  return false;
+  push(`)`);
 }
-function isInDestructureAssignment(parent, parentStack) {
-  if (parent && (parent.type === "ObjectProperty" || parent.type === "ArrayPattern")) {
-    let i = parentStack.length;
-    while (i--) {
-      const p = parentStack[i];
-      if (p.type === "AssignmentExpression") {
-        return true;
-      } else if (p.type !== "ObjectProperty" && !p.type.endsWith("Pattern")) {
-        break;
-      }
+function genTemplateLiteral(node, context) {
+  const { push, indent, deindent } = context;
+  push("`");
+  const l = node.elements.length;
+  const multilines = l > 3;
+  for (let i = 0; i < l; i++) {
+    const e = node.elements[i];
+    if (shared.isString(e)) {
+      push(e.replace(/(`|\$|\\)/g, "\\$1"), -3 /* Unknown */);
+    } else {
+      push("${");
+      if (multilines)
+        indent();
+      genNode(e, context);
+      if (multilines)
+        deindent();
+      push("}");
     }
   }
-  return false;
+  push("`");
 }
-function walkFunctionParams(node, onIdent) {
-  for (const p of node.params) {
-    for (const id of extractIdentifiers(p)) {
-      onIdent(id);
+function genIfStatement(node, context) {
+  const { push, indent, deindent } = context;
+  const { test, consequent, alternate } = node;
+  push(`if (`);
+  genNode(test, context);
+  push(`) {`);
+  indent();
+  genNode(consequent, context);
+  deindent();
+  push(`}`);
+  if (alternate) {
+    push(` else `);
+    if (alternate.type === 23) {
+      genIfStatement(alternate, context);
+    } else {
+      push(`{`);
+      indent();
+      genNode(alternate, context);
+      deindent();
+      push(`}`);
     }
   }
 }
-function walkBlockDeclarations(block, onIdent) {
-  for (const stmt of block.body) {
-    if (stmt.type === "VariableDeclaration") {
-      if (stmt.declare)
-        continue;
-      for (const decl of stmt.declarations) {
-        for (const id of extractIdentifiers(decl.id)) {
-          onIdent(id);
-        }
-      }
-    } else if (stmt.type === "FunctionDeclaration" || stmt.type === "ClassDeclaration") {
-      if (stmt.declare || !stmt.id)
-        continue;
-      onIdent(stmt.id);
-    } else if (stmt.type === "ForOfStatement" || stmt.type === "ForInStatement" || stmt.type === "ForStatement") {
-      const variable = stmt.type === "ForStatement" ? stmt.init : stmt.left;
-      if (variable && variable.type === "VariableDeclaration") {
-        for (const decl of variable.declarations) {
-          for (const id of extractIdentifiers(decl.id)) {
-            onIdent(id);
-          }
-        }
-      }
-    }
-  }
+function genAssignmentExpression(node, context) {
+  genNode(node.left, context);
+  context.push(` = `);
+  genNode(node.right, context);
 }
-function extractIdentifiers(param, nodes = []) {
-  switch (param.type) {
-    case "Identifier":
-      nodes.push(param);
-      break;
-    case "MemberExpression":
-      let object = param;
-      while (object.type === "MemberExpression") {
-        object = object.object;
-      }
-      nodes.push(object);
-      break;
-    case "ObjectPattern":
-      for (const prop of param.properties) {
-        if (prop.type === "RestElement") {
-          extractIdentifiers(prop.argument, nodes);
-        } else {
-          extractIdentifiers(prop.value, nodes);
-        }
-      }
-      break;
-    case "ArrayPattern":
-      param.elements.forEach((element) => {
-        if (element)
-          extractIdentifiers(element, nodes);
-      });
-      break;
-    case "RestElement":
-      extractIdentifiers(param.argument, nodes);
-      break;
-    case "AssignmentPattern":
-      extractIdentifiers(param.left, nodes);
-      break;
-  }
-  return nodes;
+function genSequenceExpression(node, context) {
+  context.push(`(`);
+  genNodeList(node.expressions, context);
+  context.push(`)`);
 }
-function markScopeIdentifier(node, child, knownIds) {
-  const { name } = child;
-  if (node.scopeIds && node.scopeIds.has(name)) {
-    return;
-  }
-  if (name in knownIds) {
-    knownIds[name]++;
+function genReturnStatement({ returns }, context) {
+  context.push(`return `);
+  if (shared.isArray(returns)) {
+    genNodeListAsArray(returns, context);
   } else {
-    knownIds[name] = 1;
-  }
-  (node.scopeIds || (node.scopeIds = /* @__PURE__ */ new Set())).add(name);
-}
-const isFunctionType = (node) => {
-  return /Function(?:Expression|Declaration)$|Method$/.test(node.type);
-};
-const isStaticProperty = (node) => node && (node.type === "ObjectProperty" || node.type === "ObjectMethod") && !node.computed;
-const isStaticPropertyKey = (node, parent) => isStaticProperty(parent) && parent.key === node;
-function isReferenced(node, parent, grandparent) {
-  switch (parent.type) {
-    case "MemberExpression":
-    case "OptionalMemberExpression":
-      if (parent.property === node) {
-        return !!parent.computed;
-      }
-      return parent.object === node;
-    case "JSXMemberExpression":
-      return parent.object === node;
-    case "VariableDeclarator":
-      return parent.init === node;
-    case "ArrowFunctionExpression":
-      return parent.body === node;
-    case "PrivateName":
-      return false;
-    case "ClassMethod":
-    case "ClassPrivateMethod":
-    case "ObjectMethod":
-      if (parent.key === node) {
-        return !!parent.computed;
-      }
-      return false;
-    case "ObjectProperty":
-      if (parent.key === node) {
-        return !!parent.computed;
-      }
-      return !grandparent || grandparent.type !== "ObjectPattern";
-    case "ClassProperty":
-      if (parent.key === node) {
-        return !!parent.computed;
-      }
-      return true;
-    case "ClassPrivateProperty":
-      return parent.key !== node;
-    case "ClassDeclaration":
-    case "ClassExpression":
-      return parent.superClass === node;
-    case "AssignmentExpression":
-      return parent.right === node;
-    case "AssignmentPattern":
-      return parent.right === node;
-    case "LabeledStatement":
-      return false;
-    case "CatchClause":
-      return false;
-    case "RestElement":
-      return false;
-    case "BreakStatement":
-    case "ContinueStatement":
-      return false;
-    case "FunctionDeclaration":
-    case "FunctionExpression":
-      return false;
-    case "ExportNamespaceSpecifier":
-    case "ExportDefaultSpecifier":
-      return false;
-    case "ExportSpecifier":
-      if (grandparent == null ? void 0 : grandparent.source) {
-        return false;
-      }
-      return parent.local === node;
-    case "ImportDefaultSpecifier":
-    case "ImportNamespaceSpecifier":
-    case "ImportSpecifier":
-      return false;
-    case "ImportAttribute":
-      return false;
-    case "JSXAttribute":
-      return false;
-    case "ObjectPattern":
-    case "ArrayPattern":
-      return false;
-    case "MetaProperty":
-      return false;
-    case "ObjectTypeProperty":
-      return parent.key !== node;
-    case "TSEnumMember":
-      return parent.id !== node;
-    case "TSPropertySignature":
-      if (parent.key === node) {
-        return !!parent.computed;
-      }
-      return true;
+    genNode(returns, context);
   }
-  return true;
 }
-const TS_NODE_TYPES = [
-  "TSAsExpression",
-  // foo as number
-  "TSTypeAssertion",
-  // (<number>foo)
-  "TSNonNullExpression",
-  // foo!
-  "TSInstantiationExpression",
-  // foo<string>
-  "TSSatisfiesExpression"
-  // foo satisfies T
-];
 
 const isLiteralWhitelisted = /* @__PURE__ */ shared.makeMap("true,false,null,this");
 const constantBailRE = /\w\s*\(|\.[^\d]/;
@@ -5850,7 +5856,7 @@ const transformOn = (dir, node, context, augmentor) => {
     if (arg.isStatic) {
       let rawName = arg.content;
       if (rawName.startsWith("vnode")) {
-        context.onError(createCompilerError(47, arg.loc));
+        context.onError(createCompilerError(51, arg.loc));
       }
       if (rawName.startsWith("vue:")) {
         rawName = `vnode-${rawName.slice(4)}`;
@@ -6384,12 +6390,15 @@ function baseCompile(source, options = {}) {
   const isModuleMode = options.mode === "module";
   const prefixIdentifiers = options.prefixIdentifiers === true || isModuleMode;
   if (!prefixIdentifiers && options.cacheHandlers) {
-    onError(createCompilerError(50));
+    onError(createCompilerError(49));
   }
   if (options.scopeId && !isModuleMode) {
-    onError(createCompilerError(51));
+    onError(createCompilerError(50));
   }
-  const ast = shared.isString(source) ? baseParse(source, options) : source;
+  const resolvedOptions = shared.extend({}, options, {
+    prefixIdentifiers
+  });
+  const ast = shared.isString(source) ? baseParse(source, resolvedOptions) : source;
   const [nodeTransforms, directiveTransforms] = getBaseTransformPreset(prefixIdentifiers);
   if (options.isTS) {
     const { expressionPlugins } = options;
@@ -6399,8 +6408,7 @@ function baseCompile(source, options = {}) {
   }
   transform(
     ast,
-    shared.extend({}, options, {
-      prefixIdentifiers,
+    shared.extend({}, resolvedOptions, {
       nodeTransforms: [
         ...nodeTransforms,
         ...options.nodeTransforms || []
@@ -6414,12 +6422,7 @@ function baseCompile(source, options = {}) {
       )
     })
   );
-  return generate(
-    ast,
-    shared.extend({}, options, {
-      prefixIdentifiers
-    })
-  );
+  return generate(ast, resolvedOptions);
 }
 
 const BindingTypes = {
@@ -6567,6 +6570,7 @@ exports.transformExpression = transformExpression;
 exports.transformModel = transformModel;
 exports.transformOn = transformOn;
 exports.traverseNode = traverseNode;
+exports.unwrapTSNode = unwrapTSNode;
 exports.walkBlockDeclarations = walkBlockDeclarations;
 exports.walkFunctionParams = walkFunctionParams;
 exports.walkIdentifiers = walkIdentifiers;