typescript 5.2.0-dev.20230612 → 5.2.0-dev.20230614

package/lib/tsserver.js

@@ -2305,7 +2305,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.2";
-var version = `${versionMajorMinor}.0-dev.20230612`;
+var version = `${versionMajorMinor}.0-dev.20230614`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -11227,6 +11227,9 @@ var Diagnostics = {
   Use_type_0: diag(95181, 3 /* Message */, "Use_type_0_95181", "Use 'type {0}'"),
   Fix_all_with_type_only_imports: diag(95182, 3 /* Message */, "Fix_all_with_type_only_imports_95182", "Fix all with type-only imports"),
   Cannot_move_statements_to_the_selected_file: diag(95183, 3 /* Message */, "Cannot_move_statements_to_the_selected_file_95183", "Cannot move statements to the selected file"),
+  Inline_variable: diag(95184, 3 /* Message */, "Inline_variable_95184", "Inline variable"),
+  Could_not_find_variable_to_inline: diag(95185, 3 /* Message */, "Could_not_find_variable_to_inline_95185", "Could not find variable to inline."),
+  Variables_with_multiple_declarations_cannot_be_inlined: diag(95186, 3 /* Message */, "Variables_with_multiple_declarations_cannot_be_inlined_95186", "Variables with multiple declarations cannot be inlined."),
   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?"),
@@ -47322,11 +47325,10 @@ var CheckMode = /* @__PURE__ */ ((CheckMode3) => {
   CheckMode3[CheckMode3["Inferential"] = 2] = "Inferential";
   CheckMode3[CheckMode3["SkipContextSensitive"] = 4] = "SkipContextSensitive";
   CheckMode3[CheckMode3["SkipGenericFunctions"] = 8] = "SkipGenericFunctions";
-  CheckMode3[CheckMode3["SkipAddingIntraExpressionSites"] = 16] = "SkipAddingIntraExpressionSites";
-  CheckMode3[CheckMode3["IsForSignatureHelp"] = 32] = "IsForSignatureHelp";
-  CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 64] = "IsForStringLiteralArgumentCompletions";
-  CheckMode3[CheckMode3["RestBindingElement"] = 128] = "RestBindingElement";
-  CheckMode3[CheckMode3["TypeOnly"] = 256] = "TypeOnly";
+  CheckMode3[CheckMode3["IsForSignatureHelp"] = 16] = "IsForSignatureHelp";
+  CheckMode3[CheckMode3["IsForStringLiteralArgumentCompletions"] = 32] = "IsForStringLiteralArgumentCompletions";
+  CheckMode3[CheckMode3["RestBindingElement"] = 64] = "RestBindingElement";
+  CheckMode3[CheckMode3["TypeOnly"] = 128] = "TypeOnly";
   return CheckMode3;
 })(CheckMode || {});
 var SignatureCheckMode = /* @__PURE__ */ ((SignatureCheckMode3) => {
@@ -47601,14 +47603,25 @@ function createTypeChecker(host) {
     getTypeOfPropertyOfContextualType,
     getFullyQualifiedName,
     getResolvedSignature: (node, candidatesOutArray, argumentCount) => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 0 /* Normal */),
-    getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray) => runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(
-      call,
-      candidatesOutArray,
-      /*argumentCount*/
-      void 0,
-      64 /* IsForStringLiteralArgumentCompletions */
-    )),
-    getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 32 /* IsForSignatureHelp */)),
+    getResolvedSignatureForStringLiteralCompletions: (call, editingArgument, candidatesOutArray, checkMode = 32 /* IsForStringLiteralArgumentCompletions */) => {
+      if (checkMode & 32 /* IsForStringLiteralArgumentCompletions */) {
+        return runWithInferenceBlockedFromSourceNode(editingArgument, () => getResolvedSignatureWorker(
+          call,
+          candidatesOutArray,
+          /*argumentCount*/
+          void 0,
+          checkMode & ~32 /* IsForStringLiteralArgumentCompletions */
+        ));
+      }
+      return runWithoutResolvedSignatureCaching(editingArgument, () => getResolvedSignatureWorker(
+        call,
+        candidatesOutArray,
+        /*argumentCount*/
+        void 0,
+        checkMode & ~32 /* IsForStringLiteralArgumentCompletions */
+      ));
+    },
+    getResolvedSignatureForSignatureHelp: (node, candidatesOutArray, argumentCount) => runWithoutResolvedSignatureCaching(node, () => getResolvedSignatureWorker(node, candidatesOutArray, argumentCount, 16 /* IsForSignatureHelp */)),
     getExpandedParameters,
     hasEffectiveRestParameter,
     containsArgumentsReference,
@@ -55434,9 +55447,15 @@ function createTypeChecker(host) {
     const prop = getPropertyOfType(type, name);
     return prop ? getTypeOfSymbol(prop) : void 0;
   }
-  function getTypeOfPropertyOrIndexSignature(type, name) {
+  function getTypeOfPropertyOrIndexSignature(type, name, addOptionalityToIndex) {
     var _a;
-    return getTypeOfPropertyOfType(type, name) || ((_a = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a.type) || unknownType;
+    let propType;
+    return getTypeOfPropertyOfType(type, name) || (propType = (_a = getApplicableIndexInfoForName(type, name)) == null ? void 0 : _a.type) && addOptionality(
+      propType,
+      /*isProperty*/
+      true,
+      addOptionalityToIndex
+    ) || unknownType;
   }
   function isTypeAny(type) {
     return type && (type.flags & 1 /* Any */) !== 0;
@@ -55563,7 +55582,7 @@ function createTypeChecker(host) {
     return type.flags & (128 /* StringLiteral */ | 256 /* NumberLiteral */) ? "" + type.value : void 0;
   }
   function getTypeForBindingElement(declaration) {
-    const checkMode = declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+    const checkMode = declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
     const parentType = getTypeForBindingElementParent(declaration.parent.parent, checkMode);
     return parentType && getBindingElementTypeFromParentType(declaration, parentType);
   }
@@ -57320,19 +57339,13 @@ function createTypeChecker(host) {
     if (getObjectFlags(type) & 4 /* Reference */) {
       const target = type.target;
       const typeArguments = getTypeArguments(type);
-      if (length(target.typeParameters) === length(typeArguments)) {
-        const ref = createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
-        return needApparentType ? getApparentType(ref) : ref;
-      }
+      return length(target.typeParameters) === length(typeArguments) ? createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType])) : type;
     } else if (type.flags & 2097152 /* Intersection */) {
       const types = sameMap(type.types, (t) => getTypeWithThisArgument(t, thisArgument, needApparentType));
       return types !== type.types ? getIntersectionType(types) : type;
     }
     return needApparentType ? getApparentType(type) : type;
   }
