@typescript-deploys/pr-build 5.1.0-pr-50951-3 → 5.1.0-pr-53258-7

package/lib/tsserver.js

@@ -91,6 +91,7 @@ __export(server_exports, {
   ImportKind: () => ImportKind,
   ImportsNotUsedAsValues: () => ImportsNotUsedAsValues,
   IndentStyle: () => IndentStyle,
+  IndexFlags: () => IndexFlags,
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
@@ -2284,7 +2285,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-insiders.20230313`;
+var version = `${versionMajorMinor}.0-insiders.20230314`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6747,6 +6748,13 @@ var AccessFlags = /* @__PURE__ */ ((AccessFlags2) => {
   AccessFlags2[AccessFlags2["Persistent"] = 1 /* IncludeUndefined */] = "Persistent";
   return AccessFlags2;
 })(AccessFlags || {});
+var IndexFlags = /* @__PURE__ */ ((IndexFlags2) => {
+  IndexFlags2[IndexFlags2["None"] = 0] = "None";
+  IndexFlags2[IndexFlags2["StringsOnly"] = 1] = "StringsOnly";
+  IndexFlags2[IndexFlags2["NoIndexSignatures"] = 2] = "NoIndexSignatures";
+  IndexFlags2[IndexFlags2["NoReducibleCheck"] = 4] = "NoReducibleCheck";
+  return IndexFlags2;
+})(IndexFlags || {});
 var JsxReferenceKind = /* @__PURE__ */ ((JsxReferenceKind2) => {
   JsxReferenceKind2[JsxReferenceKind2["Component"] = 0] = "Component";
   JsxReferenceKind2[JsxReferenceKind2["Function"] = 1] = "Function";
@@ -9389,6 +9397,7 @@ var Diagnostics = {
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5: diag(1250, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_1250", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'."),
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_definitions_are_automatically_in_strict_mode: diag(1251, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Class_d_1251", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Class definitions are automatically in strict mode."),
   Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_are_automatically_in_strict_mode: diag(1252, 1 /* Error */, "Function_declarations_are_not_allowed_inside_blocks_in_strict_mode_when_targeting_ES3_or_ES5_Modules_1252", "Function declarations are not allowed inside blocks in strict mode when targeting 'ES3' or 'ES5'. Modules are automatically in strict mode."),
+  Abstract_properties_can_only_appear_within_an_abstract_class: diag(1253, 1 /* Error */, "Abstract_properties_can_only_appear_within_an_abstract_class_1253", "Abstract properties can only appear within an abstract class."),
   A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_reference: diag(1254, 1 /* Error */, "A_const_initializer_in_an_ambient_context_must_be_a_string_or_numeric_literal_or_literal_enum_refere_1254", "A 'const' initializer in an ambient context must be a string or numeric literal or literal enum reference."),
   A_definite_assignment_assertion_is_not_permitted_in_this_context: diag(1255, 1 /* Error */, "A_definite_assignment_assertion_is_not_permitted_in_this_context_1255", "A definite assignment assertion '!' is not permitted in this context."),
   A_required_element_cannot_follow_an_optional_element: diag(1257, 1 /* Error */, "A_required_element_cannot_follow_an_optional_element_1257", "A required element cannot follow an optional element."),
@@ -13838,36 +13847,32 @@ function getModifiers(node) {
     return filter(node.modifiers, isModifier);
   }
 }
-function getJSDocParameterTagsWorker(node, noCache) {
-  const declaration = getRootDeclaration(node);
-  if (isParameter(declaration)) {
-    const name = node.name;
-    const signatureDeclaration = declaration.parent;
-    const jsDocParameterTags = filter(getJSDocTagsWorker(signatureDeclaration, noCache), isJSDocParameterTag);
-    if (length(jsDocParameterTags) === 0) {
-      return emptyArray;
-    }
-    if (isIdentifier(name)) {
-      return filter(jsDocParameterTags, (tag) => isIdentifier(tag.name) && tag.name.escapedText === name.escapedText);
-    }
-    const i = signatureDeclaration.parameters.indexOf(declaration);
-    Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
-    if (i < length(jsDocParameterTags)) {
-      return [jsDocParameterTags[i]];
+function getJSDocParameterTagsWorker(param, noCache) {
+  if (param.name) {
+    if (isIdentifier(param.name)) {
+      const name = param.name.escapedText;
+      return getJSDocTagsWorker(param.parent, noCache).filter((tag) => isJSDocParameterTag(tag) && isIdentifier(tag.name) && tag.name.escapedText === name);
+    } else {
+      const i = param.parent.parameters.indexOf(param);
+      Debug.assert(i > -1, "Parameters should always be in their parents' parameter list");
+      const paramTags = getJSDocTagsWorker(param.parent, noCache).filter(isJSDocParameterTag);
+      if (i < paramTags.length) {
+        return [paramTags[i]];
+      }
     }
   }
   return emptyArray;
 }
-function getJSDocParameterTags(node) {
+function getJSDocParameterTags(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     false
   );
 }
-function getJSDocParameterTagsNoCache(node) {
+function getJSDocParameterTagsNoCache(param) {
   return getJSDocParameterTagsWorker(
-    node,
+    param,
     /*noCache*/
     true
   );
@@ -17526,7 +17531,7 @@ function getJSDocCommentsAndTags(hostNode, noCache) {
     if (hasJSDocNodes(node)) {
       result = addRange(result, filterOwnedJSDocTags(hostNode, last(node.jsDoc)));
     }
-    if (node.kind === 167 /* Parameter */ || node.kind === 206 /* BindingElement */) {
+    if (node.kind === 167 /* Parameter */) {
       result = addRange(result, (noCache ? getJSDocParameterTagsNoCache : getJSDocParameterTags)(node));
       break;
     }
@@ -47274,6 +47279,7 @@ function createTypeChecker(host) {
   var noImplicitThis = getStrictOptionValue(compilerOptions, "noImplicitThis");
   var useUnknownInCatchVariables = getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
   var keyofStringsOnly = !!compilerOptions.keyofStringsOnly;
+  var defaultIndexFlags = keyofStringsOnly ? 1 /* StringsOnly */ : 0 /* None */;
   var freshObjectLiteralFlag = compilerOptions.suppressExcessPropertyErrors ? 0 : 8192 /* FreshLiteral */;
   var exactOptionalPropertyTypes = compilerOptions.exactOptionalPropertyTypes;
   var checkBinaryExpression = createCheckBinaryExpression();
@@ -58542,6 +58548,13 @@ function createTypeChecker(host) {
   function isConflictingPrivateProperty(prop) {
     return !prop.valueDeclaration && !!(getCheckFlags(prop) & 1024 /* ContainsPrivate */);
   }
+  function isGenericReducibleType(type) {
+    return !!(type.flags & 1048576 /* Union */ && type.objectFlags & 16777216 /* ContainsIntersections */ && some(type.types, isGenericReducibleType) || type.flags & 2097152 /* Intersection */ && isReducibleIntersection(type));
+  }
+  function isReducibleIntersection(type) {
+    const uniqueFilled = type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
+    return getReducedType(uniqueFilled) !== uniqueFilled;
+  }
   function elaborateNeverIntersection(errorInfo, type) {
     if (type.flags & 2097152 /* Intersection */ && getObjectFlags(type) & 33554432 /* IsNeverIntersection */) {
       const neverProp = find(getPropertiesOfUnionOrIntersectionType(type), isDiscriminantWithNeverType);
@@ -60911,10 +60924,10 @@ function createTypeChecker(host) {
     }
     return links.resolvedType;
   }
-  function createIndexType(type, stringsOnly) {
+  function createIndexType(type, indexFlags) {
     const result = createType(4194304 /* Index */);
     result.type = type;
-    result.stringsOnly = stringsOnly;
+    result.indexFlags = indexFlags;
     return result;
   }
   function createOriginIndexType(type) {
@@ -60922,31 +60935,23 @@ function createTypeChecker(host) {
     result.type = type;
     return result;
   }
-  function getIndexTypeForGenericType(type, stringsOnly) {
-    return stringsOnly ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      true
-    )) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(
-      type,
-      /*stringsOnly*/
-      false
-    ));
+  function getIndexTypeForGenericType(type, indexFlags) {
+    return indexFlags & 1 /* StringsOnly */ ? type.resolvedStringIndexType || (type.resolvedStringIndexType = createIndexType(type, 1 /* StringsOnly */)) : type.resolvedIndexType || (type.resolvedIndexType = createIndexType(type, 0 /* None */));
   }
-  function getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) {
+  function getIndexTypeForMappedType(type, indexFlags) {
     const typeParameter = getTypeParameterFromMappedType(type);
     const constraintType = getConstraintTypeFromMappedType(type);
     const nameType = getNameTypeFromMappedType(type.target || type);
-    if (!nameType && !noIndexSignatures) {
+    if (!nameType && !(indexFlags & 2 /* NoIndexSignatures */)) {
       return constraintType;
     }
     const keyTypes = [];
     if (isMappedTypeWithKeyofConstraintDeclaration(type)) {
       if (!isGenericIndexType(constraintType)) {
         const modifiersType = getApparentType(getModifiersTypeFromMappedType(type));
-        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, stringsOnly, addMemberForKeyType);
+        forEachMappedTypePropertyKeyTypeAndIndexSignatureKeyType(modifiersType, 8576 /* StringOrNumberLiteralOrUnique */, !!(indexFlags & 1 /* StringsOnly */), addMemberForKeyType);
       } else {
-        return getIndexTypeForGenericType(type, stringsOnly);
+        return getIndexTypeForGenericType(type, indexFlags);
       }
     } else {
       forEachType(getLowerBoundOfKeyType(constraintType), addMemberForKeyType);
@@ -60954,7 +60959,7 @@ function createTypeChecker(host) {
     if (isGenericIndexType(constraintType)) {
       forEachType(constraintType, addMemberForKeyType);
     }
-    const result = noIndexSignatures ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
+    const result = indexFlags & 2 /* NoIndexSignatures */ ? filterType(getUnionType(keyTypes), (t) => !(t.flags & (1 /* Any */ | 4 /* String */))) : getUnionType(keyTypes);
     if (result.flags & 1048576 /* Union */ && constraintType.flags & 1048576 /* Union */ && getTypeListId(result.types) === getTypeListId(constraintType.types)) {
       return constraintType;
     }
@@ -61007,19 +61012,15 @@ function createTypeChecker(host) {
       origin
     );
   }
-  function isPossiblyReducibleByInstantiation(type) {
-    const uniqueFilled = getUniqueLiteralFilledInstantiation(type);
-    return getReducedType(uniqueFilled) !== uniqueFilled;
+  function shouldDeferIndexType(type, indexFlags = 0 /* None */) {
+    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && !(indexFlags & 4 /* NoReducibleCheck */) && isGenericReducibleType(type) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
   }
-  function shouldDeferIndexType(type) {
-    return !!(type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericTupleType(type) || isGenericMappedType(type) && !hasDistributiveNameType(type) || type.flags & 1048576 /* Union */ && some(type.types, isPossiblyReducibleByInstantiation) || type.flags & 2097152 /* Intersection */ && maybeTypeOfKind(type, 465829888 /* Instantiable */) && some(type.types, isEmptyAnonymousObjectType));
-  }
-  function getIndexType(type, stringsOnly = keyofStringsOnly, noIndexSignatures) {
+  function getIndexType(type, indexFlags = defaultIndexFlags) {
     type = getReducedType(type);
-    return shouldDeferIndexType(type) ? getIndexTypeForGenericType(type, stringsOnly) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, stringsOnly, noIndexSignatures))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, stringsOnly, noIndexSignatures) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
+    return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(
       type,
-      (noIndexSignatures ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (stringsOnly ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
-      stringsOnly === keyofStringsOnly && !noIndexSignatures
+      (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */),
+      indexFlags === defaultIndexFlags
     );
   }
   function getExtractStringType(type) {
@@ -61559,12 +61560,13 @@ function createTypeChecker(host) {
     if (objectType === wildcardType || indexType === wildcardType) {
       return wildcardType;
     }
+    objectType = getReducedType(objectType);
     if (isStringIndexSignatureOnlyType(objectType) && !(indexType.flags & 98304 /* Nullable */) && isTypeAssignableToKind(indexType, 4 /* String */ | 8 /* Number */)) {
       indexType = stringType;
     }
     if (compilerOptions.noUncheckedIndexedAccess && accessFlags & 32 /* ExpressionPosition */)
       accessFlags |= 1 /* IncludeUndefined */;
-    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)))) {
+    if (isGenericIndexType(indexType) || (accessNode && accessNode.kind !== 197 /* IndexedAccessType */ ? isGenericTupleType(objectType) && !indexTypeLessThan(indexType, objectType.target.fixedLength) : isGenericObjectType(objectType) && !(isTupleType(objectType) && indexTypeLessThan(indexType, objectType.target.fixedLength)) || isGenericReducibleType(objectType))) {
       if (objectType.flags & 3 /* AnyOrUnknown */) {
         return objectType;
       }
@@ -62750,9 +62752,6 @@ function createTypeChecker(host) {
     }
     return type;
   }
-  function getUniqueLiteralFilledInstantiation(type) {
-    return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.uniqueLiteralFilledInstantiation || (type.uniqueLiteralFilledInstantiation = instantiateType(type, uniqueLiteralMapper));
-  }
   function getPermissiveInstantiation(type) {
     return type.flags & (402784252 /* Primitive */ | 3 /* AnyOrUnknown */ | 131072 /* Never */) ? type : type.permissiveInstantiation || (type.permissiveInstantiation = instantiateType(type, permissiveMapper));
   }
@@ -63464,7 +63463,12 @@ function createTypeChecker(host) {
     const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
-      const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+      const sourceType = i === restIndex ? getRestTypeAtPosition(
+        source,
+        i,
+        /*readonly*/
+        true
+      ) : tryGetTypeAtPosition(source, i);
       const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
@@ -64935,7 +64939,7 @@ function createTypeChecker(host) {
         } else {
           const constraint = getSimplifiedTypeOrConstraint(targetType);
           if (constraint) {
-            if (isRelatedTo(source2, getIndexType(constraint, target2.stringsOnly), 2 /* Target */, reportErrors2) === -1 /* True */) {
+            if (isRelatedTo(source2, getIndexType(constraint, target2.indexFlags | 4 /* NoReducibleCheck */), 2 /* Target */, reportErrors2) === -1 /* True */) {
               return -1 /* True */;
             }
           } else if (isGenericMappedType(targetType)) {
@@ -65016,13 +65020,7 @@ function createTypeChecker(host) {
           }
           if (!isGenericMappedType(source2)) {
             const targetKeys = keysRemapped ? getNameTypeFromMappedType(target2) : getConstraintTypeFromMappedType(target2);
-            const sourceKeys = getIndexType(
-              source2,
-              /*stringsOnly*/
-              void 0,
-              /*noIndexSignatures*/
-              true
-            );
+            const sourceKeys = getIndexType(source2, 2 /* NoIndexSignatures */);
             const includeOptional = modifiers & 4 /* IncludeOptional */;
             const filteredByApplicability = includeOptional ? intersectTypes(targetKeys, sourceKeys) : void 0;
             if (includeOptional ? !(filteredByApplicability.flags & 131072 /* Never */) : isRelatedTo(targetKeys, sourceKeys, 3 /* Both */)) {
@@ -75955,12 +75953,12 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getRestTypeAtPosition(source, pos) {
+  function getRestTypeAtPosition(source, pos, readonly = false) {
     const parameterCount = getParameterCount(source);
     const minArgumentCount = getMinArgumentCount(source);
     const restType = getEffectiveRestType(source);
     if (restType && pos >= parameterCount - 1) {
-      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
+      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType), readonly);
     }
     const types = [];
     const flags = [];
@@ -75978,13 +75976,7 @@ function createTypeChecker(host) {
         names.push(name);
       }
     }
-    return createTupleType(
-      types,
-      flags,
-      /*readonly*/
-      false,
-      length(names) === length(types) ? names : void 0
-    );
+    return createTupleType(types, flags, readonly, length(names) === length(types) ? names : void 0);
   }
   function getParameterCount(signature) {
     const length2 = signature.parameters.length;
@@ -79262,11 +79254,7 @@ function createTypeChecker(host) {
     }
     const objectType = type.objectType;
     const indexType = type.indexType;
-    if (isTypeAssignableTo(indexType, getIndexType(
-      objectType,
-      /*stringsOnly*/
-      false
-    ))) {
+    if (isTypeAssignableTo(indexType, getIndexType(objectType, 0 /* None */))) {
       if (accessNode.kind === 210 /* ElementAccessExpression */ && isAssignmentTarget(accessNode) && getObjectFlags(objectType) & 32 /* Mapped */ && getMappedTypeModifiers(objectType) & 1 /* IncludeReadonly */) {
         error(accessNode, Diagnostics.Index_signature_in_type_0_only_permits_reading, typeToString(objectType));
       }
@@ -86086,7 +86074,8 @@ function createTypeChecker(host) {
                 return grammarErrorOnNode(modifier, Diagnostics.abstract_modifier_can_only_appear_on_a_class_method_or_property_declaration);
               }
               if (!(node.parent.kind === 261 /* ClassDeclaration */ && hasSyntacticModifier(node.parent, 256 /* Abstract */))) {
-                return grammarErrorOnNode(modifier, Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class);
+                const message = node.kind === 170 /* PropertyDeclaration */ ? Diagnostics.Abstract_properties_can_only_appear_within_an_abstract_class : Diagnostics.Abstract_methods_can_only_appear_within_an_abstract_class;
+                return grammarErrorOnNode(modifier, message);
               }
               if (flags & 32 /* Static */) {
                 return grammarErrorOnNode(modifier, Diagnostics._0_modifier_cannot_be_used_with_1_modifier, "static", "abstract");
@@ -133512,6 +133501,11 @@ function canBeConvertedToAsync(node) {
 }
 
 // src/services/transpile.ts
+var optionsRedundantWithVerbatimModuleSyntax = /* @__PURE__ */ new Set([
+  "isolatedModules",
+  "preserveValueImports",
+  "importsNotUsedAsValues"
+]);
 function transpileModule(input, transpileOptions) {
   const diagnostics = [];
   const options = transpileOptions.compilerOptions ? fixupCompilerOptions(transpileOptions.compilerOptions, diagnostics) : {};
@@ -133522,6 +133516,9 @@ function transpileModule(input, transpileOptions) {
     }
   }
   for (const option of transpileOptionValueCompilerOptions) {
+    if (options.verbatimModuleSyntax && optionsRedundantWithVerbatimModuleSyntax.has(option.name)) {
+      continue;
+    }
     options[option.name] = option.transpileOptionValue;
   }
   options.suppressOutputPathCheck = true;
@@ -168077,6 +168074,7 @@ __export(ts_exports3, {
   ImportKind: () => ImportKind,
   ImportsNotUsedAsValues: () => ImportsNotUsedAsValues,
   IndentStyle: () => IndentStyle,
+  IndexFlags: () => IndexFlags,
   IndexKind: () => IndexKind,
   InferenceFlags: () => InferenceFlags,
   InferencePriority: () => InferencePriority,
@@ -182035,6 +182033,7 @@ start(initializeNodeSystem(), require("os").platform());
   ImportKind,
   ImportsNotUsedAsValues,
   IndentStyle,
+  IndexFlags,
   IndexKind,
   InferenceFlags,
   InferencePriority,

package/lib/tsserverlibrary.d.ts

@@ -8518,7 +8518,7 @@ declare namespace ts {
      *
      * For binding patterns, parameter tags are matched by position.
      */
-    function getJSDocParameterTags(node: ParameterDeclaration | BindingElement): readonly JSDocParameterTag[];
+    function getJSDocParameterTags(param: ParameterDeclaration): readonly JSDocParameterTag[];
     /**
      * Gets the JSDoc type parameter tags for the node if present.
      *