@typescript-deploys/pr-build 5.5.0-pr-57717-2 → 5.5.0-pr-57749-2

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.5";
-var version = `${versionMajorMinor}.0-insiders.20240311`;
+var version = `${versionMajorMinor}.0-insiders.20240312`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -6096,6 +6096,8 @@ var Diagnostics = {
   The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration: diag(1494, 1 /* Error */, "The_left_hand_side_of_a_for_in_statement_cannot_be_an_await_using_declaration_1494", "The left-hand side of a 'for...in' statement cannot be an 'await using' declaration."),
   _0_modifier_cannot_appear_on_an_await_using_declaration: diag(1495, 1 /* Error */, "_0_modifier_cannot_appear_on_an_await_using_declaration_1495", "'{0}' modifier cannot appear on an 'await using' declaration."),
   Identifier_string_literal_or_number_literal_expected: diag(1496, 1 /* Error */, "Identifier_string_literal_or_number_literal_expected_1496", "Identifier, string literal, or number literal expected."),
+  Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator: diag(1497, 1 /* Error */, "Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator_1497", "Expression must be enclosed in parentheses to be used as a decorator."),
+  Invalid_syntax_in_decorator: diag(1498, 1 /* Error */, "Invalid_syntax_in_decorator_1498", "Invalid syntax in decorator."),
   The_types_of_0_are_incompatible_between_these_types: diag(2200, 1 /* Error */, "The_types_of_0_are_incompatible_between_these_types_2200", "The types of '{0}' are incompatible between these types."),
   The_types_returned_by_0_are_incompatible_between_these_types: diag(2201, 1 /* Error */, "The_types_returned_by_0_are_incompatible_between_these_types_2201", "The types returned by '{0}' are incompatible between these types."),
   Call_signature_return_types_0_and_1_are_incompatible: diag(
@@ -7743,6 +7745,8 @@ var Diagnostics = {
   Add_optional_parameter_to_0: diag(95191, 3 /* Message */, "Add_optional_parameter_to_0_95191", "Add optional parameter to '{0}'"),
   Add_optional_parameters_to_0: diag(95192, 3 /* Message */, "Add_optional_parameters_to_0_95192", "Add optional parameters to '{0}'"),
   Add_all_optional_parameters: diag(95193, 3 /* Message */, "Add_all_optional_parameters_95193", "Add all optional parameters"),
+  Wrap_in_parentheses: diag(95194, 3 /* Message */, "Wrap_in_parentheses_95194", "Wrap in parentheses"),
+  Wrap_all_invalid_decorator_expressions_in_parentheses: diag(95195, 3 /* Message */, "Wrap_all_invalid_decorator_expressions_in_parentheses_95195", "Wrap all invalid decorator expressions in parentheses"),
   No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer: diag(18004, 1 /* Error */, "No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer_18004", "No value exists in scope for the shorthand property '{0}'. Either declare one or provide an initializer."),
   Classes_may_not_have_a_field_named_constructor: diag(18006, 1 /* Error */, "Classes_may_not_have_a_field_named_constructor_18006", "Classes may not have a field named 'constructor'."),
   JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array: diag(18007, 1 /* Error */, "JSX_expressions_may_not_use_the_comma_operator_Did_you_mean_to_write_an_array_18007", "JSX expressions may not use the comma operator. Did you mean to write an array?"),
@@ -17570,7 +17574,7 @@ function canUsePropertyAccess(name, languageVersion) {
 }
 function isJSDocOptionalParameter(node) {
   return isInJSFile(node) && // node.type should only be a JSDocOptionalType when node is a parameter of a JSDocFunctionType
-  (node.type && node.type.kind === 316 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(({ isBracketed, typeExpression }) => isBracketed || !!typeExpression && typeExpression.type.kind === 316 /* JSDocOptionalType */));
+  (node.type && node.type.kind === 316 /* JSDocOptionalType */ || getJSDocParameterTags(node).some(isOptionalJSDocPropertyLikeTag));
 }
 function isOptionalDeclaration(declaration) {
   switch (declaration.kind) {
@@ -44179,8 +44183,6 @@ function createTypeChecker(host) {
   var comparableRelation = /* @__PURE__ */ new Map();
   var identityRelation = /* @__PURE__ */ new Map();
   var enumRelation = /* @__PURE__ */ new Map();
-  var builtinGlobals = createSymbolTable();
-  builtinGlobals.set(undefinedSymbol.escapedName, undefinedSymbol);
   var suggestedExtensions = [
     [".mts", ".mjs"],
     [".ts", ".js"],
@@ -44598,17 +44600,17 @@ function createTypeChecker(host) {
       }
     }
   }
-  function addToSymbolTable(target, source, message) {
-    source.forEach((sourceSymbol, id) => {
-      const targetSymbol = target.get(id);
-      if (targetSymbol) {
-        forEach(targetSymbol.declarations, addDeclarationDiagnostic(unescapeLeadingUnderscores(id), message));
-      } else {
-        target.set(id, sourceSymbol);
-      }
-    });
-    function addDeclarationDiagnostic(id, message2) {
-      return (declaration) => diagnostics.add(createDiagnosticForNode(declaration, message2, id));
+  function addUndefinedToGlobalsOrErrorOnRedeclaration() {
+    const name = undefinedSymbol.escapedName;
+    const targetSymbol = globals.get(name);
+    if (targetSymbol) {
+      forEach(targetSymbol.declarations, (declaration) => {
+        if (!isTypeDeclaration(declaration)) {
+          diagnostics.add(createDiagnosticForNode(declaration, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0, unescapeLeadingUnderscores(name)));
+        }
+      });
+    } else {
+      globals.set(name, undefinedSymbol);
     }
   }
   function getSymbolLinks(symbol) {
@@ -44678,7 +44680,14 @@ function createTypeChecker(host) {
       } else if (declaration.kind === 260 /* VariableDeclaration */) {
         return !isImmediatelyUsedInInitializerOfBlockScopedVariable(declaration, usage);
       } else if (isClassLike(declaration)) {
-        return !findAncestor(usage, (n) => isComputedPropertyName(n) && n.parent.parent === declaration);
+        const container = findAncestor(usage, (n) => n === declaration ? "quit" : isComputedPropertyName(n) ? n.parent.parent === declaration : isDecorator(n) && (n.parent === declaration || isMethodDeclaration(n.parent) && n.parent.parent === declaration || isGetOrSetAccessorDeclaration(n.parent) && n.parent.parent === declaration || isPropertyDeclaration(n.parent) && n.parent.parent === declaration || isParameter(n.parent) && n.parent.parent.parent === declaration));
+        if (!container) {
+          return true;
+        }
+        if (isDecorator(container)) {
+          return !!findAncestor(usage, (n) => n === container ? "quit" : isFunctionLike(n) && !getImmediatelyInvokedFunctionExpression(n));
+        }
+        return false;
       } else if (isPropertyDeclaration(declaration)) {
         return !isPropertyImmediatelyReferencedWithinDeclaration(
           declaration,
@@ -53563,7 +53572,7 @@ function createTypeChecker(host) {
         if (!lateSymbol)
           lateSymbols.set(memberName, lateSymbol = createSymbol(0 /* None */, memberName, 4096 /* Late */));
         const earlySymbol = earlySymbols && earlySymbols.get(memberName);
-        if (!(parent.flags & 32 /* Class */) && lateSymbol.flags & getExcludedSymbolFlags(symbolFlags)) {
+        if (!(parent.flags & 32 /* Class */) && (lateSymbol.flags & getExcludedSymbolFlags(symbolFlags) || earlySymbol)) {
           const declarations = earlySymbol ? concatenate(earlySymbol.declarations, lateSymbol.declarations) : lateSymbol.declarations;
           const name = !(type.flags & 8192 /* UniqueESSymbol */) && unescapeLeadingUnderscores(memberName) || declarationNameToString(declName);
           forEach(declarations, (declaration) => error(getNameOfDeclaration(declaration) || declaration, Diagnostics.Property_0_was_also_declared_here, name));
@@ -55351,10 +55360,16 @@ function createTypeChecker(host) {
     const symbol = getSymbol(globals, '"' + moduleName + '"', 512 /* ValueModule */);
     return symbol && withAugmentations ? getMergedSymbol(symbol) : symbol;
   }
+  function hasEffectiveQuestionToken(node) {
+    return hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isParameter(node) && isJSDocOptionalParameter(node);
+  }
   function isOptionalParameter(node) {
-    if (hasQuestionToken(node) || isOptionalJSDocPropertyLikeTag(node) || isJSDocOptionalParameter(node)) {
+    if (hasEffectiveQuestionToken(node)) {
       return true;
     }
+    if (!isParameter(node)) {
+      return false;
+    }
     if (node.initializer) {
       const signature = getSignatureFromDeclaration(node.parent);
       const parameterIndex = node.parent.parameters.indexOf(node);
@@ -55454,7 +55469,7 @@ function createTypeChecker(host) {
         if (type && type.kind === 201 /* LiteralType */) {
           flags |= 2 /* HasLiteralTypes */;
         }
-        const isOptionalParameter2 = isOptionalJSDocPropertyLikeTag(param) || param.initializer || param.questionToken || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type || isJSDocOptionalParameter(param);
+        const isOptionalParameter2 = hasEffectiveQuestionToken(param) || isParameter(param) && param.initializer || isRestParameter(param) || iife && parameters.length > iife.arguments.length && !type;
         if (!isOptionalParameter2) {
           minArgumentCount = parameters.length;
         }
@@ -60572,7 +60587,7 @@ function createTypeChecker(host) {
     if (reduced !== type) {
       return reduced;
     }
-    if (type.flags & 2097152 /* Intersection */ && some(type.types, isEmptyAnonymousObjectType)) {
+    if (type.flags & 2097152 /* Intersection */ && shouldNormalizeIntersection(type)) {
       const normalizedTypes = sameMap(type.types, (t) => getNormalizedType(t, writing));
       if (normalizedTypes !== type.types) {
         return getIntersectionType(normalizedTypes);
@@ -60580,6 +60595,17 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function shouldNormalizeIntersection(type) {
+    let hasInstantiable = false;
+    let hasNullableOrEmpty = false;
+    for (const t of type.types) {
+      hasInstantiable || (hasInstantiable = !!(t.flags & 465829888 /* Instantiable */));
+      hasNullableOrEmpty || (hasNullableOrEmpty = !!(t.flags & 98304 /* Nullable */) || isEmptyAnonymousObjectType(t));
+      if (hasInstantiable && hasNullableOrEmpty)
+        return true;
+    }
+    return false;
+  }
   function getNormalizedTupleType(type, writing) {
     const elements = getElementTypes(type);
     const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
@@ -65430,9 +65456,9 @@ function createTypeChecker(host) {
     if (strictNullChecks) {
       switch (facts) {
         case 524288 /* NEUndefined */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 65536 /* EQUndefined */) ? getIntersectionType([t, hasTypeFacts(t, 131072 /* EQNull */) && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
+          return removeNullableByIntersection(reduced, 65536 /* EQUndefined */, 131072 /* EQNull */, 33554432 /* IsNull */, nullType);
         case 1048576 /* NENull */:
-          return mapType(reduced, (t) => hasTypeFacts(t, 131072 /* EQNull */) ? getIntersectionType([t, hasTypeFacts(t, 65536 /* EQUndefined */) && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
+          return removeNullableByIntersection(reduced, 131072 /* EQNull */, 65536 /* EQUndefined */, 16777216 /* IsUndefined */, undefinedType);
         case 2097152 /* NEUndefinedOrNull */:
         case 4194304 /* Truthy */:
           return mapType(reduced, (t) => hasTypeFacts(t, 262144 /* EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(t) : t);
@@ -65440,6 +65466,14 @@ function createTypeChecker(host) {
     }
     return reduced;
   }
+  function removeNullableByIntersection(type, targetFacts, otherFacts, otherIncludesFacts, otherType) {
+    const facts = getTypeFacts(type, 65536 /* EQUndefined */ | 131072 /* EQNull */ | 16777216 /* IsUndefined */ | 33554432 /* IsNull */);
+    if (!(facts & targetFacts)) {
+      return type;
+    }
+    const emptyAndOtherUnion = getUnionType([emptyObjectType, otherType]);
+    return mapType(type, (t) => hasTypeFacts(t, targetFacts) ? getIntersectionType([t, !(facts & otherIncludesFacts) && hasTypeFacts(t, otherFacts) ? emptyAndOtherUnion : emptyObjectType]) : t);
+  }
   function recombineUnknownType(type) {
     return type === unknownUnionType ? unknownType : type;
   }
@@ -69007,7 +69041,7 @@ function createTypeChecker(host) {
     }
   }
   function checkSpreadExpression(node, checkMode) {
-    if (languageVersion < 2 /* ES2015 */) {
+    if (languageVersion < 2 /* SpreadElements */) {
       checkExternalEmitHelpers(node, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
     }
     const arrayOrIterableType = checkExpression(node.expression, checkMode);
@@ -69041,7 +69075,7 @@ function createTypeChecker(host) {
     for (let i = 0; i < elementCount; i++) {
       const e = elements[i];
       if (e.kind === 230 /* SpreadElement */) {
-        if (languageVersion < 2 /* ES2015 */) {
+        if (languageVersion < 2 /* SpreadElements */) {
           checkExternalEmitHelpers(e, compilerOptions.downlevelIteration ? 1536 /* SpreadIncludes */ : 1024 /* SpreadArray */);
         }
         const spreadType = checkExpression(e.expression, checkMode, forceTuple);
@@ -69271,7 +69305,7 @@ function createTypeChecker(host) {
           addIntraExpressionInferenceSite(inferenceContext, inferenceNode, type);
         }
       } else if (memberDecl.kind === 305 /* SpreadAssignment */) {
-        if (languageVersion < 2 /* ES2015 */) {
+        if (languageVersion < 2 /* ObjectAssign */) {
           checkExternalEmitHelpers(memberDecl, 2 /* Assign */);
         }
         if (propertiesArray.length > 0) {
@@ -70296,7 +70330,7 @@ function createTypeChecker(host) {
     const isAnyLike = isTypeAny(apparentType) || apparentType === silentNeverType;
     let prop;
     if (isPrivateIdentifier(right)) {
-      if (languageVersion < 99 /* ESNext */) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
         if (assignmentKind !== 0 /* None */) {
           checkExternalEmitHelpers(node, 1048576 /* ClassPrivateFieldSet */);
         }
@@ -72123,7 +72157,7 @@ function createTypeChecker(host) {
       }
       return resolveErrorCall(node);
     }
-    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunctionOrConstructor)) {
+    if (checkMode & 8 /* SkipGenericFunctions */ && !node.typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
       skippedGenericFunction(node, checkMode);
       return resolvingSignature;
     }
@@ -72133,12 +72167,8 @@ function createTypeChecker(host) {
     }
     return resolveCall(node, callSignatures, candidatesOutArray, checkMode, callChainFlags);
   }
-  function isGenericFunctionReturningFunctionOrConstructor(signature) {
-    if (!signature.typeParameters) {
-      return false;
-    }
-    const returnType = getReturnTypeOfSignature(signature);
-    return isFunctionType(returnType) || isConstructorType(returnType);
+  function isGenericFunctionReturningFunction(signature) {
+    return !!(signature.typeParameters && isFunctionType(getReturnTypeOfSignature(signature)));
   }
   function isUntypedFunctionCall(funcType, apparentFuncType, numCallSignatures, numConstructSignatures) {
     return isTypeAny(funcType) || isTypeAny(apparentFuncType) && !!(funcType.flags & 262144 /* TypeParameter */) || !numCallSignatures && !numConstructSignatures && !(apparentFuncType.flags & 1048576 /* Union */) && !(getReducedType(apparentFuncType).flags & 131072 /* Never */) && isTypeAssignableTo(funcType, globalFunctionType);
@@ -72909,7 +72939,7 @@ function createTypeChecker(host) {
   function checkTaggedTemplateExpression(node) {
     if (!checkGrammarTaggedTemplateChain(node))
       checkGrammarTypeArguments(node, node.typeArguments);
-    if (languageVersion < 2 /* ES2015 */) {
+    if (languageVersion < 2 /* TaggedTemplates */) {
       checkExternalEmitHelpers(node, 262144 /* MakeTemplateObject */);
     }
     const signature = getResolvedSignature(node);
@@ -74556,7 +74586,7 @@ function createTypeChecker(host) {
       return silentNeverType;
     }
     if (isPrivateIdentifier(left)) {
-      if (languageVersion < 99 /* ESNext */) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
         checkExternalEmitHelpers(left, 2097152 /* ClassPrivateFieldIn */);
       }
       if (!getNodeLinks(left).resolvedSymbol && getContainingClass(left)) {
@@ -74617,7 +74647,7 @@ function createTypeChecker(host) {
       if (propertyIndex < properties.length - 1) {
         error(property, Diagnostics.A_rest_element_must_be_last_in_a_destructuring_pattern);
       } else {
-        if (languageVersion < 99 /* ESNext */) {
+        if (languageVersion < 5 /* ObjectSpreadRest */) {
           checkExternalEmitHelpers(property, 4 /* Rest */);
         }
         const nonRestNames = [];
@@ -74638,7 +74668,7 @@ function createTypeChecker(host) {
   }
   function checkArrayLiteralAssignment(node, sourceType, checkMode) {
     const elements = node.elements;
-    if (languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+    if (languageVersion < 2 /* DestructuringAssignment */ && compilerOptions.downlevelIteration) {
       checkExternalEmitHelpers(node, 512 /* Read */);
     }
     const possiblyOutOfBoundsType = checkIteratedTypeOrElementType(65 /* Destructuring */ | 128 /* PossiblyOutOfBounds */, sourceType, undefinedType, node) || errorType;
@@ -75340,10 +75370,10 @@ function createTypeChecker(host) {
     }
     const isAsync = (functionFlags & 2 /* Async */) !== 0;
     if (node.asteriskToken) {
-      if (isAsync && languageVersion < 99 /* ESNext */) {
+      if (isAsync && languageVersion < 5 /* AsyncGenerators */) {
         checkExternalEmitHelpers(node, 26624 /* AsyncDelegatorIncludes */);
       }
-      if (!isAsync && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+      if (!isAsync && languageVersion < 2 /* Generators */ && compilerOptions.downlevelIteration) {
         checkExternalEmitHelpers(node, 256 /* Values */);
       }
     }
@@ -76115,13 +76145,13 @@ function createTypeChecker(host) {
     }
     const functionFlags = getFunctionFlags(node);
     if (!(functionFlags & 4 /* Invalid */)) {
-      if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 99 /* ESNext */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) === 3 /* AsyncGenerator */ && languageVersion < 5 /* AsyncGenerators */) {
         checkExternalEmitHelpers(node, 6144 /* AsyncGeneratorIncludes */);
       }
-      if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* ES2017 */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) === 2 /* Async */ && languageVersion < 4 /* AsyncFunctions */) {
         checkExternalEmitHelpers(node, 64 /* Awaiter */);
       }
-      if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* ES2015 */) {
+      if ((functionFlags & 3 /* AsyncGenerator */) !== 0 /* Normal */ && languageVersion < 2 /* Generators */) {
         checkExternalEmitHelpers(node, 128 /* Generator */);
       }
     }
@@ -76354,15 +76384,17 @@ function createTypeChecker(host) {
     setNodeLinksForPrivateIdentifierScope(node);
   }
   function setNodeLinksForPrivateIdentifierScope(node) {
-    if (isPrivateIdentifier(node.name) && languageVersion < 99 /* ESNext */) {
-      for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
-        getNodeLinks(lexicalScope).flags |= 1048576 /* ContainsClassWithPrivateIdentifiers */;
-      }
-      if (isClassExpression(node.parent)) {
-        const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
-        if (enclosingIterationStatement) {
-          getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
-          getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+    if (isPrivateIdentifier(node.name)) {
+      if (languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */ || !useDefineForClassFields) {
+        for (let lexicalScope = getEnclosingBlockScopeContainer(node); !!lexicalScope; lexicalScope = getEnclosingBlockScopeContainer(lexicalScope)) {
+          getNodeLinks(lexicalScope).flags |= 1048576 /* ContainsClassWithPrivateIdentifiers */;
+        }
+        if (isClassExpression(node.parent)) {
+          const enclosingIterationStatement = getEnclosingIterationStatement(node.parent);
+          if (enclosingIterationStatement) {
+            getNodeLinks(node.name).flags |= 32768 /* BlockScopedBindingInLoop */;
+            getNodeLinks(enclosingIterationStatement).flags |= 4096 /* LoopWithCapturedBlockScopedBinding */;
+          }
         }
       }
     }
@@ -77314,7 +77346,56 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkGrammarDecorator(decorator) {
+    const sourceFile = getSourceFileOfNode(decorator);
+    if (!hasParseDiagnostics(sourceFile)) {
+      let node = decorator.expression;
+      if (isParenthesizedExpression(node)) {
+        return false;
+      }
+      let canHaveCallExpression = true;
+      let errorNode;
+      while (true) {
+        if (isExpressionWithTypeArguments(node) || isNonNullExpression(node)) {
+          node = node.expression;
+          continue;
+        }
+        if (isCallExpression(node)) {
+          if (!canHaveCallExpression) {
+            errorNode = node;
+          }
+          if (node.questionDotToken) {
+            errorNode = node.questionDotToken;
+          }
+          node = node.expression;
+          canHaveCallExpression = false;
+          continue;
+        }
+        if (isPropertyAccessExpression(node)) {
+          if (node.questionDotToken) {
+            errorNode = node.questionDotToken;
+          }
+          node = node.expression;
+          canHaveCallExpression = false;
+          continue;
+        }
+        if (!isIdentifier(node)) {
+          errorNode = node;
+        }
+        break;
+      }
+      if (errorNode) {
+        addRelatedInfo(
+          error(decorator.expression, Diagnostics.Expression_must_be_enclosed_in_parentheses_to_be_used_as_a_decorator),
+          createDiagnosticForNode(errorNode, Diagnostics.Invalid_syntax_in_decorator)
+        );
+        return true;
+      }
+    }
+    return false;
+  }
   function checkDecorator(node) {
+    checkGrammarDecorator(node);
     const signature = getResolvedSignature(node);
     checkDeprecatedSignature(signature, node);
     const returnType = getReturnTypeOfSignature(signature);
@@ -77487,7 +77568,7 @@ function createTypeChecker(host) {
       if (node.kind === 169 /* Parameter */) {
         checkExternalEmitHelpers(firstDecorator, 32 /* Param */);
       }
-    } else if (languageVersion < 99 /* ESNext */) {
+    } else if (languageVersion < 99 /* ClassAndClassElementDecorators */) {
       checkExternalEmitHelpers(firstDecorator, 8 /* ESDecorateAndRunInitializers */);
       if (isClassDeclaration(node)) {
         if (!node.name) {
@@ -78192,7 +78273,7 @@ function createTypeChecker(host) {
         potentialUnusedRenamedBindingElementsInTypes.push(node);
         return;
       }
-      if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ES2018 */) {
+      if (isObjectBindingPattern(node.parent) && node.dotDotDotToken && languageVersion < 5 /* ObjectSpreadRest */) {
         checkExternalEmitHelpers(node, 4 /* Rest */);
       }
       if (node.propertyName && node.propertyName.kind === 167 /* ComputedPropertyName */) {
@@ -78228,7 +78309,7 @@ function createTypeChecker(host) {
       }
     }
     if (isBindingPattern(node.name)) {
-      if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < 2 /* ES2015 */ && compilerOptions.downlevelIteration) {
+      if (node.name.kind === 207 /* ArrayBindingPattern */ && languageVersion < 2 /* BindingPatterns */ && compilerOptions.downlevelIteration) {
         checkExternalEmitHelpers(node, 512 /* Read */);
       }
       forEach(node.name.elements, checkSourceElement);
@@ -78379,7 +78460,7 @@ function createTypeChecker(host) {
   }
   function checkVariableDeclarationList(node) {
     const blockScopeKind = getCombinedNodeFlags(node) & 7 /* BlockScoped */;
-    if (blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) {
+    if ((blockScopeKind === 4 /* Using */ || blockScopeKind === 6 /* AwaitUsing */) && languageVersion < 99 /* UsingAndAwaitUsing */) {
       checkExternalEmitHelpers(node, 16777216 /* AddDisposableResourceAndDisposeResources */);
     }
     forEach(node.declarations, checkSourceElement);
@@ -78552,11 +78633,11 @@ function createTypeChecker(host) {
         grammarErrorOnNode(node.awaitModifier, Diagnostics.for_await_loops_cannot_be_used_inside_a_class_static_block);
       } else {
         const functionFlags = getFunctionFlags(container);
-        if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 99 /* ESNext */) {
+        if ((functionFlags & (4 /* Invalid */ | 2 /* Async */)) === 2 /* Async */ && languageVersion < 5 /* ForAwaitOf */) {
           checkExternalEmitHelpers(node, 16384 /* ForAwaitOfIncludes */);
         }
       }
-    } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ES2015 */) {
+    } else if (compilerOptions.downlevelIteration && languageVersion < 2 /* ForOf */) {
       checkExternalEmitHelpers(node, 256 /* ForOfIncludes */);
     }
     if (node.initializer.kind === 261 /* VariableDeclarationList */) {
@@ -79480,6 +79561,7 @@ function createTypeChecker(host) {
       case "symbol":
       case "void":
       case "object":
+      case "undefined":
         error(name, message, name.escapedText);
     }
   }
@@ -79619,12 +79701,12 @@ function createTypeChecker(host) {
     return true;
   }
   function getFirstTransformableStaticClassElement(node) {
-    const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < 99 /* ESNext */ && classOrConstructorParameterIsDecorated(
+    const willTransformStaticElementsOfDecoratedClass = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */ && classOrConstructorParameterIsDecorated(
       /*useLegacyDecorators*/
       false,
       node
     );
-    const willTransformPrivateElementsOrClassStaticBlocks = languageVersion <= 9 /* ES2022 */;
+    const willTransformPrivateElementsOrClassStaticBlocks = languageVersion < 9 /* PrivateNamesAndClassStaticBlocks */ || languageVersion < 99 /* ClassAndClassElementDecorators */;
     const willTransformInitializers = !emitStandardClassFields;
     if (willTransformStaticElementsOfDecoratedClass || willTransformPrivateElementsOrClassStaticBlocks) {
       for (const member of node.members) {
@@ -79653,7 +79735,7 @@ function createTypeChecker(host) {
     const parent = walkUpOuterExpressions(node);
     if (!isNamedEvaluationSource(parent))
       return;
-    const willTransformESDecorators = !legacyDecorators && languageVersion < 99 /* ESNext */;
+    const willTransformESDecorators = !legacyDecorators && languageVersion < 99 /* ClassAndClassElementDecorators */;
     let location;
     if (willTransformESDecorators && classOrConstructorParameterIsDecorated(
       /*useLegacyDecorators*/
@@ -79713,7 +79795,7 @@ function createTypeChecker(host) {
     const baseTypeNode = getEffectiveBaseTypeNode(node);
     if (baseTypeNode) {
       forEach(baseTypeNode.typeArguments, checkSourceElement);
-      if (languageVersion < 2 /* ES2015 */) {
+      if (languageVersion < 2 /* Classes */) {
         checkExternalEmitHelpers(baseTypeNode.parent, 1 /* Extends */);
       }
       const extendsNode = getClassExtendsHeritageElement(node);
@@ -83182,7 +83264,7 @@ function createTypeChecker(host) {
         }
       }
     }
-    addToSymbolTable(globals, builtinGlobals, Diagnostics.Declaration_name_conflicts_with_built_in_global_identifier_0);
+    addUndefinedToGlobalsOrErrorOnRedeclaration();
     getSymbolLinks(undefinedSymbol).type = undefinedWideningType;
     getSymbolLinks(argumentsSymbol).type = getGlobalType(
       "IArguments",
@@ -83836,7 +83918,7 @@ function createTypeChecker(host) {
         if (parameter.initializer) {
           return grammarErrorOnNode(parameter.name, Diagnostics.A_rest_parameter_cannot_have_an_initializer);
         }
-      } else if (isOptionalParameter(parameter)) {
+      } else if (hasEffectiveQuestionToken(parameter)) {
         seenOptionalParameter = true;
         if (parameter.questionToken && parameter.initializer) {
           return grammarErrorOnNode(parameter.name, Diagnostics.Parameter_cannot_have_question_mark_and_initializer);
@@ -86770,12 +86852,12 @@ function getOriginalNodeId(node) {
 function containsDefaultReference(node) {
   if (!node)
     return false;
-  if (!isNamedImports(node))
+  if (!isNamedImports(node) && !isNamedExports(node))
     return false;
   return some(node.elements, isNamedDefaultReference);
 }
 function isNamedDefaultReference(e) {
-  return e.propertyName !== void 0 && e.propertyName.escapedText === "default" /* Default */;
+  return e.propertyName !== void 0 ? e.propertyName.escapedText === "default" /* Default */ : e.name.escapedText === "default" /* Default */;
 }
 function chainBundle(context, transformSourceFile) {
   return transformSourceFileOrBundle;
@@ -86849,6 +86931,7 @@ function collectExternalModuleInfo(context, sourceFile) {
             externalImports.push(node);
             if (isNamedExports(node.exportClause)) {
               addExportedNamesForExportDeclaration(node);
+              hasImportDefault || (hasImportDefault = containsDefaultReference(node.exportClause));
             } else {
               const name = node.exportClause.name;
               if (!uniqueExports.get(idText(name))) {