-  function getThisArgument(type) {
-    return getObjectFlags(type) & 4 /* Reference */ && length(getTypeArguments(type)) > getTypeReferenceArity(type) ? last(getTypeArguments(type)) : type;
-  }
   function resolveObjectTypeMembers(type, source, typeParameters, typeArguments) {
     let mapper;
     let members;
@@ -58398,7 +58411,7 @@ function createTypeChecker(host) {
       return type.resolvedBaseConstraint;
     }
     const stack = [];
-    return type.resolvedBaseConstraint = getTypeWithThisArgument(getImmediateBaseConstraint(type), getThisArgument(type));
+    return type.resolvedBaseConstraint = getImmediateBaseConstraint(type);
     function getImmediateBaseConstraint(t) {
       if (!t.immediateBaseConstraint) {
         if (!pushTypeResolution(t, 4 /* ImmediateBaseConstraint */)) {
@@ -58490,18 +58503,18 @@ function createTypeChecker(host) {
       }
       if (isGenericTupleType(t)) {
         const newElements = map(getElementTypes(t), (v, i) => {
-          const constraint = t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
-          return constraint && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
+          const constraint = v.flags & 262144 /* TypeParameter */ && t.target.elementFlags[i] & 8 /* Variadic */ && getBaseConstraint(v) || v;
+          return constraint !== v && everyType(constraint, (c) => isArrayOrTupleType(c) && !isGenericTupleType(c)) ? constraint : v;
         });
         return createTupleType(newElements, t.target.elementFlags, t.target.readonly, t.target.labeledElementDeclarations);
       }
       return t;
     }
   }
-  function getApparentTypeOfIntersectionType(type) {
+  function getApparentTypeOfIntersectionType(type, thisArgument) {
     return type.resolvedApparentType || (type.resolvedApparentType = getTypeWithThisArgument(
       type,
-      type,
+      thisArgument,
       /*needApparentType*/
       true
     ));
@@ -58552,8 +58565,9 @@ function createTypeChecker(host) {
     return !!(type.flags & 8388608 /* IndexedAccess */ && getObjectFlags(objectType = type.objectType) & 32 /* Mapped */ && !isGenericMappedType(objectType) && isGenericIndexType(type.indexType) && !(getMappedTypeModifiers(objectType) & 8 /* ExcludeOptional */) && !objectType.declaration.nameType);
   }
   function getApparentType(type) {
-    const t = !(type.flags & 465829888 /* Instantiable */) ? type : getBaseConstraintOfType(type) || unknownType;
-    return getObjectFlags(t) & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
+    const t = type.flags & 465829888 /* Instantiable */ ? getBaseConstraintOfType(type) || unknownType : type;
+    const objectFlags = getObjectFlags(t);
+    return objectFlags & 32 /* Mapped */ ? getApparentTypeOfMappedType(t) : objectFlags & 4 /* Reference */ && t !== type ? getTypeWithThisArgument(t, type) : t.flags & 2097152 /* Intersection */ ? getApparentTypeOfIntersectionType(t, type) : t.flags & 402653316 /* StringLike */ ? globalStringType : t.flags & 296 /* NumberLike */ ? globalNumberType : t.flags & 2112 /* BigIntLike */ ? getGlobalBigIntType() : t.flags & 528 /* BooleanLike */ ? globalBooleanType : t.flags & 12288 /* ESSymbolLike */ ? getGlobalESSymbolType() : t.flags & 67108864 /* NonPrimitive */ ? emptyObjectType : t.flags & 4194304 /* Index */ ? keyofConstraintType : t.flags & 2 /* Unknown */ && !strictNullChecks ? emptyObjectType : t;
   }
   function getReducedApparentType(type) {
     return getReducedType(getApparentType(getReducedType(type)));
@@ -65382,7 +65396,7 @@ function createTypeChecker(host) {
           return 3 /* Maybe */;
         }
         const c = target2;
-        if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
+        if (!c.root.inferTypeParameters && !isDistributionDependent(c.root) && !(source2.flags & 16777216 /* Conditional */ && source2.root === c.root)) {
           const skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
           const skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
           if (result2 = skipTrue ? -1 /* True */ : isRelatedTo(
@@ -66443,7 +66457,12 @@ function createTypeChecker(host) {
       let matched = false;
       for (let i = 0; i < types.length; i++) {
         if (include[i]) {
-          const targetType = getTypeOfPropertyOfType(types[i], propertyName);
+          const targetType = getTypeOfPropertyOrIndexSignature(
+            types[i],
+            propertyName,
+            /*addOptionalityToIndex*/
+            true
+          );
           if (targetType && related(getDiscriminatingType(), targetType)) {
             matched = true;
           } else {
@@ -68374,7 +68393,7 @@ function createTypeChecker(host) {
       const constraint = getConstraintOfTypeParameter(inference.typeParameter);
       if (constraint) {
         const instantiatedConstraint = instantiateType(constraint, context.nonFixingMapper);
-        if (!inferredType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
+        if (!inferredType || inferredType === wildcardType || !context.compareTypes(inferredType, getTypeWithThisArgument(instantiatedConstraint, inferredType))) {
           inference.inferredType = fallbackType && context.compareTypes(fallbackType, getTypeWithThisArgument(instantiatedConstraint, fallbackType)) ? fallbackType : instantiatedConstraint;
         }
       }
@@ -69841,7 +69860,12 @@ function createTypeChecker(host) {
       propType = removeNullable && optionalChain ? getOptionalType(propType) : propType;
       const narrowedPropType = narrowType2(propType);
       return filterType(type, (t) => {
-        const discriminantType = getTypeOfPropertyOrIndexSignature(t, propName);
+        const discriminantType = getTypeOfPropertyOrIndexSignature(
+          t,
+          propName,
+          /*addOptionalityToIndex*/
+          false
+        );
         return !(discriminantType.flags & 131072 /* Never */) && !(narrowedPropType.flags & 131072 /* Never */) && areTypesComparable(narrowedPropType, discriminantType);
       });
     }
@@ -70468,7 +70492,7 @@ function createTypeChecker(host) {
     return type.flags & 2097152 /* Intersection */ ? some(type.types, isGenericTypeWithoutNullableConstraint) : !!(type.flags & 465829888 /* Instantiable */ && !maybeTypeOfKind(getBaseConstraintOrType(type), 98304 /* Nullable */));
   }
   function hasContextualTypeWithNoGenericTypes(node, checkMode) {
-    const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 128 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
+    const contextualType = (isIdentifier(node) || isPropertyAccessExpression(node) || isElementAccessExpression(node)) && !((isJsxOpeningElement(node.parent) || isJsxSelfClosingElement(node.parent)) && node.parent.tagName === node) && (checkMode && checkMode & 64 /* RestBindingElement */ ? getContextualType2(node, 8 /* SkipBindingPatterns */) : getContextualType2(
       node,
       /*contextFlags*/
       void 0
@@ -71115,6 +71139,25 @@ function createTypeChecker(host) {
       return t.flags & 2097152 /* Intersection */ ? forEach(t.types, getThisTypeArgument) : getThisTypeArgument(t);
     });
   }
+  function getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType) {
+    let literal = containingLiteral;
+    let type = contextualType;
+    while (type) {
+      const thisType = getThisTypeFromContextualType(type);
+      if (thisType) {
+        return thisType;
+      }
+      if (literal.parent.kind !== 302 /* PropertyAssignment */) {
+        break;
+      }
+      literal = literal.parent.parent;
+      type = getApparentTypeOfContextualType(
+        literal,
+        /*contextFlags*/
+        void 0
+      );
+    }
+  }
   function getContextualThisParameterType(func) {
     if (func.kind === 218 /* ArrowFunction */) {
       return void 0;
@@ -71137,22 +71180,9 @@ function createTypeChecker(host) {
           /*contextFlags*/
           void 0
         );
-        let literal = containingLiteral;
-        let type = contextualType;
-        while (type) {
-          const thisType = getThisTypeFromContextualType(type);
-          if (thisType) {
-            return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
-          }
-          if (literal.parent.kind !== 302 /* PropertyAssignment */) {
-            break;
-          }
-          literal = literal.parent.parent;
-          type = getApparentTypeOfContextualType(
-            literal,
-            /*contextFlags*/
-            void 0
-          );
+        const thisType = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
+        if (thisType) {
+          return instantiateType(thisType, getMapperFromContext(getInferenceContext(containingLiteral)));
         }
         return getWidenedType(contextualType ? getNonNullableType(contextualType) : checkExpressionCached(containingLiteral));
       }
@@ -71225,7 +71255,7 @@ function createTypeChecker(host) {
   function getContextualTypeForBindingElement(declaration, contextFlags) {
     const parent2 = declaration.parent.parent;
     const name = declaration.propertyName || declaration.name;
-    const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */);
+    const parentType = getContextualTypeForVariableLikeDeclaration(parent2, contextFlags) || parent2.kind !== 207 /* BindingElement */ && parent2.initializer && checkDeclarationInitializer(parent2, declaration.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */);
     if (!parentType || isBindingPattern(name) || isComputedNonLiteralName(name))
       return void 0;
     if (parent2.name.kind === 206 /* ArrayBindingPattern */) {
@@ -72274,9 +72304,7 @@ function createTypeChecker(host) {
         elementTypes.push(undefinedOrMissingType);
         elementFlags.push(2 /* Optional */);
       } else {
-        const shouldAddAsIntraExpressionInferenceSite = inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(e);
-        const elementCheckMode = (checkMode || 0 /* Normal */) | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        const type = checkExpressionForMutableLocation(e, elementCheckMode, forceTuple);
+        const type = checkExpressionForMutableLocation(e, checkMode, forceTuple);
         elementTypes.push(addOptionality(
           type,
           /*isProperty*/
@@ -72284,7 +72312,7 @@ function createTypeChecker(host) {
           hasOmittedExpression
         ));
         elementFlags.push(hasOmittedExpression ? 2 /* Optional */ : 1 /* Required */);
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (inTupleContext && checkMode && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(e)) {
           const inferenceContext = getInferenceContext(node);
           Debug.assert(inferenceContext);
           addIntraExpressionInferenceSite(inferenceContext, e, type);
@@ -72425,13 +72453,11 @@ function createTypeChecker(host) {
       let member = getSymbolOfDeclaration(memberDecl);
       const computedNameType = memberDecl.name && memberDecl.name.kind === 166 /* ComputedPropertyName */ ? checkComputedPropertyName(memberDecl.name) : void 0;
       if (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 303 /* ShorthandPropertyAssignment */ || isObjectLiteralMethod(memberDecl)) {
-        const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl);
-        const propCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, propCheckMode) : (
+        let type = memberDecl.kind === 302 /* PropertyAssignment */ ? checkPropertyAssignment(memberDecl, checkMode) : (
           // avoid resolving the left side of the ShorthandPropertyAssignment outside of the destructuring
           // for error recovery purposes. For example, if a user wrote `{ a = 100 }` instead of `{ a: 100 }`.
           // we don't want to say "could not find 'a'".
-          memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, propCheckMode) : checkObjectLiteralMethod(memberDecl, propCheckMode)
+          memberDecl.kind === 303 /* ShorthandPropertyAssignment */ ? checkExpressionForMutableLocation(!inDestructuringPattern && memberDecl.objectAssignmentInitializer ? memberDecl.objectAssignmentInitializer : memberDecl.name, checkMode) : checkObjectLiteralMethod(memberDecl, checkMode)
         );
         if (isInJavascript) {
           const jsDocType = getTypeForDeclarationFromJSDocComment(memberDecl);
@@ -72475,7 +72501,7 @@ function createTypeChecker(host) {
         prop.links.target = member;
         member = prop;
         allPropertiesTable == null ? void 0 : allPropertiesTable.set(prop.escapedName, prop);
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && (memberDecl.kind === 302 /* PropertyAssignment */ || memberDecl.kind === 173 /* MethodDeclaration */) && isContextSensitive(memberDecl)) {
           const inferenceContext = getInferenceContext(node);
           Debug.assert(inferenceContext);
           const inferenceNode = memberDecl.kind === 302 /* PropertyAssignment */ ? memberDecl.initializer : memberDecl;
@@ -72648,9 +72674,7 @@ function createTypeChecker(host) {
     for (const attributeDecl of attributes.properties) {
       const member = attributeDecl.symbol;
       if (isJsxAttribute(attributeDecl)) {
-        const shouldAddAsIntraExpressionInferenceSite = contextualType && checkMode & 2 /* Inferential */ && !(checkMode & (4 /* SkipContextSensitive */ | 16 /* SkipAddingIntraExpressionSites */)) && isContextSensitive(attributeDecl);
-        const attributeCheckMode = checkMode | (shouldAddAsIntraExpressionInferenceSite ? 16 /* SkipAddingIntraExpressionSites */ : 0);
-        const exprType = checkJsxAttribute(attributeDecl, attributeCheckMode);
+        const exprType = checkJsxAttribute(attributeDecl, checkMode);
         objectFlags |= getObjectFlags(exprType) & 458752 /* PropagatingFlags */;
         const attributeSymbol = createSymbol(4 /* Property */ | member.flags, member.escapedName);
         attributeSymbol.declarations = member.declarations;
@@ -72671,7 +72695,7 @@ function createTypeChecker(host) {
             addDeprecatedSuggestion(attributeDecl.name, prop.declarations, attributeDecl.name.escapedText);
           }
         }
-        if (shouldAddAsIntraExpressionInferenceSite) {
+        if (contextualType && checkMode & 2 /* Inferential */ && !(checkMode & 4 /* SkipContextSensitive */) && isContextSensitive(attributeDecl)) {
           const inferenceContext = getInferenceContext(attributes);
           Debug.assert(inferenceContext);
           const inferenceNode = attributeDecl.initializer.expression;
@@ -74289,7 +74313,7 @@ function createTypeChecker(host) {
     }
     for (let i = 0; i < argCount; i++) {
       const arg = args[i];
-      if (arg.kind !== 231 /* OmittedExpression */ && !(checkMode & 64 /* IsForStringLiteralArgumentCompletions */ && hasSkipDirectInferenceFlag(arg))) {
+      if (arg.kind !== 231 /* OmittedExpression */) {
         const paramType = getTypeAtPosition(signature, i);
         if (couldContainTypeVariables(paramType)) {
           const argType = checkExpressionWithContextualType(arg, paramType, context, checkMode);
@@ -74902,12 +74926,11 @@ function createTypeChecker(host) {
     const args = getEffectiveCallArguments(node);
     const isSingleNonGenericCandidate = candidates.length === 1 && !candidates[0].typeParameters;
     let argCheckMode = !isDecorator2 && !isSingleNonGenericCandidate && some(args, isContextSensitive) ? 4 /* SkipContextSensitive */ : 0 /* Normal */;
-    argCheckMode |= checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
     let candidatesForArgumentError;
     let candidateForArgumentArityError;
     let candidateForTypeArgumentError;
     let result;
-    const signatureHelpTrailingComma = !!(checkMode & 32 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
+    const signatureHelpTrailingComma = !!(checkMode & 16 /* IsForSignatureHelp */) && node.kind === 212 /* CallExpression */ && node.arguments.hasTrailingComma;
     if (candidates.length > 1) {
       result = chooseOverload(candidates, subtypeRelation, isSingleNonGenericCandidate, signatureHelpTrailingComma);
     }
@@ -75126,7 +75149,7 @@ function createTypeChecker(host) {
           continue;
         }
         if (argCheckMode) {
-          argCheckMode = checkMode & 64 /* IsForStringLiteralArgumentCompletions */;
+          argCheckMode = 0 /* Normal */;
           if (inferenceContext) {
             const typeArgumentTypes = inferTypeArguments(node, candidate, args, argCheckMode, inferenceContext);
             checkCandidate = getSignatureInstantiation(candidate, typeArgumentTypes, isInJSFile(candidate.declaration), inferenceContext.inferredTypeParameters);
@@ -78204,8 +78227,9 @@ function createTypeChecker(host) {
       case 36 /* ExclamationEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
       case 38 /* ExclamationEqualsEqualsToken */:
-        if (!(checkMode && checkMode & 256 /* TypeOnly */)) {
-          if (isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) {
+        if (!(checkMode && checkMode & 128 /* TypeOnly */)) {
+          if ((isLiteralExpressionOfObject(left) || isLiteralExpressionOfObject(right)) && // only report for === and !== in JS, not == or !=
+          (!isInJSFile(left) || (operator === 37 /* EqualsEqualsEqualsToken */ || operator === 38 /* ExclamationEqualsEqualsToken */))) {
             const eqType = operator === 35 /* EqualsEqualsToken */ || operator === 37 /* EqualsEqualsEqualsToken */;
             error2(errorNode, Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value, eqType ? "false" : "true");
           }
@@ -78863,7 +78887,7 @@ function createTypeChecker(host) {
       }
     }
     const startInvocationCount = flowInvocationCount;
-    const type = checkExpression(node, 256 /* TypeOnly */);
+    const type = checkExpression(node, 128 /* TypeOnly */);
     if (flowInvocationCount !== startInvocationCount) {
       const cache = flowTypeCache || (flowTypeCache = []);
       cache[getNodeId(node)] = type;
@@ -78978,7 +79002,7 @@ function createTypeChecker(host) {
         return nullWideningType;
       case 15 /* NoSubstitutionTemplateLiteral */:
       case 11 /* StringLiteral */:
-        return hasSkipDirectInferenceFlag(node) ? anyType : getFreshTypeOfLiteralType(getStringLiteralType(node.text));
+        return hasSkipDirectInferenceFlag(node) ? wildcardType : getFreshTypeOfLiteralType(getStringLiteralType(node.text));
       case 9 /* NumericLiteral */:
         checkGrammarNumericLiteral(node);
         return getFreshTypeOfLiteralType(getNumberLiteralType(+node.text));
@@ -81334,7 +81358,7 @@ function createTypeChecker(host) {
         checkComputedPropertyName(node.propertyName);
       }
       const parent2 = node.parent.parent;
-      const parentCheckMode = node.dotDotDotToken ? 128 /* RestBindingElement */ : 0 /* Normal */;
+      const parentCheckMode = node.dotDotDotToken ? 64 /* RestBindingElement */ : 0 /* Normal */;
       const parentType = getTypeForBindingElementParent(parent2, parentCheckMode);
       const name = node.propertyName || node.name;
       if (parentType && !isBindingPattern(name)) {
@@ -84924,7 +84948,7 @@ function createTypeChecker(host) {
             /*contextFlags*/
             void 0
           );
-          const type = contextualType && getThisTypeFromContextualType(contextualType);
+          const type = getThisTypeOfObjectLiteralFromContextualType(containingLiteral, contextualType);
           return type && !isTypeAny(type);
         }
       }
@@ -118643,7 +118667,9 @@ var plainJSErrors = /* @__PURE__ */ new Set([
   Diagnostics.let_is_not_allowed_to_be_used_as_a_name_in_let_or_const_declarations.code,
   Diagnostics.Class_constructor_may_not_be_a_generator.code,
   Diagnostics.Class_constructor_may_not_be_an_accessor.code,
-  Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code
+  Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules.code,
+  // Type errors
+  Diagnostics.This_condition_will_always_return_0_since_JavaScript_compares_objects_by_reference_not_value.code
 ]);
 function shouldProgramCreateNewSourceFiles(program, newOptions) {
   if (!program)
@@ -135666,8 +135692,8 @@ function getApplicableRefactors(context, includeInteractiveActions) {
     return context.cancellationToken && context.cancellationToken.isCancellationRequested() || !((_a = refactor.kinds) == null ? void 0 : _a.some((kind) => refactorKindBeginsWith(kind, context.kind))) ? void 0 : refactor.getAvailableActions(context, includeInteractiveActions);
   }));
 }
-function getEditsForRefactor(context, refactorName13, actionName2, interactiveRefactorArguments) {
-  const refactor = refactors.get(refactorName13);
+function getEditsForRefactor(context, refactorName14, actionName2, interactiveRefactorArguments) {
+  const refactor = refactors.get(refactorName14);
   return refactor && refactor.getEditsForAction(context, actionName2, interactiveRefactorArguments);
 }
 
@@ -136435,24 +136461,165 @@ function refactorKindBeginsWith(known, requested) {
   return known.substr(0, requested.length) === requested;
 }
 
+// src/services/refactors/inlineVariable.ts
+var refactorName4 = "Inline variable";
+var refactorDescription = getLocaleSpecificMessage(Diagnostics.Inline_variable);
+var inlineVariableAction = {
+  name: refactorName4,
+  description: refactorDescription,
+  kind: "refactor.inline.variable"
+};
+registerRefactor(refactorName4, {
+  kinds: [inlineVariableAction.kind],
+  getAvailableActions(context) {
+    const {
+      file,
+      program,
+      preferences,
+      startPosition,
+      triggerReason
+    } = context;
+    const info = getInliningInfo(file, startPosition, triggerReason === "invoked", program);
+    if (!info) {
+      return emptyArray;
+    }
+    if (!ts_refactor_exports.isRefactorErrorInfo(info)) {
+      return [{
+        name: refactorName4,
+        description: refactorDescription,
+        actions: [inlineVariableAction]
+      }];
+    }
+    if (preferences.provideRefactorNotApplicableReason) {
+      return [{
+        name: refactorName4,
+        description: refactorDescription,
+        actions: [{
+          ...inlineVariableAction,
+          notApplicableReason: info.error
+        }]
+      }];
+    }
+    return emptyArray;
+  },
+  getEditsForAction(context, actionName2) {
+    Debug.assert(actionName2 === refactorName4, "Unexpected refactor invoked");
+    const { file, program, startPosition } = context;
+    const info = getInliningInfo(
+      file,
+      startPosition,
+      /*tryWithReferenceToken*/
+      true,
+      program
+    );
+    if (!info || ts_refactor_exports.isRefactorErrorInfo(info)) {
+      return void 0;
+    }
+    const { references, declaration, replacement } = info;
+    const edits = ts_textChanges_exports.ChangeTracker.with(context, (tracker) => {
+      for (const node of references) {
+        tracker.replaceNode(file, node, getReplacementExpression(node, replacement));
+      }
+      tracker.delete(file, declaration);
+    });
+    return { edits };
+  }
+});
+function getInliningInfo(file, startPosition, tryWithReferenceToken, program) {
+  var _a, _b;
+  const checker = program.getTypeChecker();
+  const token = getTouchingPropertyName(file, startPosition);
+  const parent2 = token.parent;
+  if (!isIdentifier(token)) {
+    return void 0;
+  }
+  if (isInitializedVariable(parent2) && isVariableDeclarationInVariableStatement(parent2)) {
+    if (((_a = checker.getMergedSymbol(parent2.symbol).declarations) == null ? void 0 : _a.length) !== 1) {
+      return { error: getLocaleSpecificMessage(Diagnostics.Variables_with_multiple_declarations_cannot_be_inlined) };
+    }
+    if (isDeclarationExported(parent2)) {
+      return void 0;
+    }
+    const references = getReferenceNodes(parent2, checker, file);
+    return references && { references, declaration: parent2, replacement: parent2.initializer };
+  }
+  if (tryWithReferenceToken) {
+    let definition = checker.resolveName(
+      token.text,
+      token,
+      111551 /* Value */,
+      /*excludeGlobals*/
+      false
+    );
+    definition = definition && checker.getMergedSymbol(definition);
+    if (((_b = definition == null ? void 0 : definition.declarations) == null ? void 0 : _b.length) !== 1) {
+      return { error: getLocaleSpecificMessage(Diagnostics.Variables_with_multiple_declarations_cannot_be_inlined) };
+    }
+    const declaration = definition.declarations[0];
+    if (!isInitializedVariable(declaration) || !isVariableDeclarationInVariableStatement(declaration) || !isIdentifier(declaration.name)) {
+      return void 0;
+    }
+    if (isDeclarationExported(declaration)) {
+      return void 0;
+    }
+    const references = getReferenceNodes(declaration, checker, file);
+    return references && { references, declaration, replacement: declaration.initializer };
+  }
+  return { error: getLocaleSpecificMessage(Diagnostics.Could_not_find_variable_to_inline) };
+}
+function isDeclarationExported(declaration) {
+  const variableStatement = cast(declaration.parent.parent, isVariableStatement);
+  return some(variableStatement.modifiers, isExportModifier);
+}
+function getReferenceNodes(declaration, checker, file) {
+  const references = [];
+  const cannotInline = ts_FindAllReferences_exports.Core.eachSymbolReferenceInFile(declaration.name, checker, file, (ref) => {
+    if (ts_FindAllReferences_exports.isWriteAccessForReference(ref)) {
+      return true;
+    }
+    if (isExportSpecifier(ref.parent) || isExportAssignment(ref.parent)) {
+      return true;
+    }
+    if (isTypeQueryNode(ref.parent)) {
+      return true;
+    }
+    if (textRangeContainsPositionInclusive(declaration, ref.pos)) {
+      return true;
+    }
+    references.push(ref);
+  });
+  return references.length === 0 || cannotInline ? void 0 : references;
+}
+function getReplacementExpression(reference, replacement) {
+  replacement = getSynthesizedDeepClone(replacement);
+  const { parent: parent2 } = reference;
+  if (isExpression(parent2) && (getExpressionPrecedence(replacement) < getExpressionPrecedence(parent2) || needsParentheses(parent2))) {
+    return factory.createParenthesizedExpression(replacement);
+  }
+  if (isFunctionLike(replacement) && isCallLikeExpression(parent2)) {
+    return factory.createParenthesizedExpression(replacement);
+  }
+  return replacement;
+}
+
 // src/services/refactors/moveToNewFile.ts
-var refactorName4 = "Move to a new file";
+var refactorName5 = "Move to a new file";
 var description = getLocaleSpecificMessage(Diagnostics.Move_to_a_new_file);
 var moveToNewFileAction = {
-  name: refactorName4,
+  name: refactorName5,
   description,
   kind: "refactor.move.newFile"
 };
-registerRefactor(refactorName4, {
+registerRefactor(refactorName5, {
   kinds: [moveToNewFileAction.kind],
   getAvailableActions: function getRefactorActionsToMoveToNewFile(context) {
     const statements = getStatementsToMove(context);
     if (context.preferences.allowTextChangesInNewFiles && statements) {
-      return [{ name: refactorName4, description, actions: [moveToNewFileAction] }];
+      return [{ name: refactorName5, description, actions: [moveToNewFileAction] }];
     }
     if (context.preferences.provideRefactorNotApplicableReason) {
       return [{
-        name: refactorName4,
+        name: refactorName5,
         description,
         actions: [{ ...moveToNewFileAction, notApplicableReason: getLocaleSpecificMessage(Diagnostics.Selection_is_not_a_valid_statement_or_statements) }]
       }];
@@ -136460,7 +136627,7 @@ registerRefactor(refactorName4, {
     return emptyArray;
   },
   getEditsForAction: function getRefactorEditsToMoveToNewFile(context, actionName2) {
-    Debug.assert(actionName2 === refactorName4, "Wrong refactor invoked");
+    Debug.assert(actionName2 === refactorName5, "Wrong refactor invoked");
     const statements = Debug.checkDefined(getStatementsToMove(context));
     const edits = ts_textChanges_exports.ChangeTracker.with(context, (t) => doChange3(context.file, context.program, statements, t, context.host, context.preferences, context));
     return { edits, renameFilename: void 0, renameLocation: void 0 };
@@ -137444,14 +137611,14 @@ function getOverloadRangeToMove(sourceFile, statement) {
 var ts_refactor_addOrRemoveBracesToArrowFunction_exports = {};
 
 // src/services/refactors/convertOverloadListToSingleSignature.ts
-var refactorName5 = "Convert overload list to single signature";
-var refactorDescription = getLocaleSpecificMessage(Diagnostics.Convert_overload_list_to_single_signature);
+var refactorName6 = "Convert overload list to single signature";
+var refactorDescription2 = getLocaleSpecificMessage(Diagnostics.Convert_overload_list_to_single_signature);
 var functionOverloadAction = {
-  name: refactorName5,
-  description: refactorDescription,
+  name: refactorName6,
+  description: refactorDescription2,
   kind: "refactor.rewrite.function.overloadList"
 };
-registerRefactor(refactorName5, {
+registerRefactor(refactorName6, {
   kinds: [functionOverloadAction.kind],
   getEditsForAction: getRefactorEditsToConvertOverloadsToOneSignature,
   getAvailableActions: getRefactorActionsToConvertOverloadsToOneSignature
@@ -137462,8 +137629,8 @@ function getRefactorActionsToConvertOverloadsToOneSignature(context) {
   if (!info)
     return emptyArray;
   return [{
-    name: refactorName5,
-    description: refactorDescription,
+    name: refactorName6,
+    description: refactorDescription2,
     actions: [functionOverloadAction]
   }];
 }
@@ -137656,8 +137823,8 @@ function getConvertableOverloadListAtPosition(file, startPosition, program) {
 }
 
 // src/services/refactors/addOrRemoveBracesToArrowFunction.ts
-var refactorName6 = "Add or remove braces in an arrow function";
-var refactorDescription2 = getLocaleSpecificMessage(Diagnostics.Add_or_remove_braces_in_an_arrow_function);
+var refactorName7 = "Add or remove braces in an arrow function";
+var refactorDescription3 = getLocaleSpecificMessage(Diagnostics.Add_or_remove_braces_in_an_arrow_function);
 var addBracesAction = {
   name: "Add braces to arrow function",
   description: getLocaleSpecificMessage(Diagnostics.Add_braces_to_arrow_function),
@@ -137668,7 +137835,7 @@ var removeBracesAction = {
   description: getLocaleSpecificMessage(Diagnostics.Remove_braces_from_arrow_function),
   kind: "refactor.rewrite.arrow.braces.remove"
 };
-registerRefactor(refactorName6, {
+registerRefactor(refactorName7, {
   kinds: [removeBracesAction.kind],
   getEditsForAction: getRefactorEditsToRemoveFunctionBraces,
   getAvailableActions: getRefactorActionsToRemoveFunctionBraces
@@ -137680,8 +137847,8 @@ function getRefactorActionsToRemoveFunctionBraces(context) {
     return emptyArray;
   if (!isRefactorErrorInfo(info)) {
     return [{
-      name: refactorName6,
-      description: refactorDescription2,
+      name: refactorName7,
+      description: refactorDescription3,
       actions: [
         info.addBraces ? addBracesAction : removeBracesAction
       ]
@@ -137689,8 +137856,8 @@ function getRefactorActionsToRemoveFunctionBraces(context) {
   }
   if (context.preferences.provideRefactorNotApplicableReason) {
     return [{
-      name: refactorName6,
-      description: refactorDescription2,
+      name: refactorName7,
+      description: refactorDescription3,
       actions: [
         { ...addBracesAction, notApplicableReason: info.error },
         { ...removeBracesAction, notApplicableReason: info.error }
@@ -137786,8 +137953,8 @@ function getConvertibleArrowFunctionAtPosition(file, startPosition, considerFunc
 var ts_refactor_convertArrowFunctionOrFunctionExpression_exports = {};
 
 // src/services/refactors/convertArrowFunctionOrFunctionExpression.ts
-var refactorName7 = "Convert arrow function or function expression";
-var refactorDescription3 = getLocaleSpecificMessage(Diagnostics.Convert_arrow_function_or_function_expression);
+var refactorName8 = "Convert arrow function or function expression";
+var refactorDescription4 = getLocaleSpecificMessage(Diagnostics.Convert_arrow_function_or_function_expression);
 var toAnonymousFunctionAction = {
   name: "Convert to anonymous function",
   description: getLocaleSpecificMessage(Diagnostics.Convert_to_anonymous_function),
@@ -137803,7 +137970,7 @@ var toArrowFunctionAction = {
   description: getLocaleSpecificMessage(Diagnostics.Convert_to_arrow_function),
   kind: "refactor.rewrite.function.arrow"
 };
-registerRefactor(refactorName7, {
+registerRefactor(refactorName8, {
   kinds: [
     toAnonymousFunctionAction.kind,
     toNamedFunctionAction.kind,
@@ -137845,8 +138012,8 @@ function getRefactorActionsToConvertFunctionExpressions(context) {
     }
   }
   return [{
-    name: refactorName7,
-    description: refactorDescription3,
+    name: refactorName8,
+    description: refactorDescription4,
     actions: possibleActions.length === 0 && context.preferences.provideRefactorNotApplicableReason ? errors : possibleActions
   }];
 }
@@ -138011,15 +138178,15 @@ function isFunctionReferencedInFile(sourceFile, typeChecker, node) {
 var ts_refactor_convertParamsToDestructuredObject_exports = {};
 
 // src/services/refactors/convertParamsToDestructuredObject.ts
-var refactorName8 = "Convert parameters to destructured object";
+var refactorName9 = "Convert parameters to destructured object";
 var minimumParameterLength = 1;
-var refactorDescription4 = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
+var refactorDescription5 = getLocaleSpecificMessage(Diagnostics.Convert_parameters_to_destructured_object);
 var toDestructuredAction = {
-  name: refactorName8,
-  description: refactorDescription4,
+  name: refactorName9,
+  description: refactorDescription5,
   kind: "refactor.rewrite.parameters.toDestructured"
 };
-registerRefactor(refactorName8, {
+registerRefactor(refactorName9, {
   kinds: [toDestructuredAction.kind],
   getEditsForAction: getRefactorEditsToConvertParametersToDestructuredObject,
   getAvailableActions: getRefactorActionsToConvertParametersToDestructuredObject
@@ -138033,13 +138200,13 @@ function getRefactorActionsToConvertParametersToDestructuredObject(context) {
   if (!functionDeclaration)
     return emptyArray;
   return [{
-    name: refactorName8,
-    description: refactorDescription4,
+    name: refactorName9,
+    description: refactorDescription5,
     actions: [toDestructuredAction]
   }];
 }
 function getRefactorEditsToConvertParametersToDestructuredObject(context, actionName2) {
-  Debug.assert(actionName2 === refactorName8, "Unexpected action name");
+  Debug.assert(actionName2 === refactorName9, "Unexpected action name");
   const { file, startPosition, program, cancellationToken, host } = context;
   const functionDeclaration = getFunctionDeclarationAtPosition(file, startPosition, program.getTypeChecker());
   if (!functionDeclaration || !cancellationToken)
@@ -138554,14 +138721,14 @@ function getFunctionNames(functionDeclaration) {
 var ts_refactor_convertStringOrTemplateLiteral_exports = {};
 
 // src/services/refactors/convertStringOrTemplateLiteral.ts
-var refactorName9 = "Convert to template string";
-var refactorDescription5 = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
+var refactorName10 = "Convert to template string";
+var refactorDescription6 = getLocaleSpecificMessage(Diagnostics.Convert_to_template_string);
 var convertStringAction = {
-  name: refactorName9,
-  description: refactorDescription5,
+  name: refactorName10,
+  description: refactorDescription6,
   kind: "refactor.rewrite.string"
 };
-registerRefactor(refactorName9, {
+registerRefactor(refactorName10, {
   kinds: [convertStringAction.kind],
   getEditsForAction: getRefactorEditsToConvertToTemplateString,
   getAvailableActions: getRefactorActionsToConvertToTemplateString
@@ -138570,7 +138737,7 @@ function getRefactorActionsToConvertToTemplateString(context) {
   const { file, startPosition } = context;
   const node = getNodeOrParentOfParentheses(file, startPosition);
   const maybeBinary = getParentBinaryExpression(node);
-  const refactorInfo = { name: refactorName9, description: refactorDescription5, actions: [] };
+  const refactorInfo = { name: refactorName10, description: refactorDescription6, actions: [] };
   if (isBinaryExpression(maybeBinary) && treeToArray(maybeBinary).isValidConcatenation) {
     refactorInfo.actions.push(convertStringAction);
     return [refactorInfo];
@@ -138596,7 +138763,7 @@ function getRefactorEditsToConvertToTemplateString(context, actionName2) {
   const { file, startPosition } = context;
   const node = getNodeOrParentOfParentheses(file, startPosition);
   switch (actionName2) {
-    case refactorDescription5:
+    case refactorDescription6:
       return { edits: getEditsForToTemplateLiteral(context, node) };
     default:
       return Debug.fail("invalid action");
@@ -138778,14 +138945,14 @@ function getExpressionFromParenthesesOrExpression(node) {
 var ts_refactor_convertToOptionalChainExpression_exports = {};
 
 // src/services/refactors/convertToOptionalChainExpression.ts
-var refactorName10 = "Convert to optional chain expression";
+var refactorName11 = "Convert to optional chain expression";
 var convertToOptionalChainExpressionMessage = getLocaleSpecificMessage(Diagnostics.Convert_to_optional_chain_expression);
 var toOptionalChainAction = {
-  name: refactorName10,
+  name: refactorName11,
   description: convertToOptionalChainExpressionMessage,
   kind: "refactor.rewrite.expression.optionalChain"
 };
-registerRefactor(refactorName10, {
+registerRefactor(refactorName11, {
   kinds: [toOptionalChainAction.kind],
   getEditsForAction: getRefactorEditsToConvertToOptionalChain,
   getAvailableActions: getRefactorActionsToConvertToOptionalChain
@@ -138796,14 +138963,14 @@ function getRefactorActionsToConvertToOptionalChain(context) {
     return emptyArray;
   if (!isRefactorErrorInfo(info)) {
     return [{
-      name: refactorName10,
+      name: refactorName11,
       description: convertToOptionalChainExpressionMessage,
       actions: [toOptionalChainAction]
     }];
   }
   if (context.preferences.provideRefactorNotApplicableReason) {
     return [{
-      name: refactorName10,
+      name: refactorName11,
       description: convertToOptionalChainExpressionMessage,
       actions: [{ ...toOptionalChainAction, notApplicableReason: info.error }]
     }];
@@ -138999,7 +139166,7 @@ __export(ts_refactor_extractSymbol_exports, {
 });
 
 // src/services/refactors/extractSymbol.ts
-var refactorName11 = "Extract Symbol";
+var refactorName12 = "Extract Symbol";
 var extractConstantAction = {
   name: "Extract Constant",
   description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
@@ -139010,7 +139177,7 @@ var extractFunctionAction = {
   description: getLocaleSpecificMessage(Diagnostics.Extract_function),
   kind: "refactor.extract.function"
 };
-registerRefactor(refactorName11, {
+registerRefactor(refactorName12, {
   kinds: [
     extractConstantAction.kind,
     extractFunctionAction.kind
@@ -139029,14 +139196,14 @@ function getRefactorActionsToExtractSymbol(context) {
     const errors = [];
     if (refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
       errors.push({
-        name: refactorName11,
+        name: refactorName12,
         description: extractFunctionAction.description,
         actions: [{ ...extractFunctionAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
       });
     }
     if (refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
       errors.push({
-        name: refactorName11,
+        name: refactorName12,
         description: extractConstantAction.description,
         actions: [{ ...extractConstantAction, notApplicableReason: getStringError(rangeToExtract.errors) }]
       });
@@ -139100,26 +139267,26 @@ function getRefactorActionsToExtractSymbol(context) {
   const infos = [];
   if (functionActions.length) {
     infos.push({
-      name: refactorName11,
+      name: refactorName12,
       description: getLocaleSpecificMessage(Diagnostics.Extract_function),
       actions: functionActions
     });
   } else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorFunctionAction) {
     infos.push({
-      name: refactorName11,
+      name: refactorName12,
       description: getLocaleSpecificMessage(Diagnostics.Extract_function),
       actions: [innermostErrorFunctionAction]
     });
   }
   if (constantActions.length) {
     infos.push({
-      name: refactorName11,
+      name: refactorName12,
       description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
       actions: constantActions
     });
   } else if (context.preferences.provideRefactorNotApplicableReason && innermostErrorConstantAction) {
     infos.push({
-      name: refactorName11,
+      name: refactorName12,
       description: getLocaleSpecificMessage(Diagnostics.Extract_constant),
       actions: [innermostErrorConstantAction]
     });
@@ -140651,14 +140818,14 @@ registerRefactor(actionName, {
 var ts_refactor_inferFunctionReturnType_exports = {};
 
 // src/services/refactors/inferFunctionReturnType.ts
-var refactorName12 = "Infer function return type";
-var refactorDescription6 = getLocaleSpecificMessage(Diagnostics.Infer_function_return_type);
+var refactorName13 = "Infer function return type";
+var refactorDescription7 = getLocaleSpecificMessage(Diagnostics.Infer_function_return_type);
 var inferReturnTypeAction = {
-  name: refactorName12,
-  description: refactorDescription6,
+  name: refactorName13,
+  description: refactorDescription7,
   kind: "refactor.rewrite.function.returnType"
 };
-registerRefactor(refactorName12, {
+registerRefactor(refactorName13, {
   kinds: [inferReturnTypeAction.kind],
   getEditsForAction: getRefactorEditsToInferReturnType,
   getAvailableActions: getRefactorActionsToInferReturnType
@@ -140677,15 +140844,15 @@ function getRefactorActionsToInferReturnType(context) {
     return emptyArray;
   if (!isRefactorErrorInfo(info)) {
     return [{
-      name: refactorName12,
-      description: refactorDescription6,
+      name: refactorName13,
+      description: refactorDescription7,
       actions: [inferReturnTypeAction]
     }];
   }
   if (context.preferences.provideRefactorNotApplicableReason) {
     return [{
-      name: refactorName12,
-      description: refactorDescription6,
+      name: refactorName13,
+      description: refactorDescription7,
       actions: [{ ...inferReturnTypeAction, notApplicableReason: info.error }]
     }];
   }
@@ -142929,10 +143096,10 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     const newFileName = createNewFileName(sourceFile, program, getRefactorContext(sourceFile, positionOrRange, preferences, emptyOptions), host);
     return { newFileName, files };
   }
-  function getEditsForRefactor2(fileName, formatOptions, positionOrRange, refactorName13, actionName2, preferences = emptyOptions, interactiveRefactorArguments) {
+  function getEditsForRefactor2(fileName, formatOptions, positionOrRange, refactorName14, actionName2, preferences = emptyOptions, interactiveRefactorArguments) {
     synchronizeHostData();
     const file = getValidSourceFile(fileName);
-    return ts_refactor_exports.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName13, actionName2, interactiveRefactorArguments);
+    return ts_refactor_exports.getEditsForRefactor(getRefactorContext(file, positionOrRange, preferences, formatOptions), refactorName14, actionName2, interactiveRefactorArguments);
   }
   function toLineColumnOffset(fileName, position) {
     if (position === 0) {
@@ -158975,7 +159142,7 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, typeCheck
     case 290 /* JsxAttribute */:
       if (!isRequireCallArgument(node) && !isImportCall(parent2)) {
         const argumentInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(parent2.kind === 290 /* JsxAttribute */ ? parent2.parent : node, position, sourceFile);
-        return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType();
+        return argumentInfo && (getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker, 0 /* Normal */)) || fromContextualType(0 /* None */);
       }
     case 271 /* ImportDeclaration */:
     case 277 /* ExportDeclaration */:
@@ -159044,12 +159211,12 @@ function walkUpParentheses(node) {
 function getAlreadyUsedTypesInStringLiteralUnion(union, current) {
   return mapDefined(union.types, (type) => type !== current && isLiteralTypeNode(type) && isStringLiteral(type.literal) ? type.literal.text : void 0);
 }
-function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker) {
+function getStringLiteralCompletionsFromSignature(call, arg, argumentInfo, checker, checkMode = 32 /* IsForStringLiteralArgumentCompletions */) {
   let isNewIdentifier = false;
   const uniques = /* @__PURE__ */ new Map();
   const candidates = [];
   const editingArgument = isJsxOpeningLikeElement(call) ? Debug.checkDefined(findAncestor(arg.parent, isJsxAttribute)) : arg;
-  checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates);
+  checker.getResolvedSignatureForStringLiteralCompletions(call, editingArgument, candidates, checkMode);
   const types = flatMap(candidates, (candidate) => {
     if (!signatureHasRestParameter(candidate) && argumentInfo.argumentCount > candidate.parameters.length)
       return;
@@ -159659,6 +159826,7 @@ __export(ts_FindAllReferences_exports, {
   getTextSpanOfEntry: () => getTextSpanOfEntry,
   isContextWithStartAndEndNode: () => isContextWithStartAndEndNode,
   isDeclarationOfSymbol: () => isDeclarationOfSymbol,
+  isWriteAccessForReference: () => isWriteAccessForReference,
   nodeEntry: () => nodeEntry,
   toContextSpan: () => toContextSpan,
   toHighlightSpan: () => toHighlightSpan,
@@ -172323,9 +172491,9 @@ function buildOverload(name) {
 
 // src/deprecatedCompat/5.0/identifierProperties.ts
 addObjectAllocatorPatcher((objectAllocator2) => {
-  const Identifier74 = objectAllocator2.getIdentifierConstructor();
-  if (!hasProperty(Identifier74.prototype, "originalKeywordKind")) {
-    Object.defineProperty(Identifier74.prototype, "originalKeywordKind", {
+  const Identifier75 = objectAllocator2.getIdentifierConstructor();
+  if (!hasProperty(Identifier75.prototype, "originalKeywordKind")) {
+    Object.defineProperty(Identifier75.prototype, "originalKeywordKind", {
       get: deprecate(function() {
         return identifierToKeywordKind(this);
       }, {
@@ -172337,8 +172505,8 @@ addObjectAllocatorPatcher((objectAllocator2) => {
       })
     });
   }
-  if (!hasProperty(Identifier74.prototype, "isInJSDocNamespace")) {
-    Object.defineProperty(Identifier74.prototype, "isInJSDocNamespace", {
+  if (!hasProperty(Identifier75.prototype, "isInJSDocNamespace")) {
+    Object.defineProperty(Identifier75.prototype, "isInJSDocNamespace", {
       get: deprecate(function() {
         return this.flags & 2048 /* IdentifierIsInJSDocNamespace */ ? true : void 0;
       }, {