tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/checker-expressions.js

@@ -7,16 +7,17 @@ import { getThisContainer, isEntityNameExpression, isStatic, skipParentheses, is
 import { shouldCheckErasableSyntax } from './checker-declarations.js';
 import { skipTrivia } from './scanner.js';
 import { Diagnostic } from './diagnostics.js';
+import { createDiagnosticForNode } from './checker.js';
 import { checkSuperExpression, checkThisBeforeSuper, checkThisInStaticClassFieldInitializerInDecoratedClass, } from './checker-super.js';
 import { cachedTypeKey, } from './checker-types.js';
 import { createTupleTypeEx, getBigIntLiteralType, getFreshTypeOfLiteralType, getNumberLiteralType, getRegularTypeOfLiteralType, getStringLiteralType, getUnionTypeEx, getWidenedLiteralType, getWidenedUniqueESSymbolType, isErrorType, isTupleType, someType, typesOf, getBaseTypeOfLiteralType, cloneTypeReference, createArrayTypeEx, everyType, getTemplateLiteralType, isMutableArrayOrTuple, } from './checker-type-factory.js';
 import { TupleElementInfo } from './checker-types.js';
 import { getBaseConstraintOfType, getPropertyOfType, getIndexInfoOfType, getIndexInfosOfType, getIndexTypeOfType, getTypeOfPropertyOfType, isArrayLikeType, getBaseConstraintOrType, isApplicableIndexType, getDeclarationModifierFlagsFromSymbol, getApparentType, mapToBaseConstraintOrType, } from './checker-members.js';
-import { getExportSymbolOfValueSymbolIfExported, getMergedSymbol, getSymbolOfDeclaration, resolveEntityName, resolveName, getFirstIdentifier, getCannotFindNameDiagnosticForName, getDeclarationOfAliasSymbol, popTypeResolution, pushTypeResolution, reportCircularityError, } from './checker-symbols.js';
+import { getExportSymbolOfValueSymbolIfExported, getMergedSymbol, getSymbolOfDeclaration, resolveEntityName, resolveName, getFirstIdentifier, cannotFindNameAtLocation, getDeclarationOfAliasSymbol, popTypeResolution, pushTypeResolution, reportCircularityError, } from './checker-symbols.js';
 import { getTypeOfSymbol, getWidenedType, isReadonlySymbol, getOptionalType, removeMissingType, addOptionality, } from './checker-symbol-types.js';
 import { getDeclaredTypeOfClassOrInterface } from './checker-declared-types.js';
 import { getTypeFromTypeNode } from './checker-type-nodes.js';
-import { isGenericObjectType, getIndexedAccessTypeOrUndefinedEx, getHomomorphicTypeVariable, isGenericIndexType, isGenericMappedType, isGenericType, getMappedTypeNameTypeKind, getIndexForMappedType, getIndexTypeEx, getMappedTypeModifiers, getPropertyNameFromIndex, isNoInferType, } from './checker-type-operators.js';
+import { isGenericObjectType, getIndexedAccessTypeOrUndefinedEx, getHomomorphicTypeVariable, isGenericIndexType, isGenericMappedType, isGenericType, getIndexTypeEx, getMappedTypeModifiers, getPropertyNameFromIndex, isNoInferType, } from './checker-type-operators.js';
 import { getTypeFacts, getNonNullableType, getTypeWithFacts, hasTypeFacts } from './checker-flow.js';
 import { checkTypeComparableTo, isTypeAssignableTo, isTypeComparableTo } from './relations.js';
 import { isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
@@ -33,7 +34,8 @@ import { isInPropertyInitializerOrClassStaticBlock } from './checker-declaration
 import { checkObjectLiteral } from './checker-object-literals.js';
 import { evaluate } from './checker-evaluator.js';
 import { checkPrivateIdentifierExpression, checkPropertyAccessExpressionOrQualifiedName, isMethodAccessForCall, } from './checker-property-access.js';
-import { checkBinaryExpression, checkConditionalExpression, checkDeleteExpression, checkPostfixUnaryExpression, checkPrefixUnaryExpression, isTypeAssertion, } from './checker-operators.js';
+import { checkBinaryExpression, checkConditionalExpression, checkDeleteExpression, checkPostfixUnaryExpression, checkPrefixUnaryExpression, grammarErrorOnNode, isTypeAssertion, } from './checker-operators.js';
+import { fileExtensionIsOneOf } from './path.js';
 import { checkJsx } from './checker-jsx.js';
 import { getRegularTypeOfObjectLiteral } from './checker-literals.js';
 import { getReturnTypeOfSignature, getSignatureFromDeclaration, getSingleSignature, getThisTypeOfSignature, } from './checker-signatures.js';
@@ -69,14 +71,14 @@ export function checkExpressionEx(c, node, checkMode) {
  */
 function checkConstEnumAccess(c, node, t) {
     const parent = node.parent;
-    const ok = ((parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ || parent.kind === 213 /* SyntaxKind.ElementAccessExpression */) &&
+    const ok = ((parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ || parent.kind === 214 /* SyntaxKind.ElementAccessExpression */) &&
         getExpression(parent) === node) ||
-        ((node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 167 /* SyntaxKind.QualifiedName */) &&
+        ((node.kind === 79 /* SyntaxKind.Identifier */ || node.kind === 168 /* SyntaxKind.QualifiedName */) &&
             isInRightSideOfImportOrExportAssignment(node)) ||
-        (parent.kind === 187 /* SyntaxKind.TypeQuery */ && parent.exprName === node) ||
-        parent.kind === 282 /* SyntaxKind.ExportSpecifier */;
+        (parent.kind === 188 /* SyntaxKind.TypeQuery */ && parent.exprName === node) ||
+        parent.kind === 283 /* SyntaxKind.ExportSpecifier */;
     if (!ok)
-        c.error(node, 639 /* Diagnostics.X_const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query */);
+        c.error(node, 646 /* Diagnostics.X_const_enums_can_only_be_used_in_property_or_index_access_expressions_or_the_right_hand_side_of_an_import_declaration_or_export_assignment_or_type_query */);
     // Under verbatimModuleSyntax, only uses that don't resolve to an import are checked here; imports of
     // ambient const enums are checked with the alias.
     if (c.compilerOptions.isolatedModules === true ||
@@ -85,17 +87,17 @@ function checkConstEnumAccess(c, node, t) {
             resolveName(c, node, getText(getFirstIdentifier(node)), 2097152 /* SymbolFlags.Alias */, undefined, false, true) === undefined)) {
         const constEnumDeclaration = t.symbol.valueDeclaration;
         if ((constEnumDeclaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0 && !isValidTypeOnlyAliasUseSite(node))
-            c.error(node, 880 /* Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled */, getIsolatedModulesLikeFlagName(c));
+            c.error(node, 887 /* Diagnostics.Cannot_access_ambient_const_enums_when_0_is_enabled */, getIsolatedModulesLikeFlagName(c));
     }
 }
 function isInRightSideOfImportOrExportAssignment(name) {
     let node = name;
-    while (node.parent.kind === 167 /* SyntaxKind.QualifiedName */)
+    while (node.parent.kind === 168 /* SyntaxKind.QualifiedName */)
         node = node.parent;
     const parent = node.parent;
-    return ((parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
+    return ((parent.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
         parent.moduleReference === node) ||
-        (parent.kind === 278 /* SyntaxKind.ExportAssignment */ && getExpression(parent) === node));
+        (parent.kind === 279 /* SyntaxKind.ExportAssignment */ && getExpression(parent) === node));
 }
 /** The type of `node`, computed once. */
 export function checkExpressionCached(c, node) {
@@ -162,11 +164,11 @@ export function checkDeclarationInitializer(c, declaration, checkMode = 0 /* Che
 function getQuickTypeOfExpression(c, node) {
     const expr = skipParentheses(node);
     switch (expr.kind) {
-        case 224 /* SyntaxKind.AwaitExpression */: {
+        case 225 /* SyntaxKind.AwaitExpression */: {
             const t = getQuickTypeOfExpression(c, getExpression(expr));
             return t !== undefined ? getAwaitedType(c, t) : undefined;
         }
-        case 214 /* SyntaxKind.CallExpression */: {
+        case 215 /* SyntaxKind.CallExpression */: {
             const call = expr;
             if (call.expression.kind === 107 /* SyntaxKind.SuperKeyword */ ||
                 isRequireCall(call, true) ||
@@ -183,10 +185,10 @@ function getQuickTypeOfExpression(c, node) {
             }
             return getReturnTypeOfSingleNonGenericSignature(c, checkNonNullExpression(c, call.expression), 0 /* SignatureKind.Call */);
         }
-        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return getReturnTypeOfSingleNonGenericSignature(c, checkNonNullExpression(c, getExpression(expr)), 1 /* SignatureKind.Construct */);
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */: {
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */: {
             const typeNode = getType(expr);
             return isConstTypeReference(typeNode) ? undefined : getTypeFromTypeNode(c, typeNode);
         }
@@ -202,18 +204,20 @@ function getReturnTypeOfSingleNonGenericSignature(c, funcType, kind) {
         : undefined;
 }
 export function checkComputedPropertyName(c, node) {
-    const nodeId = node.expression.id;
+    const nodeId = node.id;
     if (c.resolvedTypes.get(nodeId) === undefined) {
+        // A reference to the name while its expression is checked sees a circular type.
+        c.resolvedTypes.set(nodeId, c.circularConstraintType);
         const expression = node.expression;
         const container = node.parent.parent;
         // `[x in y]` in a type member is a mapped type written in the wrong place, reported by the parser.
-        if ((container.kind === 188 /* SyntaxKind.TypeLiteral */ ||
+        if ((container.kind === 189 /* SyntaxKind.TypeLiteral */ ||
             isClassLike(container) ||
-            container.kind === 265 /* SyntaxKind.InterfaceDeclaration */) &&
-            expression.kind === 227 /* SyntaxKind.BinaryExpression */ &&
+            container.kind === 266 /* SyntaxKind.InterfaceDeclaration */) &&
+            expression.kind === 228 /* SyntaxKind.BinaryExpression */ &&
             expression.operatorToken.kind === 102 /* SyntaxKind.InKeyword */ &&
-            node.parent.kind !== 178 /* SyntaxKind.GetAccessor */ &&
-            node.parent.kind !== 179 /* SyntaxKind.SetAccessor */) {
+            node.parent.kind !== 179 /* SyntaxKind.GetAccessor */ &&
+            node.parent.kind !== 180 /* SyntaxKind.SetAccessor */) {
             c.resolvedTypes.set(nodeId, c.errorType);
             return c.resolvedTypes.get(nodeId);
         }
@@ -223,14 +227,14 @@ export function checkComputedPropertyName(c, node) {
         if ((t.flags & 12 /* TypeFlags.Nullable */) !== 0 ||
             (!isTypeAssignableToKind(c, t, 12583968 /* TypeFlags.StringLike */ | 67648 /* TypeFlags.NumberLike */ | 16896 /* TypeFlags.ESSymbolLike */, false) &&
                 !isTypeAssignableTo(c, t, c.stringNumberSymbolType)))
-            c.error(node, 630 /* Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any */);
+            c.error(node, 637 /* Diagnostics.A_computed_property_name_must_be_of_type_string_number_symbol_or_any */);
     }
     return c.resolvedTypes.get(nodeId);
 }
 /** A parameter's declared type without `undefined` when its initializer can't be `undefined`. */
 function removeOptionalityFromDeclaredType(c, declaredType, declaration) {
     const removeUndefined = c.strictNullChecks &&
-        declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+        declaration.kind === 171 /* SyntaxKind.Parameter */ &&
         getInitializer(declaration) !== undefined &&
         hasTypeFacts(c, declaredType, 16777216 /* TypeFacts.IsUndefined */) &&
         !parameterInitializerContainsUndefined(c, declaration);
@@ -257,19 +261,19 @@ function parameterInitializerContainsUndefined(c, declaration) {
 /** Whether `node` is the operand of a spread in an object destructuring assignment, as in `({ ...x } = obj)`. */
 function isSpreadDestructuringAssignmentTarget(node) {
     const parent = node.parent;
-    if (parent.kind !== 305 /* SyntaxKind.SpreadAssignment */ || parent.parent === undefined)
+    if (parent.kind !== 306 /* SyntaxKind.SpreadAssignment */ || parent.parent === undefined)
         return false;
     const pattern = parent.parent;
     const grandparent = pattern.parent;
-    return ((grandparent.kind === 227 /* SyntaxKind.BinaryExpression */ && grandparent.left === pattern) ||
-        (grandparent.kind === 251 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === pattern));
+    return ((grandparent.kind === 228 /* SyntaxKind.BinaryExpression */ && grandparent.left === pattern) ||
+        (grandparent.kind === 252 /* SyntaxKind.ForOfStatement */ && grandparent.initializer === pattern));
 }
 /** Whether `node` is in a binding element of the same declaration as the binding element `declaration`. */
 function isSameScopedBindingElement(node, declaration) {
-    if (declaration.kind !== 209 /* SyntaxKind.BindingElement */)
+    if (declaration.kind !== 210 /* SyntaxKind.BindingElement */)
         return false;
     let bindingElement = node.parent;
-    while (bindingElement !== undefined && bindingElement.kind !== 209 /* SyntaxKind.BindingElement */)
+    while (bindingElement !== undefined && bindingElement.kind !== 210 /* SyntaxKind.BindingElement */)
         bindingElement = bindingElement.parent;
     return bindingElement !== undefined && getRootDeclaration(bindingElement) === getRootDeclaration(declaration);
 }
@@ -278,16 +282,16 @@ export function isThisInTypeQuery(node) {
     if (node.kind !== 79 /* SyntaxKind.Identifier */ || getText(node) !== 'this')
         return false;
     let current = node;
-    while (current.parent.kind === 167 /* SyntaxKind.QualifiedName */ && current.parent.left === current)
+    while (current.parent.kind === 168 /* SyntaxKind.QualifiedName */ && current.parent.left === current)
         current = current.parent;
-    return current.parent.kind === 187 /* SyntaxKind.TypeQuery */;
+    return current.parent.kind === 188 /* SyntaxKind.TypeQuery */;
 }
 /** The type of the expression in a `typeof` type query. */
 export function checkTypeQueryExpression(c, node) {
     const exprName = node.exprName;
     if (exprName.kind === 79 /* SyntaxKind.Identifier */)
         return checkIdentifier(c, exprName);
-    if (exprName.kind === 167 /* SyntaxKind.QualifiedName */)
+    if (exprName.kind === 168 /* SyntaxKind.QualifiedName */)
         return checkQualifiedName(c, exprName);
     if (exprName.kind === 109 /* SyntaxKind.ThisKeyword */)
         return checkThisExpression(c, exprName);
@@ -299,9 +303,9 @@ export function getResolvedSymbol(c, node) {
     if (cached !== undefined)
         return cached;
     let symbol = c.unknownSymbol;
-    if (getText(node) !== '') {
-        const text = getText(node);
-        const found = resolveName(c, node, text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, getCannotFindNameDiagnosticForName(c, node), !isWriteOnlyAccess(node), false);
+    const text = getText(node);
+    if (text !== '') {
+        const found = resolveName(c, node, text, 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */, cannotFindNameAtLocation, !isWriteOnlyAccess(node), false);
         if (found !== undefined)
             symbol = found;
     }
@@ -332,40 +336,40 @@ function checkExpressionWorker(c, node, checkMode) {
             return getFreshTypeOfLiteralType(c, getNumberLiteralType(c, Number(getText(node))));
         case 9 /* SyntaxKind.BigIntLiteral */:
             return getFreshTypeOfLiteralType(c, getBigIntLiteralType(c, parseBigIntText(getText(node))));
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
             return checkTemplateExpression(c, node);
         case 13 /* SyntaxKind.RegularExpressionLiteral */:
             return c.globalRegExpType;
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
             return checkArrayLiteral(c, node, checkMode);
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
             return checkObjectLiteral(c, node, checkMode);
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
             return checkPropertyAccessExpression(c, node, false, checkMode);
-        case 167 /* SyntaxKind.QualifiedName */:
+        case 168 /* SyntaxKind.QualifiedName */:
             return checkQualifiedName(c, node);
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
             return checkElementAccessExpression(c, node, checkMode);
-        case 214 /* SyntaxKind.CallExpression */:
+        case 215 /* SyntaxKind.CallExpression */:
             return checkCallExpression(c, node, checkMode);
-        case 215 /* SyntaxKind.NewExpression */:
+        case 216 /* SyntaxKind.NewExpression */:
             return checkNewExpression(c, node, checkMode);
-        case 216 /* SyntaxKind.TaggedTemplateExpression */:
+        case 217 /* SyntaxKind.TaggedTemplateExpression */:
             return checkTaggedTemplateExpression(c, node, checkMode);
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return checkExpressionEx(c, getExpression(node), checkMode);
-        case 232 /* SyntaxKind.ClassExpression */:
+        case 233 /* SyntaxKind.ClassExpression */:
             return checkClassExpression(c, node);
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             return checkFunctionExpressionOrObjectLiteralMethod(c, node, checkMode);
-        case 222 /* SyntaxKind.TypeOfExpression */:
+        case 223 /* SyntaxKind.TypeOfExpression */:
             checkExpression(c, getExpression(node));
             return c.typeofType;
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
-        case 235 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
             return checkAssertion(c, node, checkMode);
-        case 236 /* SyntaxKind.NonNullExpression */: {
+        case 237 /* SyntaxKind.NonNullExpression */: {
             const leftType = checkExpressionEx(c, getExpression(node), checkMode);
             if ((node.flags & 32 /* NodeFlags.OptionalChain */) === 0)
                 return getNonNullableType(c, leftType);
@@ -373,41 +377,41 @@ function checkExpressionWorker(c, node, checkMode) {
             const nonOptionalType = getOptionalExpressionType(c, leftType, getExpression(node));
             return propagateOptionalTypeMarker(c, getNonNullableType(c, nonOptionalType), node, nonOptionalType !== leftType);
         }
-        case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+        case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
             return checkExpressionWithTypeArguments(c, node);
-        case 239 /* SyntaxKind.SatisfiesExpression */:
+        case 240 /* SyntaxKind.SatisfiesExpression */:
             return checkSatisfiesExpression(c, node, checkMode);
-        case 237 /* SyntaxKind.MetaProperty */:
+        case 238 /* SyntaxKind.MetaProperty */:
             return checkMetaProperty(c, node);
-        case 221 /* SyntaxKind.DeleteExpression */:
+        case 222 /* SyntaxKind.DeleteExpression */:
             return checkDeleteExpression(c, node);
-        case 223 /* SyntaxKind.VoidExpression */:
+        case 224 /* SyntaxKind.VoidExpression */:
             // The operand is checked deferred.
             checkNodeDeferred(c, node);
             return c.undefinedWideningType;
-        case 224 /* SyntaxKind.AwaitExpression */:
+        case 225 /* SyntaxKind.AwaitExpression */:
             return checkAwaitExpression(c, node);
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
             return checkPrefixUnaryExpression(c, node);
-        case 226 /* SyntaxKind.PostfixUnaryExpression */:
+        case 227 /* SyntaxKind.PostfixUnaryExpression */:
             return checkPostfixUnaryExpression(c, node);
-        case 227 /* SyntaxKind.BinaryExpression */:
+        case 228 /* SyntaxKind.BinaryExpression */:
             return checkBinaryExpression(c, node, checkMode);
-        case 228 /* SyntaxKind.ConditionalExpression */:
+        case 229 /* SyntaxKind.ConditionalExpression */:
             return checkConditionalExpression(c, node, checkMode);
-        case 231 /* SyntaxKind.SpreadElement */:
+        case 232 /* SyntaxKind.SpreadElement */:
             return checkSpreadExpression(c, node, checkMode);
-        case 233 /* SyntaxKind.OmittedExpression */:
+        case 234 /* SyntaxKind.OmittedExpression */:
             return c.undefinedWideningType;
-        case 230 /* SyntaxKind.YieldExpression */:
+        case 231 /* SyntaxKind.YieldExpression */:
             return checkYieldExpression(c, node);
-        case 238 /* SyntaxKind.SyntheticExpression */:
+        case 239 /* SyntaxKind.SyntheticExpression */:
             return c.anyType;
-        case 295 /* SyntaxKind.JsxExpression */:
-        case 285 /* SyntaxKind.JsxElement */:
-        case 286 /* SyntaxKind.JsxSelfClosingElement */:
-        case 289 /* SyntaxKind.JsxFragment */:
-        case 293 /* SyntaxKind.JsxAttributes */:
+        case 296 /* SyntaxKind.JsxExpression */:
+        case 286 /* SyntaxKind.JsxElement */:
+        case 287 /* SyntaxKind.JsxSelfClosingElement */:
+        case 290 /* SyntaxKind.JsxFragment */:
+        case 294 /* SyntaxKind.JsxAttributes */:
             return checkJsx(c, node, checkMode);
     }
     return c.errorType;
@@ -434,7 +438,7 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
         return c.errorType;
     if (symbol === c.argumentsSymbol) {
         if (isInPropertyInitializerOrClassStaticBlock(node, true)) {
-            c.error(node, 946 /* Diagnostics.X_arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks */);
+            c.error(node, 953 /* Diagnostics.X_arguments_cannot_be_referenced_in_property_initializers_or_class_static_initialization_blocks */);
             return c.errorType;
         }
         return getTypeOfSymbol(c, symbol);
@@ -446,7 +450,7 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
     const immediateDeclaration = declaration;
     // In `const [a, b = a + 1] = [2]`, `a` is `any` while computing the contextual type of `[2]`.
     if (declaration !== undefined &&
-        declaration.kind === 209 /* SyntaxKind.BindingElement */ &&
+        declaration.kind === 210 /* SyntaxKind.BindingElement */ &&
         c.contextualBindingPatterns.includes(declaration.parent) &&
         isDescendantOf(node, declaration.parent))
         return c.nonInferrableAnyType;
@@ -454,22 +458,22 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
     const assignmentKind = getAssignmentTargetKind(node);
     if (assignmentKind !== 0 /* AssignmentKind.None */) {
         if ((localOrExportSymbol.flags & 3 /* SymbolFlags.Variable */) === 0) {
-            let message = 696 /* Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable */;
+            let message = 703 /* Diagnostics.Cannot_assign_to_0_because_it_is_not_a_variable */;
             if ((localOrExportSymbol.flags & 384 /* SymbolFlags.Enum */) !== 0)
-                message = 771 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_enum */;
+                message = 778 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_enum */;
             else if ((localOrExportSymbol.flags & 32 /* SymbolFlags.Class */) !== 0)
-                message = 772 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_class */;
+                message = 779 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_class */;
             else if ((localOrExportSymbol.flags & 1536 /* SymbolFlags.Module */) !== 0)
-                message = 774 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace */;
+                message = 781 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_namespace */;
             else if ((localOrExportSymbol.flags & 16 /* SymbolFlags.Function */) !== 0)
-                message = 773 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_function */;
+                message = 780 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_function */;
             else if ((localOrExportSymbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0)
-                message = 775 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_import */;
+                message = 782 /* Diagnostics.Cannot_assign_to_0_because_it_is_an_import */;
             c.error(node, message, symbolToString(c, symbol));
             return c.errorType;
         }
         if (isReadonlySymbol(c, localOrExportSymbol)) {
-            c.error(node, 736 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_constant */, symbolToString(c, symbol));
+            c.error(node, 743 /* Diagnostics.Cannot_assign_to_0_because_it_is_a_constant */, symbolToString(c, symbol));
             return c.errorType;
         }
     }
@@ -485,14 +489,14 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
         return t;
     if (declaration === undefined)
         return t;
-    const isParameter = getRootDeclaration(declaration).kind === 170 /* SyntaxKind.Parameter */;
+    const isParameter = getRootDeclaration(declaration).kind === 171 /* SyntaxKind.Parameter */;
     // The CommonJS `module` symbol is declared by its source file.
     const declarationContainer = declaration.parent !== undefined ? getControlFlowContainer(declaration) : undefined;
     let flowContainer = getControlFlowContainer(node);
     const isOuterVariable = flowContainer !== declarationContainer;
     const isModuleExports = (symbol.flags & 134217728 /* SymbolFlags.ModuleExports */) !== 0;
     const typeIsAutomatic = t === c.autoType || t === c.autoArrayType;
-    const isAutomaticTypeInNonNull = typeIsAutomatic && node.parent.kind === 236 /* SyntaxKind.NonNullExpression */;
+    const isAutomaticTypeInNonNull = typeIsAutomatic && node.parent.kind === 237 /* SyntaxKind.NonNullExpression */;
     // Closures see narrowings of constants, and of variables past their last assignment.
     while (flowContainer !== declarationContainer &&
         (isFunctionExpressionOrArrowFunction(flowContainer) ||
@@ -501,9 +505,9 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
             (isParameterOrMutableLocalVariable(c, localOrExportSymbol) && isPastLastAssignment(c, localOrExportSymbol, node))))
         flowContainer = getControlFlowContainer(flowContainer);
     const isNeverInitialized = immediateDeclaration !== undefined &&
-        immediateDeclaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
-        immediateDeclaration.parent.parent.kind !== 250 /* SyntaxKind.ForInStatement */ &&
-        immediateDeclaration.parent.parent.kind !== 251 /* SyntaxKind.ForOfStatement */ &&
+        immediateDeclaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
+        immediateDeclaration.parent.parent.kind !== 251 /* SyntaxKind.ForInStatement */ &&
+        immediateDeclaration.parent.parent.kind !== 252 /* SyntaxKind.ForOfStatement */ &&
         getInitializer(immediateDeclaration) === undefined &&
         immediateDeclaration.exclamationToken === undefined &&
         isMutableLocalVariableDeclaration(immediateDeclaration) &&
@@ -520,9 +524,9 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
                 (t.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16 /* TypeFlags.Void */)) !== 0 ||
                 isPartOfTypeQuery(node) ||
                 isInAmbientOrTypeNode(node) ||
-                node.parent.kind === 282 /* SyntaxKind.ExportSpecifier */)) ||
-        node.parent.kind === 236 /* SyntaxKind.NonNullExpression */ ||
-        (declaration.kind === 261 /* SyntaxKind.VariableDeclaration */ &&
+                node.parent.kind === 283 /* SyntaxKind.ExportSpecifier */)) ||
+        node.parent.kind === 237 /* SyntaxKind.NonNullExpression */ ||
+        (declaration.kind === 262 /* SyntaxKind.VariableDeclaration */ &&
             declaration.exclamationToken !== undefined) ||
         (declaration.flags & 8388608 /* NodeFlags.Ambient */) !== 0;
     let initialType;
@@ -542,14 +546,14 @@ export function checkIdentifier(c, node, checkMode = 0 /* CheckMode.Normal */) {
     if (!isEvolvingArrayOperationTarget(c, node) && typeIsAutomatic) {
         if (flowType === c.autoType || flowType === c.autoArrayType) {
             if (c.noImplicitAny) {
-                c.error(getNameOfDeclaration(declaration), 1705 /* Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined */, symbolToString(c, symbol), typeToString(c, flowType));
-                c.error(node, 1678 /* Diagnostics.Variable_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
+                c.error(getNameOfDeclaration(declaration), 1724 /* Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined */, symbolToString(c, symbol), typeToString(c, flowType));
+                c.error(node, 1697 /* Diagnostics.Variable_0_implicitly_has_an_1_type */, symbolToString(c, symbol), typeToString(c, flowType));
             }
             return convertAutoToAny(c, flowType);
         }
     }
     else if (!assumeInitialized && !containsUndefinedType(t) && containsUndefinedType(flowType)) {
-        c.error(node, 621 /* Diagnostics.Variable_0_is_used_before_being_assigned */, symbolToString(c, symbol));
+        c.error(node, 628 /* Diagnostics.Variable_0_is_used_before_being_assigned */, symbolToString(c, symbol));
         return t;
     }
     return assignmentKind !== 0 /* AssignmentKind.None */ ? getBaseTypeOfLiteralType(c, flowType) : flowType;
@@ -578,11 +582,11 @@ export function someTypeIsGenericWithUnionConstraint(c, t) {
 function isConstraintPosition(c, t, node) {
     const parent = node.parent;
     // `obj[x]` keeps `T[K]` when both are generic and obj's constraint isn't nullable.
-    return (parent.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ||
-        parent.kind === 167 /* SyntaxKind.QualifiedName */ ||
-        ((parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.kind === 215 /* SyntaxKind.NewExpression */) &&
+    return (parent.kind === 213 /* SyntaxKind.PropertyAccessExpression */ ||
+        parent.kind === 168 /* SyntaxKind.QualifiedName */ ||
+        ((parent.kind === 215 /* SyntaxKind.CallExpression */ || parent.kind === 216 /* SyntaxKind.NewExpression */) &&
             getExpression(parent) === node) ||
-        (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+        (parent.kind === 214 /* SyntaxKind.ElementAccessExpression */ &&
             getExpression(parent) === node &&
             !(someType(t, (u) => isGenericTypeWithoutNullableConstraint(c, u)) &&
                 isGenericIndexType(c, getTypeOfExpression(c, parent.argumentExpression)))));
@@ -609,11 +613,11 @@ function isGenericTypeWithoutNullableConstraint(c, t) {
 function hasContextualTypeWithNoGenericTypes(c, node, checkMode) {
     // JSX tag names are excluded: their contextual type resolves the tag itself.
     if (node.kind !== 79 /* SyntaxKind.Identifier */ &&
-        node.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ &&
-        node.kind !== 213 /* SyntaxKind.ElementAccessExpression */)
+        node.kind !== 213 /* SyntaxKind.PropertyAccessExpression */ &&
+        node.kind !== 214 /* SyntaxKind.ElementAccessExpression */)
         return false;
     const parent = node.parent;
-    if ((parent.kind === 287 /* SyntaxKind.JsxOpeningElement */ || parent.kind === 286 /* SyntaxKind.JsxSelfClosingElement */) &&
+    if ((parent.kind === 288 /* SyntaxKind.JsxOpeningElement */ || parent.kind === 287 /* SyntaxKind.JsxSelfClosingElement */) &&
         getTagName(parent) === node)
         return false;
     // Rest elements skip binding pattern contextual types, so their type stays generic when possible.
@@ -635,9 +639,9 @@ export function isInAmbientOrTypeNode(node) {
     if ((node.flags & 8388608 /* NodeFlags.Ambient */) !== 0)
         return true;
     for (let current = node; current !== undefined; current = current.parent) {
-        if (current.kind === 265 /* SyntaxKind.InterfaceDeclaration */ ||
-            current.kind === 266 /* SyntaxKind.TypeAliasDeclaration */ ||
-            current.kind === 188 /* SyntaxKind.TypeLiteral */)
+        if (current.kind === 266 /* SyntaxKind.InterfaceDeclaration */ ||
+            current.kind === 267 /* SyntaxKind.TypeAliasDeclaration */ ||
+            current.kind === 189 /* SyntaxKind.TypeLiteral */)
             return true;
     }
     return false;
@@ -647,15 +651,15 @@ export function checkThisExpression(c, node) {
     let container = getThisContainer(node, true, true);
     let capturedByArrowFunction = false;
     let thisInComputedPropertyName = false;
-    if (container.kind === 177 /* SyntaxKind.Constructor */)
-        checkThisBeforeSuper(c, node, container, 1812 /* Diagnostics.X_super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class */);
+    if (container.kind === 178 /* SyntaxKind.Constructor */)
+        checkThisBeforeSuper(c, node, container, 1832 /* Diagnostics.X_super_must_be_called_before_accessing_this_in_the_constructor_of_a_derived_class */);
     for (;;) {
         // Skip arrow functions to the real owner of `this`.
-        if (container.kind === 220 /* SyntaxKind.ArrowFunction */) {
+        if (container.kind === 221 /* SyntaxKind.ArrowFunction */) {
             container = getThisContainer(container, false, !thisInComputedPropertyName);
             capturedByArrowFunction = true;
         }
-        if (container.kind === 168 /* SyntaxKind.ComputedPropertyName */) {
+        if (container.kind === 169 /* SyntaxKind.ComputedPropertyName */) {
             container = getThisContainer(container, !capturedByArrowFunction, false);
             thisInComputedPropertyName = true;
             continue;
@@ -664,23 +668,31 @@ export function checkThisExpression(c, node) {
     }
     checkThisInStaticClassFieldInitializerInDecoratedClass(c, node, container);
     if (thisInComputedPropertyName)
-        c.error(node, 631 /* Diagnostics.X_this_cannot_be_referenced_in_a_computed_property_name */);
-    else if (container.kind === 268 /* SyntaxKind.ModuleDeclaration */)
-        c.error(node, 509 /* Diagnostics.X_this_cannot_be_referenced_in_a_module_or_namespace_body */);
-    else if (container.kind === 267 /* SyntaxKind.EnumDeclaration */)
-        c.error(node, 510 /* Diagnostics.X_this_cannot_be_referenced_in_current_location */);
+        c.error(node, 638 /* Diagnostics.X_this_cannot_be_referenced_in_a_computed_property_name */);
+    else if (container.kind === 269 /* SyntaxKind.ModuleDeclaration */)
+        c.error(node, 516 /* Diagnostics.X_this_cannot_be_referenced_in_a_module_or_namespace_body */);
+    else if (container.kind === 268 /* SyntaxKind.EnumDeclaration */)
+        c.error(node, 517 /* Diagnostics.X_this_cannot_be_referenced_in_current_location */);
     const t = tryGetThisTypeAt(c, node, container);
     if (c.noImplicitThis) {
         const globalThisType = getTypeOfSymbol(c, c.globalThisSymbol);
         if (t === globalThisType && capturedByArrowFunction)
-            c.error(node, 1712 /* Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this */);
-        else if (t === undefined)
-            c.error(node, 816 /* Diagnostics.X_this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation */);
+            c.error(node, 1731 /* Diagnostics.The_containing_arrow_function_captures_the_global_value_of_this */);
+        else if (t === undefined) {
+            // The related information goes on the reported diagnostic after it is added, as tsgo attaches it,
+            // so a later equal report compares unequal to it and is kept.
+            const diagnostic = c.error(node, 823 /* Diagnostics.X_this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation */);
+            if (container.kind !== 308 /* SyntaxKind.SourceFile */) {
+                const outsideThis = tryGetThisTypeAt(c, container, getThisContainer(container, false, false));
+                if (outsideThis !== undefined && outsideThis !== globalThisType)
+                    diagnostic.addRelatedInfo(createDiagnosticForNode(container, 877 /* Diagnostics.An_outer_value_of_this_is_shadowed_by_this_container */, []));
+            }
+        }
     }
     return t ?? c.anyType;
 }
 function tryGetThisTypeAt(c, node, container) {
-    if (isFunctionLike(container) && container.kind !== 177 /* SyntaxKind.Constructor */) {
+    if (isFunctionLike(container) && container.kind !== 178 /* SyntaxKind.Constructor */) {
         const thisType = getThisTypeOfSignature(c, getSignatureOfFullSignatureType(c, container) ?? getSignatureFromDeclaration(c, container)) ?? getContextualThisParameterType(c, container);
         if (thisType !== undefined)
             return getFlowTypeOfReference(c, node, thisType, thisType, undefined);
@@ -690,12 +702,12 @@ function tryGetThisTypeAt(c, node, container) {
         const classSymbol = getSymbolOfDeclaration(c, parent);
         if (classSymbol === undefined)
             return c.anyType;
-        const t = isStatic(container) || container.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */
+        const t = isStatic(container) || container.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */
             ? getTypeOfSymbol(c, classSymbol)
             : getDeclaredTypeOfClassOrInterface(c, getMergedSymbol(c, classSymbol)).thisType;
         return t !== undefined ? getFlowTypeOfReference(c, node, t, t, undefined) : c.anyType;
     }
-    if (container.kind === 307 /* SyntaxKind.SourceFile */) {
+    if (container.kind === 308 /* SyntaxKind.SourceFile */) {
         if (container.externalModuleIndicator !== undefined)
             return c.undefinedType;
         return getTypeOfSymbol(c, c.globalThisSymbol);
@@ -704,7 +716,7 @@ function tryGetThisTypeAt(c, node, container) {
 }
 /** The `this` type of a function expression or method from its context, such as its object literal. */
 export function getContextualThisParameterType(c, func) {
-    if (func.kind === 220 /* SyntaxKind.ArrowFunction */)
+    if (func.kind === 221 /* SyntaxKind.ArrowFunction */)
         return undefined;
     if (isContextSensitiveFunctionOrObjectLiteralMethod(c, func)) {
         const signature = getContextualSignatureForFunctionLikeDeclaration(c, func);
@@ -720,12 +732,12 @@ export function getContextualThisParameterType(c, func) {
 }
 function getContainingObjectLiteral(func) {
     const parent = func.parent;
-    if ((func.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-        func.kind === 178 /* SyntaxKind.GetAccessor */ ||
-        func.kind === 179 /* SyntaxKind.SetAccessor */) &&
-        parent.kind === 211 /* SyntaxKind.ObjectLiteralExpression */)
+    if ((func.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+        func.kind === 179 /* SyntaxKind.GetAccessor */ ||
+        func.kind === 180 /* SyntaxKind.SetAccessor */) &&
+        parent.kind === 212 /* SyntaxKind.ObjectLiteralExpression */)
         return parent;
-    if (func.kind === 219 /* SyntaxKind.FunctionExpression */ && parent.kind === 303 /* SyntaxKind.PropertyAssignment */)
+    if (func.kind === 220 /* SyntaxKind.FunctionExpression */ && parent.kind === 304 /* SyntaxKind.PropertyAssignment */)
         return parent.parent;
     return undefined;
 }
@@ -738,11 +750,11 @@ function checkTemplateExpression(c, node) {
         const t = checkExpression(c, expression);
         if (maybeTypeOfKind(t, 16896 /* TypeFlags.ESSymbolLike */) ||
             maybeTypeOfKind(getBaseConstraintOrType(c, t), 16896 /* TypeFlags.ESSymbolLike */))
-            c.error(expression, 863 /* Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String */);
+            c.error(expression, 870 /* Diagnostics.Implicit_conversion_of_a_symbol_to_a_string_will_fail_at_runtime_Consider_wrapping_this_expression_in_String */);
         texts.push(getText(span.literal));
         types.push(isTypeAssignableTo(c, t, c.templateConstraintType) ? t : c.stringType);
     }
-    if (node.parent.kind !== 216 /* SyntaxKind.TaggedTemplateExpression */) {
+    if (node.parent.kind !== 217 /* SyntaxKind.TaggedTemplateExpression */) {
         const evaluated = evaluate(c, node, node);
         if (evaluated.kind === 2 /* EvaluatedKind.String */)
             return getFreshTypeOfLiteralType(c, getStringLiteralType(c, evaluated.stringValue));
@@ -755,8 +767,8 @@ function checkTemplateExpression(c, node) {
 }
 function isTemplateLiteralContext(node) {
     const parent = node.parent;
-    return ((parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */ && isTemplateLiteralContext(parent)) ||
-        (parent.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+    return ((parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */ && isTemplateLiteralContext(parent)) ||
+        (parent.kind === 214 /* SyntaxKind.ElementAccessExpression */ &&
             parent.argumentExpression === node));
 }
 function isTemplateLiteralContextualType(c, t) {
@@ -781,7 +793,7 @@ function checkArrayLiteral(c, node, checkMode) {
         (contextualType !== undefined && someType(contextualType, (t) => isTupleLikeContext(c, t)));
     let hasOmittedExpression = false;
     for (const e of elements) {
-        if (e.kind === 231 /* SyntaxKind.SpreadElement */) {
+        if (e.kind === 232 /* SyntaxKind.SpreadElement */) {
             const spreadType = checkExpressionEx(c, e.expression, checkMode);
             if (isArrayLikeType(c, spreadType)) {
                 elementTypes.push(spreadType);
@@ -801,13 +813,13 @@ function checkArrayLiteral(c, node, checkMode) {
                 elementInfos.push(new TupleElementInfo(4 /* ElementFlags.Rest */, undefined));
             }
         }
-        else if (c.exactOptionalPropertyTypes && e.kind === 233 /* SyntaxKind.OmittedExpression */) {
+        else if (c.exactOptionalPropertyTypes && e.kind === 234 /* SyntaxKind.OmittedExpression */) {
             hasOmittedExpression = true;
             elementTypes.push(c.undefinedOrMissingType);
             elementInfos.push(new TupleElementInfo(2 /* ElementFlags.Optional */, undefined));
         }
         else {
-            const t = e.kind === 233 /* SyntaxKind.OmittedExpression */
+            const t = e.kind === 234 /* SyntaxKind.OmittedExpression */
                 ? c.undefinedWideningType
                 : checkExpressionForMutableLocationEx(c, e, checkMode);
             if (inTupleContext &&
@@ -843,10 +855,10 @@ function checkArrayLiteral(c, node, checkMode) {
 }
 function isSpreadIntoCallOrNew(node) {
     let parent = node.parent;
-    while (parent.kind === 218 /* SyntaxKind.ParenthesizedExpression */)
+    while (parent.kind === 219 /* SyntaxKind.ParenthesizedExpression */)
         parent = parent.parent;
-    return (parent.kind === 231 /* SyntaxKind.SpreadElement */ &&
-        (parent.parent.kind === 214 /* SyntaxKind.CallExpression */ || parent.parent.kind === 215 /* SyntaxKind.NewExpression */));
+    return (parent.kind === 232 /* SyntaxKind.SpreadElement */ &&
+        (parent.parent.kind === 215 /* SyntaxKind.CallExpression */ || parent.parent.kind === 216 /* SyntaxKind.NewExpression */));
 }
 function isTupleLikeContext(c, t) {
     if (isTupleLikeType(c, t))
@@ -870,7 +882,8 @@ export function isTupleLikeType(c, t) {
 /** Whether `t` is a mutable array, a mutable tuple, or assignable to `any[]`. */
 export function isMutableArrayLikeType(c, t) {
     return (isMutableArrayOrTuple(c, t) ||
-        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */)) === 0 && isTypeAssignableTo(c, t, c.anyArrayType)));
+        ((t.flags & (1 /* TypeFlags.Any */ | 12 /* TypeFlags.Nullable */ | 262144 /* TypeFlags.Never */)) === 0 &&
+            isTypeAssignableTo(c, t, c.anyArrayType)));
 }
 function createArrayLiteralType(c, t) {
     if ((t.objectFlags & 4 /* ObjectFlags.Reference */) === 0)
@@ -899,36 +912,59 @@ export function getPropertyNameOfObjectLiteralElement(c, element) {
             return String(Number(getText(name)));
         case 9 /* SyntaxKind.BigIntLiteral */:
             return parseBigIntText(getText(name));
-        case 168 /* SyntaxKind.ComputedPropertyName */: {
+        case 169 /* SyntaxKind.ComputedPropertyName */: {
             const t = checkComputedPropertyName(c, name);
             return isTypeUsableAsPropertyName(t) ? getPropertyNameFromType(t) : undefined;
         }
     }
     return undefined;
 }
+/** Whether `node` is the object literal of the `with` property of an `import()` call's options argument. */
+function isInlineImportAttributes(node) {
+    const property = node.parent;
+    if (node.kind !== 212 /* SyntaxKind.ObjectLiteralExpression */ ||
+        property.kind !== 304 /* SyntaxKind.PropertyAssignment */ ||
+        getInitializer(property) !== node)
+        return false;
+    const name = getName(property);
+    if ((name.kind !== 79 /* SyntaxKind.Identifier */ && !isStringLiteralLike(name)) || getText(name) !== 'with')
+        return false;
+    const options = property.parent;
+    if (options.kind !== 212 /* SyntaxKind.ObjectLiteralExpression */)
+        return false;
+    let importCall = options;
+    while (importCall !== undefined && !isImportCall(importCall))
+        importCall = importCall.parent;
+    if (importCall === undefined)
+        return false;
+    const args = importCall.arguments.nodes;
+    return args.length > 1 && skipParentheses(args[1]) === options;
+}
 /** Whether `node` is in an `as const` context, where literals keep their types. */
 export function isConstContext(c, node) {
     const parent = node.parent;
     if (parent === undefined)
         return false;
+    if (isInlineImportAttributes(node))
+        return true;
     // Literals contextually typed by a `const` type parameter are in a const context.
     if (isValidConstAssertionArgument(c, node) && isConstTypeVariable(c, getContextualType(c, node), 0))
         return true;
     switch (parent.kind) {
-        case 235 /* SyntaxKind.AsExpression */:
-        case 217 /* SyntaxKind.TypeAssertionExpression */:
+        case 236 /* SyntaxKind.AsExpression */:
+        case 218 /* SyntaxKind.TypeAssertionExpression */:
             return isConstTypeReference(getType(parent));
         // As in tsgo, a const context does not reach through `satisfies` or into the branches of a
         // conditional expression: those are in one only when their own contextual type is a `const`
         // type parameter (above).
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 231 /* SyntaxKind.SpreadElement */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 232 /* SyntaxKind.SpreadElement */:
             return isConstContext(c, parent);
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
             return isConstContext(c, parent.parent);
-        case 240 /* SyntaxKind.TemplateSpan */:
+        case 241 /* SyntaxKind.TemplateSpan */:
             return isConstContext(c, parent.parent);
     }
     return false;
@@ -942,21 +978,21 @@ function isValidConstAssertionArgument(c, node) {
         case 9 /* SyntaxKind.BigIntLiteral */:
         case 111 /* SyntaxKind.TrueKeyword */:
         case 96 /* SyntaxKind.FalseKeyword */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
-        case 229 /* SyntaxKind.TemplateExpression */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
+        case 230 /* SyntaxKind.TemplateExpression */:
             return true;
-        case 218 /* SyntaxKind.ParenthesizedExpression */:
+        case 219 /* SyntaxKind.ParenthesizedExpression */:
             return isValidConstAssertionArgument(c, getExpression(node));
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = node;
             const kind = unary.operand.kind;
             return ((unary.operator === 40 /* SyntaxKind.MinusToken */ &&
                 (kind === 8 /* SyntaxKind.NumericLiteral */ || kind === 9 /* SyntaxKind.BigIntLiteral */)) ||
                 (unary.operator === 39 /* SyntaxKind.PlusToken */ && kind === 8 /* SyntaxKind.NumericLiteral */));
         }
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */: {
             const expr = skipParentheses(getExpression(node));
             const symbol = isEntityNameExpression(expr, false)
                 ? resolveEntityName(c, expr, 111551 /* SymbolFlags.Value */, true, false, undefined)
@@ -967,7 +1003,7 @@ function isValidConstAssertionArgument(c, node) {
     return false;
 }
 export function isConstTypeReference(node) {
-    if (node.kind !== 184 /* SyntaxKind.TypeReference */)
+    if (node.kind !== 185 /* SyntaxKind.TypeReference */)
         return false;
     const ref = node;
     return (ref.typeName.kind === 79 /* SyntaxKind.Identifier */ && getText(ref.typeName) === 'const' && ref.typeArguments === undefined);
@@ -1021,11 +1057,11 @@ export function checkNonNullTypeEx(c, t, node, isCallee) {
         if (isEntityNameExpression(node, false)) {
             const nodeText = entityNameToString(node);
             if (nodeText.length < 100) {
-                c.error(node, 1862 /* Diagnostics.X_0_is_of_type_unknown */, nodeText);
+                c.error(node, 1882 /* Diagnostics.X_0_is_of_type_unknown */, nodeText);
                 return c.errorType;
             }
         }
-        c.error(node, 724 /* Diagnostics.Object_is_of_type_unknown */);
+        c.error(node, 731 /* Diagnostics.Object_is_of_type_unknown */);
         return c.errorType;
     }
     const facts = getTypeFacts(c, t, 50331648 /* TypeFacts.IsUndefinedOrNull */);
@@ -1042,33 +1078,33 @@ export function checkNonNullTypeEx(c, t, node, isCallee) {
 function reportCannotInvokePossiblyNullOrUndefinedError(c, node, facts) {
     c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
         ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
-            ? 855 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined */
-            : 854 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined */
-        : 853 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null */);
+            ? 862 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null_or_undefined */
+            : 861 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_undefined */
+        : 860 /* Diagnostics.Cannot_invoke_an_object_which_is_possibly_null */);
 }
 function reportObjectPossiblyNullOrUndefinedError(c, node, facts) {
     if (node.kind === 105 /* SyntaxKind.NullKeyword */) {
-        c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, 'null');
+        c.error(node, 1886 /* Diagnostics.The_value_0_cannot_be_used_here */, 'null');
         return;
     }
     const nodeText = isEntityNameExpression(node, false) ? entityNameToString(node) : '';
     if (nodeText !== '' && nodeText.length < 100) {
         if (node.kind === 79 /* SyntaxKind.Identifier */ && nodeText === 'undefined') {
-            c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, 'undefined');
+            c.error(node, 1886 /* Diagnostics.The_value_0_cannot_be_used_here */, 'undefined');
             return;
         }
         c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
             ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
-                ? 1865 /* Diagnostics.X_0_is_possibly_null_or_undefined */
-                : 1864 /* Diagnostics.X_0_is_possibly_undefined */
-            : 1863 /* Diagnostics.X_0_is_possibly_null */, nodeText);
+                ? 1885 /* Diagnostics.X_0_is_possibly_null_or_undefined */
+                : 1884 /* Diagnostics.X_0_is_possibly_undefined */
+            : 1883 /* Diagnostics.X_0_is_possibly_null */, nodeText);
     }
     else {
         c.error(node, (facts & 16777216 /* TypeFacts.IsUndefined */) !== 0
             ? (facts & 33554432 /* TypeFacts.IsNull */) !== 0
-                ? 691 /* Diagnostics.Object_is_possibly_null_or_undefined */
-                : 690 /* Diagnostics.Object_is_possibly_undefined */
-            : 689 /* Diagnostics.Object_is_possibly_null */);
+                ? 698 /* Diagnostics.Object_is_possibly_null_or_undefined */
+                : 697 /* Diagnostics.Object_is_possibly_undefined */
+            : 696 /* Diagnostics.Object_is_possibly_null */);
     }
 }
 /** `checkNonNullType`, also reporting a `void` type as possibly undefined. */
@@ -1079,15 +1115,15 @@ export function checkNonNullNonVoidType(c, t, node) {
     if (isEntityNameExpression(node, false)) {
         const nodeText = entityNameToString(node);
         if (node.kind === 79 /* SyntaxKind.Identifier */ && nodeText === 'undefined') {
-            c.error(node, 1866 /* Diagnostics.The_value_0_cannot_be_used_here */, nodeText);
+            c.error(node, 1886 /* Diagnostics.The_value_0_cannot_be_used_here */, nodeText);
             return nonNullType;
         }
         if (nodeText.length < 100) {
-            c.error(node, 1864 /* Diagnostics.X_0_is_possibly_undefined */, nodeText);
+            c.error(node, 1884 /* Diagnostics.X_0_is_possibly_undefined */, nodeText);
             return nonNullType;
         }
     }
-    c.error(node, 690 /* Diagnostics.Object_is_possibly_undefined */);
+    c.error(node, 697 /* Diagnostics.Object_is_possibly_undefined */);
     return nonNullType;
 }
 export function entityNameToString(node) {
@@ -1096,13 +1132,13 @@ export function entityNameToString(node) {
             return getText(node);
         case 109 /* SyntaxKind.ThisKeyword */:
             return 'this';
-        case 212 /* SyntaxKind.PropertyAccessExpression */: {
+        case 213 /* SyntaxKind.PropertyAccessExpression */: {
             const access = node;
             return entityNameToString(access.expression) + '.' + entityNameToString(access.name);
         }
-        case 167 /* SyntaxKind.QualifiedName */: {
+        case 168 /* SyntaxKind.QualifiedName */: {
             const q = node;
-            return entityNameToString(q.left) + '.' + q.right.text;
+            return entityNameToString(q.left) + '.' + getText(q.right);
         }
     }
     return getText(node);
@@ -1137,41 +1173,37 @@ export function getFlowTypeOfAccessExpression(c, node, prop, propTypeIn, errorNo
     if (propType === c.autoType)
         return getFlowTypeOfAutoTypedProperty(c, node, prop);
     propType = getNarrowableTypeForReference(c, propType, node, checkMode);
-    // `this.x` in the constructor of x's class starts out uninitialized under strictPropertyInitialization.
+    // `this.x` in the constructor of x's class starts out uninitialized under strictPropertyInitialization,
+    // and a JavaScript `this.x = …` declaration is unassigned before it in its own function.
     let assumeUninitialized = false;
-    const expression = getExpression(node);
-    if (c.strictNullChecks &&
-        c.strictPropertyInitialization &&
-        expression !== undefined &&
-        expression.kind === 109 /* SyntaxKind.ThisKeyword */ &&
-        prop !== undefined) {
+    if (c.strictNullChecks && prop !== undefined) {
         const declaration = prop.valueDeclaration;
-        if (declaration !== undefined && isPropertyWithoutInitializer(declaration) && !isStatic(declaration)) {
-            const flowContainer = getControlFlowContainer(node);
-            assumeUninitialized =
-                flowContainer.kind === 177 /* SyntaxKind.Constructor */ &&
-                    flowContainer.parent === declaration.parent &&
-                    (declaration.flags & 8388608 /* NodeFlags.Ambient */) === 0;
+        const expression = getExpression(node);
+        if (c.strictPropertyInitialization && expression !== undefined && expression.kind === 109 /* SyntaxKind.ThisKeyword */) {
+            if (declaration !== undefined && isPropertyWithoutInitializer(declaration) && !isStatic(declaration)) {
+                const flowContainer = getControlFlowContainer(node);
+                assumeUninitialized =
+                    flowContainer.kind === 178 /* SyntaxKind.Constructor */ &&
+                        flowContainer.parent === declaration.parent &&
+                        (declaration.flags & 8388608 /* NodeFlags.Ambient */) === 0;
+            }
         }
-    }
-    // A JavaScript `this.x = …` declaration is unassigned before it in its own function.
-    if (c.strictNullChecks && prop !== undefined && !assumeUninitialized) {
-        const declaration = prop.valueDeclaration;
-        assumeUninitialized =
-            declaration instanceof BinaryExpression &&
-                declaration.left.kind === 212 /* SyntaxKind.PropertyAccessExpression */ &&
-                getControlFlowContainer(node) === getControlFlowContainer(declaration);
+        else
+            assumeUninitialized =
+                declaration instanceof BinaryExpression &&
+                    declaration.left.kind === 213 /* SyntaxKind.PropertyAccessExpression */ &&
+                    getControlFlowContainer(node) === getControlFlowContainer(declaration);
     }
     const initialType = assumeUninitialized ? getOptionalType(c, propType, false) : propType;
     const flowType = getFlowTypeOfReference(c, node, propType, initialType, undefined);
     if (assumeUninitialized && !containsUndefinedType(propType) && containsUndefinedType(flowType)) {
-        c.error(errorNode, 719 /* Diagnostics.Property_0_is_used_before_being_assigned */, symbolToString(c, prop));
+        c.error(errorNode, 726 /* Diagnostics.Property_0_is_used_before_being_assigned */, symbolToString(c, prop));
         return propType;
     }
     return assignmentKind !== 0 /* AssignmentKind.None */ ? getBaseTypeOfLiteralType(c, flowType) : flowType;
 }
 function isPropertyWithoutInitializer(node) {
-    return (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ &&
+    return (node.kind === 174 /* SyntaxKind.PropertyDeclaration */ &&
         !hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */) &&
         node.postfixToken === undefined &&
         getInitializer(node) === undefined);
@@ -1194,7 +1226,7 @@ function checkElementAccessExpression(c, node, _checkMode) {
     const isAssignment = assignmentKind !== 0 /* AssignmentKind.None */;
     const objectType = isAssignment || isMethodAccessForCall(node) ? getWidenedType(c, exprType) : exprType;
     if (isConstEnumObjectTypeLocal(objectType) && !isStringLiteralLike(indexExpression)) {
-        c.error(indexExpression, 640 /* Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal */);
+        c.error(indexExpression, 647 /* Diagnostics.A_const_enum_member_can_only_be_accessed_using_a_string_literal */);
         return c.errorType;
     }
     const effectiveIndexType = isForInVariableForNumericPropertyNames(c, indexExpression) ? c.numberType : indexType;
@@ -1214,18 +1246,14 @@ export function checkIndexedAccessIndexType(c, t, accessNode) {
         return t;
     const objectType = t.objectType;
     const indexType = t.indexType;
-    // Remapping mapped types don't defer their index types.
-    const objectIndexType = isGenericMappedType(c, objectType) &&
-        getMappedTypeNameTypeKind(c, objectType) === 2 /* MappedTypeNameTypeKind.Remapping */
-        ? getIndexForMappedType(c, objectType, 0 /* IndexFlags.None */)
-        : getIndexTypeEx(c, objectType, 0 /* IndexFlags.None */);
     const hasNumberIndexInfo = getIndexInfoOfType(c, objectType, c.numberType) !== undefined;
-    if (everyType(indexType, (u) => isTypeAssignableTo(c, u, objectIndexType) || (hasNumberIndexInfo && isApplicableIndexType(c, u, c.numberType)))) {
-        if (accessNode.kind === 213 /* SyntaxKind.ElementAccessExpression */ &&
+    if (everyType(indexType, (u) => isTypeAssignableTo(c, u, getIndexTypeEx(c, objectType, 0 /* IndexFlags.None */)) ||
+        (hasNumberIndexInfo && isApplicableIndexType(c, u, c.numberType)))) {
+        if (accessNode.kind === 214 /* SyntaxKind.ElementAccessExpression */ &&
             isAssignmentTarget(accessNode) &&
             (objectType.objectFlags & 32 /* ObjectFlags.Mapped */) !== 0 &&
             (getMappedTypeModifiers(objectType) & 1 /* MappedTypeModifiers.IncludeReadonly */) !== 0)
-            c.error(accessNode, 698 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, objectType));
+            c.error(accessNode, 705 /* Diagnostics.Index_signature_in_type_0_only_permits_reading */, typeToString(c, objectType));
         return t;
     }
     if (isGenericObjectType(c, objectType)) {
@@ -1236,12 +1264,12 @@ export function checkIndexedAccessIndexType(c, t, accessNode) {
                 (getDeclarationModifierFlagsFromSymbol(c, propertySymbol, false) &
                     6 /* ModifierFlags.NonPublicAccessibilityModifier */) !==
                     0) {
-                c.error(accessNode, 1091 /* Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter */, propertyName);
+                c.error(accessNode, 1098 /* Diagnostics.Private_or_protected_member_0_cannot_be_accessed_on_a_type_parameter */, propertyName);
                 return c.errorType;
             }
         }
     }
-    c.error(accessNode, 693 /* Diagnostics.Type_0_cannot_be_used_to_index_type_1 */, typeToString(c, indexType), typeToString(c, objectType));
+    c.error(accessNode, 700 /* Diagnostics.Type_0_cannot_be_used_to_index_type_1 */, typeToString(c, indexType), typeToString(c, objectType));
     return c.errorType;
 }
 function getConstituentProperty(c, objectType, propertyName) {
@@ -1275,7 +1303,7 @@ function isForInVariableForNumericPropertyNames(c, expr) {
     let child = expr;
     let node = expr.parent;
     while (node !== undefined) {
-        if (node.kind === 250 /* SyntaxKind.ForInStatement */) {
+        if (node.kind === 251 /* SyntaxKind.ForInStatement */) {
             const statement = node;
             if (child === statement.statement &&
                 getForInVariableSymbol(c, statement) === symbol &&
@@ -1289,7 +1317,7 @@ function isForInVariableForNumericPropertyNames(c, expr) {
 }
 function getForInVariableSymbol(c, node) {
     const initializer = node.initializer;
-    if (initializer.kind === 262 /* SyntaxKind.VariableDeclarationList */) {
+    if (initializer.kind === 263 /* SyntaxKind.VariableDeclarationList */) {
         const declarations = initializer.declarations.nodes;
         return declarations.length > 0 ? getSymbolOfDeclaration(c, declarations[0]) : undefined;
     }
@@ -1300,21 +1328,26 @@ function hasNumericPropertyNames(c, t) {
 }
 // ---- Assertions
 function checkAssertion(c, node, checkMode) {
+    if (node.kind === 218 /* SyntaxKind.TypeAssertionExpression */) {
+        const file = getSourceFileOfNode(node);
+        if (fileExtensionIsOneOf(file.fileName, ['.mts', '.cts']))
+            grammarErrorOnNode(c, node, 1749 /* Diagnostics.This_syntax_is_reserved_in_files_with_the_mts_or_cts_extension_Use_an_as_expression_instead */);
+    }
     // `<T>expr`, over `<T>`.
-    if (node.kind === 217 /* SyntaxKind.TypeAssertionExpression */ && shouldCheckErasableSyntax(c, node)) {
+    if (node.kind === 218 /* SyntaxKind.TypeAssertionExpression */ && shouldCheckErasableSyntax(c, node)) {
         const file = getSourceFileOfNode(node);
         c.addDiagnostic(new Diagnostic(file.diagnosticFile(), skipTrivia(file.text, node.pos), getExpression(node).pos, 243 /* Diagnostics.This_syntax_is_not_allowed_when_erasableSyntaxOnly_is_enabled */, []));
     }
+    const exprType = checkExpressionEx(c, getExpression(node), checkMode);
+    // The type node is checked in every case, including the `const` of `x as const`.
+    checkTypeNodeIfPresent(c, getType(node));
     if (isConstTypeReference(getType(node))) {
-        const exprType = checkExpressionEx(c, getExpression(node), checkMode);
         if (!isValidConstAssertionArgument(c, getExpression(node)))
             c.error(getExpression(node), 289 /* Diagnostics.A_const_assertion_can_only_be_applied_to_references_to_enum_members_or_string_number_boolean_array_or_object_literals */);
         return getRegularTypeOfLiteralType(c, exprType);
     }
-    const exprType = checkExpressionEx(c, getExpression(node), checkMode);
     // The operand is compared with the asserted type once, after the last check of the operand.
     c.nodeLinks(node).assertionExpressionType = exprType;
-    checkTypeNodeIfPresent(c, getType(node));
     checkNodeDeferred(c, node);
     return getTypeFromTypeNode(c, getType(node));
 }
@@ -1332,7 +1365,7 @@ function checkAssertionCompatibility(c, node, rawExprType, targetType) {
     if (isErrorType(c, targetType))
         return;
     if (!isTypeComparableTo(c, targetType, getWidenedType(c, exprType)))
-        checkTypeComparableTo(c, exprType, targetType, node, 528 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */);
+        checkTypeComparableTo(c, exprType, targetType, node, 535 /* Diagnostics.Conversion_of_type_0_to_type_1_may_be_a_mistake_because_neither_type_sufficiently_overlaps_with_the_other_If_this_was_intentional_convert_the_expression_to_unknown_first */);
 }
 function checkSatisfiesExpression(c, node, checkMode) {
     const expr = getExpression(node);