typescript 5.4.0-dev.20231207 → 5.4.0-dev.20231209

package/lib/tsserver.js

@@ -333,6 +333,7 @@ __export(server_exports, {
   computeSignature: () => computeSignature,
   computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
+  computedOptions: () => computedOptions,
   concatenate: () => concatenate,
   concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
   consumesNodeCoreModules: () => consumesNodeCoreModules,
@@ -2334,7 +2335,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20231207`;
+var version = `${versionMajorMinor}.0-dev.20231209`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7291,6 +7292,7 @@ var EmitHint = /* @__PURE__ */ ((EmitHint6) => {
   EmitHint6[EmitHint6["Unspecified"] = 4] = "Unspecified";
   EmitHint6[EmitHint6["EmbeddedStatement"] = 5] = "EmbeddedStatement";
   EmitHint6[EmitHint6["JsxAttributeValue"] = 6] = "JsxAttributeValue";
+  EmitHint6[EmitHint6["ImportTypeNodeAttributes"] = 7] = "ImportTypeNodeAttributes";
   return EmitHint6;
 })(EmitHint || {});
 var OuterExpressionKinds = /* @__PURE__ */ ((OuterExpressionKinds2) => {
@@ -20521,37 +20523,230 @@ function getSetExternalModuleIndicator(options) {
       return callback;
   }
 }
-function getEmitScriptTarget(compilerOptions) {
-  return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
-}
-function getEmitModuleKind(compilerOptions) {
-  return typeof compilerOptions.module === "number" ? compilerOptions.module : getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
-}
-function emitModuleKindIsNonNodeESM(moduleKind) {
-  return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
+function createComputedCompilerOptions(options) {
+  return options;
 }
-function getEmitModuleResolutionKind(compilerOptions) {
-  let moduleResolution = compilerOptions.moduleResolution;
-  if (moduleResolution === void 0) {
-    switch (getEmitModuleKind(compilerOptions)) {
-      case 1 /* CommonJS */:
-        moduleResolution = 2 /* Node10 */;
-        break;
-      case 100 /* Node16 */:
-        moduleResolution = 3 /* Node16 */;
-        break;
-      case 199 /* NodeNext */:
-        moduleResolution = 99 /* NodeNext */;
-        break;
-      default:
-        moduleResolution = 1 /* Classic */;
-        break;
+var computedOptions = createComputedCompilerOptions({
+  target: {
+    dependencies: ["module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.target ?? (compilerOptions.module === 100 /* Node16 */ && 9 /* ES2022 */ || compilerOptions.module === 199 /* NodeNext */ && 99 /* ESNext */ || 1 /* ES5 */);
+    }
+  },
+  module: {
+    dependencies: ["target"],
+    computeValue: (compilerOptions) => {
+      return typeof compilerOptions.module === "number" ? compilerOptions.module : computedOptions.target.computeValue(compilerOptions) >= 2 /* ES2015 */ ? 5 /* ES2015 */ : 1 /* CommonJS */;
+    }
+  },
+  moduleResolution: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      let moduleResolution = compilerOptions.moduleResolution;
+      if (moduleResolution === void 0) {
+        switch (computedOptions.module.computeValue(compilerOptions)) {
+          case 1 /* CommonJS */:
+            moduleResolution = 2 /* Node10 */;
+            break;
+          case 100 /* Node16 */:
+            moduleResolution = 3 /* Node16 */;
+            break;
+          case 199 /* NodeNext */:
+            moduleResolution = 99 /* NodeNext */;
+            break;
+          default:
+            moduleResolution = 1 /* Classic */;
+            break;
+        }
+      }
+      return moduleResolution;
+    }
+  },
+  moduleDetection: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.moduleDetection || (computedOptions.module.computeValue(compilerOptions) === 100 /* Node16 */ || computedOptions.module.computeValue(compilerOptions) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+    }
+  },
+  isolatedModules: {
+    dependencies: ["verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.isolatedModules || compilerOptions.verbatimModuleSyntax);
+    }
+  },
+  esModuleInterop: {
+    dependencies: ["module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.esModuleInterop !== void 0) {
+        return compilerOptions.esModuleInterop;
+      }
+      switch (computedOptions.module.computeValue(compilerOptions)) {
+        case 100 /* Node16 */:
+        case 199 /* NodeNext */:
+          return true;
+      }
+      return false;
+    }
+  },
+  allowSyntheticDefaultImports: {
+    dependencies: ["module", "target", "moduleResolution"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
+        return compilerOptions.allowSyntheticDefaultImports;
+      }
+      return computedOptions.esModuleInterop.computeValue(compilerOptions) || computedOptions.module.computeValue(compilerOptions) === 4 /* System */ || computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  resolvePackageJsonExports: {
+    dependencies: ["moduleResolution"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolvePackageJsonImports: {
+    dependencies: ["moduleResolution", "resolvePackageJsonExports"],
+    computeValue: (compilerOptions) => {
+      const moduleResolution = computedOptions.moduleResolution.computeValue(compilerOptions);
+      if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
+        return false;
+      }
+      if (compilerOptions.resolvePackageJsonExports !== void 0) {
+        return compilerOptions.resolvePackageJsonExports;
+      }
+      switch (moduleResolution) {
+        case 3 /* Node16 */:
+        case 99 /* NodeNext */:
+        case 100 /* Bundler */:
+          return true;
+      }
+      return false;
+    }
+  },
+  resolveJsonModule: {
+    dependencies: ["moduleResolution", "module", "target"],
+    computeValue: (compilerOptions) => {
+      if (compilerOptions.resolveJsonModule !== void 0) {
+        return compilerOptions.resolveJsonModule;
+      }
+      return computedOptions.moduleResolution.computeValue(compilerOptions) === 100 /* Bundler */;
+    }
+  },
+  declaration: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declaration || compilerOptions.composite);
+    }
+  },
+  preserveConstEnums: {
+    dependencies: ["isolatedModules", "verbatimModuleSyntax"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.preserveConstEnums || computedOptions.isolatedModules.computeValue(compilerOptions));
+    }
+  },
+  incremental: {
+    dependencies: ["composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.incremental || compilerOptions.composite);
+    }
+  },
+  declarationMap: {
+    dependencies: ["declaration", "composite"],
+    computeValue: (compilerOptions) => {
+      return !!(compilerOptions.declarationMap && computedOptions.declaration.computeValue(compilerOptions));
+    }
+  },
+  allowJs: {
+    dependencies: ["checkJs"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
+    }
+  },
+  useDefineForClassFields: {
+    dependencies: ["target", "module"],
+    computeValue: (compilerOptions) => {
+      return compilerOptions.useDefineForClassFields === void 0 ? computedOptions.target.computeValue(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
+    }
+  },
+  noImplicitAny: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitAny");
+    }
+  },
+  noImplicitThis: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "noImplicitThis");
+    }
+  },
+  strictNullChecks: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictNullChecks");
+    }
+  },
+  strictFunctionTypes: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictFunctionTypes");
+    }
+  },
+  strictBindCallApply: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictBindCallApply");
+    }
+  },
+  strictPropertyInitialization: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "strictPropertyInitialization");
+    }
+  },
+  alwaysStrict: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "alwaysStrict");
+    }
+  },
+  useUnknownInCatchVariables: {
+    dependencies: ["strict"],
+    computeValue: (compilerOptions) => {
+      return getStrictOptionValue(compilerOptions, "useUnknownInCatchVariables");
     }
   }
-  return moduleResolution;
-}
-function getEmitModuleDetectionKind(options) {
-  return options.moduleDetection || (getEmitModuleKind(options) === 100 /* Node16 */ || getEmitModuleKind(options) === 199 /* NodeNext */ ? 3 /* Force */ : 2 /* Auto */);
+});
+var getEmitScriptTarget = computedOptions.target.computeValue;
+var getEmitModuleKind = computedOptions.module.computeValue;
+var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue;
+var getEmitModuleDetectionKind = computedOptions.moduleDetection.computeValue;
+var getIsolatedModules = computedOptions.isolatedModules.computeValue;
+var getESModuleInterop = computedOptions.esModuleInterop.computeValue;
+var getAllowSyntheticDefaultImports = computedOptions.allowSyntheticDefaultImports.computeValue;
+var getResolvePackageJsonExports = computedOptions.resolvePackageJsonExports.computeValue;
+var getResolvePackageJsonImports = computedOptions.resolvePackageJsonImports.computeValue;
+var getResolveJsonModule = computedOptions.resolveJsonModule.computeValue;
+var getEmitDeclarations = computedOptions.declaration.computeValue;
+var shouldPreserveConstEnums = computedOptions.preserveConstEnums.computeValue;
+var isIncrementalCompilation = computedOptions.incremental.computeValue;
+var getAreDeclarationMapsEnabled = computedOptions.declarationMap.computeValue;
+var getAllowJSCompilerOption = computedOptions.allowJs.computeValue;
+var getUseDefineForClassFields = computedOptions.useDefineForClassFields.computeValue;
+function emitModuleKindIsNonNodeESM(moduleKind) {
+  return moduleKind >= 5 /* ES2015 */ && moduleKind <= 99 /* ESNext */;
 }
 function hasJsonModuleEmitEnabled(options) {
   switch (getEmitModuleKind(options)) {
@@ -20568,9 +20763,6 @@ function hasJsonModuleEmitEnabled(options) {
       return false;
   }
 }
-function getIsolatedModules(options) {
-  return !!(options.isolatedModules || options.verbatimModuleSyntax);
-}
 function importNameElisionDisabled(options) {
   return options.verbatimModuleSyntax || options.isolatedModules && options.preserveValueImports;
 }
@@ -20580,88 +20772,15 @@ function unreachableCodeIsError(options) {
 function unusedLabelIsError(options) {
   return options.allowUnusedLabels === false;
 }
-function getAreDeclarationMapsEnabled(options) {
-  return !!(getEmitDeclarations(options) && options.declarationMap);
-}
-function getESModuleInterop(compilerOptions) {
-  if (compilerOptions.esModuleInterop !== void 0) {
-    return compilerOptions.esModuleInterop;
-  }
-  switch (getEmitModuleKind(compilerOptions)) {
-    case 100 /* Node16 */:
-    case 199 /* NodeNext */:
-      return true;
-  }
-  return void 0;
-}
-function getAllowSyntheticDefaultImports(compilerOptions) {
-  if (compilerOptions.allowSyntheticDefaultImports !== void 0) {
-    return compilerOptions.allowSyntheticDefaultImports;
-  }
-  return getESModuleInterop(compilerOptions) || getEmitModuleKind(compilerOptions) === 4 /* System */ || getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
 function moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution) {
   return moduleResolution >= 3 /* Node16 */ && moduleResolution <= 99 /* NodeNext */ || moduleResolution === 100 /* Bundler */;
 }
 function shouldResolveJsRequire(compilerOptions) {
   return !!compilerOptions.noDtsResolution || getEmitModuleResolutionKind(compilerOptions) !== 100 /* Bundler */;
 }
-function getResolvePackageJsonExports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolvePackageJsonImports(compilerOptions) {
-  const moduleResolution = getEmitModuleResolutionKind(compilerOptions);
-  if (!moduleResolutionSupportsPackageJsonExportsAndImports(moduleResolution)) {
-    return false;
-  }
-  if (compilerOptions.resolvePackageJsonExports !== void 0) {
-    return compilerOptions.resolvePackageJsonExports;
-  }
-  switch (moduleResolution) {
-    case 3 /* Node16 */:
-    case 99 /* NodeNext */:
-    case 100 /* Bundler */:
-      return true;
-  }
-  return false;
-}
-function getResolveJsonModule(compilerOptions) {
-  if (compilerOptions.resolveJsonModule !== void 0) {
-    return compilerOptions.resolveJsonModule;
-  }
-  return getEmitModuleResolutionKind(compilerOptions) === 100 /* Bundler */;
-}
-function getEmitDeclarations(compilerOptions) {
-  return !!(compilerOptions.declaration || compilerOptions.composite);
-}
-function shouldPreserveConstEnums(compilerOptions) {
-  return !!(compilerOptions.preserveConstEnums || getIsolatedModules(compilerOptions));
-}
-function isIncrementalCompilation(options) {
-  return !!(options.incremental || options.composite);
-}
 function getStrictOptionValue(compilerOptions, flag) {
   return compilerOptions[flag] === void 0 ? !!compilerOptions.strict : !!compilerOptions[flag];
 }
-function getAllowJSCompilerOption(compilerOptions) {
-  return compilerOptions.allowJs === void 0 ? !!compilerOptions.checkJs : compilerOptions.allowJs;
-}
-function getUseDefineForClassFields(compilerOptions) {
-  return compilerOptions.useDefineForClassFields === void 0 ? getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */ : compilerOptions.useDefineForClassFields;
-}
 function getEmitStandardClassFields(compilerOptions) {
   return compilerOptions.useDefineForClassFields !== false && getEmitScriptTarget(compilerOptions) >= 9 /* ES2022 */;
 }
@@ -23072,8 +23191,10 @@ function createNodeFactory(flags, baseFactory2) {
     return update(updated, original);
   }
   function createNumericLiteral(value, numericLiteralFlags = 0 /* None */) {
+    const text = typeof value === "number" ? value + "" : value;
+    Debug.assert(text.charCodeAt(0) !== 45 /* minus */, "Negative numbers should be created in combination with createPrefixUnaryExpression");
     const node = createBaseDeclaration(9 /* NumericLiteral */);
-    node.text = typeof value === "number" ? value + "" : value;
+    node.text = text;
     node.numericLiteralFlags = numericLiteralFlags;
     if (numericLiteralFlags & 384 /* BinaryOrOctalSpecifier */)
       node.transformFlags |= 1024 /* ContainsES2015 */;
@@ -40332,7 +40453,8 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     ),
     (f) => getRelativePathFromFile(getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), getNormalizedAbsolutePath(f, host.getCurrentDirectory()), getCanonicalFileName)
   );
-  const optionMap = serializeCompilerOptions(configParseResult.options, { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames });
+  const pathOptions = { configFilePath: getNormalizedAbsolutePath(configFileName, host.getCurrentDirectory()), useCaseSensitiveFileNames: host.useCaseSensitiveFileNames };
+  const optionMap = serializeCompilerOptions(configParseResult.options, pathOptions);
   const watchOptionMap = configParseResult.watchOptions && serializeWatchOptions(configParseResult.watchOptions);
   const config = {
     compilerOptions: {
@@ -40357,6 +40479,18 @@ function convertToTSConfig(configParseResult, configFileName, host) {
     } : {},
     compileOnSave: !!configParseResult.compileOnSave ? true : void 0
   };
+  const providedKeys = new Set(optionMap.keys());
+  const impliedCompilerOptions = {};
+  for (const option in computedOptions) {
+    if (!providedKeys.has(option) && some(computedOptions[option].dependencies, (dep) => providedKeys.has(dep))) {
+      const implied = computedOptions[option].computeValue(configParseResult.options);
+      const defaultValue = computedOptions[option].computeValue({});
+      if (implied !== defaultValue) {
+        impliedCompilerOptions[option] = computedOptions[option].computeValue(configParseResult.options);
+      }
+    }
+  }
+  assign(config.compilerOptions, optionMapToObject(serializeCompilerOptions(impliedCompilerOptions, pathOptions)));
   return config;
 }
 function optionMapToObject(optionMap) {
@@ -54296,7 +54430,7 @@ function createTypeChecker(host) {
             return factory.createStringLiteral(name, !!singleQuote);
           }
           if (isNumericLiteralName(name) && startsWith(name, "-")) {
-            return factory.createComputedPropertyName(factory.createNumericLiteral(+name));
+            return factory.createComputedPropertyName(factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-name)));
           }
           return createPropertyNameNodeForIdentifierOrLiteral(name, getEmitScriptTarget(compilerOptions), singleQuote, stringNamed, isMethod);
         }
@@ -58362,11 +58496,10 @@ function createTypeChecker(host) {
     const baseTypes = getBaseTypes(source);
     if (baseTypes.length) {
       if (source.symbol && members === getMembersOfSymbol(source.symbol)) {
-        const symbolTable = createSymbolTable();
-        for (const symbol of members.values()) {
-          if (!(symbol.flags & 262144 /* TypeParameter */)) {
-            symbolTable.set(symbol.escapedName, symbol);
-          }
+        const symbolTable = createSymbolTable(source.declaredProperties);
+        const sourceIndex = getIndexSymbol(source.symbol);
+        if (sourceIndex) {
+          symbolTable.set("__index" /* Index */, sourceIndex);
         }
         members = symbolTable;
       }
@@ -63031,7 +63164,9 @@ function createTypeChecker(host) {
       if (checkType === wildcardType || extendsType === wildcardType) {
         return wildcardType;
       }
-      const checkTuples = isSimpleTupleType(root.node.checkType) && isSimpleTupleType(root.node.extendsType) && length(root.node.checkType.elements) === length(root.node.extendsType.elements);
+      const checkTypeNode = skipTypeParentheses(root.node.checkType);
+      const extendsTypeNode = skipTypeParentheses(root.node.extendsType);
+      const checkTuples = isSimpleTupleType(checkTypeNode) && isSimpleTupleType(extendsTypeNode) && length(checkTypeNode.elements) === length(extendsTypeNode.elements);
       const checkTypeDeferred = isDeferredType(checkType, checkTuples);
       let combinedMapper;
       if (root.inferTypeParameters) {
@@ -87377,7 +87512,7 @@ function createTypeChecker(host) {
     if (enumResult)
       return enumResult;
     const literalValue = type.value;
-    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "number" ? factory.createNumericLiteral(literalValue) : factory.createStringLiteral(literalValue);
+    return typeof literalValue === "object" ? factory.createBigIntLiteral(literalValue) : typeof literalValue === "string" ? factory.createStringLiteral(literalValue) : literalValue < 0 ? factory.createPrefixUnaryExpression(41 /* MinusToken */, factory.createNumericLiteral(-literalValue)) : factory.createNumericLiteral(literalValue);
   }
   function createLiteralConstValue(node, tracker) {
     const type = getTypeOfSymbol(getSymbolOfDeclaration(node));
@@ -93977,7 +94112,7 @@ function transformTypeScript(context) {
   function transformEnumMemberDeclarationValue(member) {
     const value = resolver.getConstantValue(member);
     if (value !== void 0) {
-      return typeof value === "string" ? factory2.createStringLiteral(value) : factory2.createNumericLiteral(value);
+      return typeof value === "string" ? factory2.createStringLiteral(value) : value < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-value)) : factory2.createNumericLiteral(value);
     } else {
       enableSubstitutionForNonQualifiedEnumMembers();
       if (member.initializer) {
@@ -94507,7 +94642,7 @@ function transformTypeScript(context) {
     const constantValue = tryGetConstEnumValue(node);
     if (constantValue !== void 0) {
       setConstantValue(node, constantValue);
-      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(Math.abs(constantValue))) : factory2.createNumericLiteral(constantValue);
+      const substitute = typeof constantValue === "string" ? factory2.createStringLiteral(constantValue) : constantValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constantValue)) : factory2.createNumericLiteral(constantValue);
       if (!compilerOptions.removeComments) {
         const originalNode = getOriginalNode(node, isAccessExpression);
         addSyntheticTrailingComment(substitute, 3 /* MultiLineCommentTrivia */, ` ${safeMultiLineComment(getTextOfNode(originalNode))} `);
@@ -108297,7 +108432,7 @@ function transformGenerators(context) {
       if (labelExpressions === void 0) {
         labelExpressions = [];
       }
-      const expression = factory2.createNumericLiteral(-1);
+      const expression = factory2.createNumericLiteral(Number.MAX_SAFE_INTEGER);
       if (labelExpressions[label] === void 0) {
         labelExpressions[label] = [expression];
       } else {
@@ -114172,7 +114307,8 @@ function transformDeclarations(context) {
             if (shouldStripInternal(m))
               return;
             const constValue = resolver.getConstantValue(m);
-            return preserveJsDoc(factory2.updateEnumMember(m, m.name, constValue !== void 0 ? typeof constValue === "string" ? factory2.createStringLiteral(constValue) : factory2.createNumericLiteral(constValue) : void 0), m);
+            const newInitializer = constValue === void 0 ? void 0 : typeof constValue === "string" ? factory2.createStringLiteral(constValue) : constValue < 0 ? factory2.createPrefixUnaryExpression(41 /* MinusToken */, factory2.createNumericLiteral(-constValue)) : factory2.createNumericLiteral(constValue);
+            return preserveJsDoc(factory2.updateEnumMember(m, m.name, newInitializer), m);
           }))
         ));
       }
@@ -116073,6 +116209,8 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       );
     if (hint === 3 /* MappedTypeParameter */)
       return emitMappedTypeParameter(cast(node, isTypeParameterDeclaration));
+    if (hint === 7 /* ImportTypeNodeAttributes */)
+      return emitImportTypeNodeAttributes(cast(node, isImportAttributes));
     if (hint === 5 /* EmbeddedStatement */) {
       Debug.assertNode(node, isEmptyStatement);
       return emitEmptyStatement(
@@ -117049,15 +117187,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     if (node.attributes) {
       writePunctuation(",");
       writeSpace();
-      writePunctuation("{");
-      writeSpace();
-      writeKeyword(node.attributes.token === 132 /* AssertKeyword */ ? "assert" : "with");
-      writePunctuation(":");
-      writeSpace();
-      const elements = node.attributes.elements;
-      emitList(node.attributes, elements, 526226 /* ImportAttributes */);
-      writeSpace();
-      writePunctuation("}");
+      pipelineEmit(7 /* ImportTypeNodeAttributes */, node.attributes);
     }
     writePunctuation(")");
     if (node.qualifier) {
@@ -118119,6 +118249,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     writeTrailingSemicolon();
   }
+  function emitImportTypeNodeAttributes(node) {
+    writePunctuation("{");
+    writeSpace();
+    writeKeyword(node.token === 132 /* AssertKeyword */ ? "assert" : "with");
+    writePunctuation(":");
+    writeSpace();
+    const elements = node.elements;
+    emitList(node, elements, 526226 /* ImportAttributes */);
+    writeSpace();
+    writePunctuation("}");
+  }
   function emitImportAttributes(node) {
     emitTokenWithComment(node.token, node.pos, writeKeyword, node);
     writeSpace();
@@ -159762,7 +159903,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   }
   const semanticStart = timestamp();
   let completionKind = 5 /* None */;
-  let isNonContextualObjectLiteral = false;
   let hasUnresolvedAutoImports = false;
   let symbols = [];
   let importSpecifierResolver;
@@ -160122,8 +160262,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
   function shouldOfferImportCompletions() {
     if (importStatementCompletion)
       return true;
-    if (isNonContextualObjectLiteral)
-      return false;
     if (!preferences.includeCompletionsForModuleExports)
       return false;
     if (sourceFile.externalModuleIndicator || sourceFile.commonJsModuleIndicator)
@@ -160426,7 +160564,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         if (objectLikeContainer.flags & 67108864 /* InWithStatement */) {
           return 2 /* Fail */;
         }
-        isNonContextualObjectLiteral = true;
         return 0 /* Continue */;
       }
       const completionsType = typeChecker.getContextualType(objectLikeContainer, 4 /* Completions */);
@@ -160437,7 +160574,6 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       existingMembers = objectLikeContainer.properties;
       if (typeMembers.length === 0) {
         if (!hasNumberIndextype) {
-          isNonContextualObjectLiteral = true;
           return 0 /* Continue */;
         }
       }
@@ -165954,9 +166090,8 @@ function provideInlayHints(context) {
           break;
         case 181 /* IndexSignature */:
           Debug.assertNode(node, isIndexSignatureDeclaration);
-          Debug.assertEqual(node.parameters.length, 1);
           parts.push({ text: "[" });
-          visitForDisplayParts(node.parameters[0]);
+          visitDisplayPartList(node.parameters, ", ");
           parts.push({ text: "]" });
           if (node.type) {
             parts.push({ text: ": " });
@@ -167623,16 +167758,16 @@ function getRenameInfoForModule(node, sourceFile, moduleSymbol) {
   if (!moduleSourceFile)
     return void 0;
   const withoutIndex = endsWith(node.text, "/index") || endsWith(node.text, "/index.js") ? void 0 : tryRemoveSuffix(removeFileExtension(moduleSourceFile.fileName), "/index");
-  const name = withoutIndex === void 0 ? moduleSourceFile.fileName : withoutIndex;
+  const fileName = withoutIndex === void 0 ? moduleSourceFile.fileName : withoutIndex;
   const kind = withoutIndex === void 0 ? "module" /* moduleElement */ : "directory" /* directory */;
   const indexAfterLastSlash = node.text.lastIndexOf("/") + 1;
   const triggerSpan = createTextSpan(node.getStart(sourceFile) + 1 + indexAfterLastSlash, node.text.length - indexAfterLastSlash);
   return {
     canRename: true,
-    fileToRename: name,
+    fileToRename: fileName,
     kind,
-    displayName: name,
-    fullDisplayName: name,
+    displayName: fileName,
+    fullDisplayName: node.text,
     kindModifiers: "" /* none */,
     triggerSpan
   };
@@ -173454,6 +173589,7 @@ __export(ts_exports2, {
   computeSignature: () => computeSignature,
   computeSignatureWithDiagnostics: () => computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics: () => computeSuggestionDiagnostics,
+  computedOptions: () => computedOptions,
   concatenate: () => concatenate,
   concatenateDiagnosticMessageChains: () => concatenateDiagnosticMessageChains,
   consumesNodeCoreModules: () => consumesNodeCoreModules,
@@ -188248,6 +188384,7 @@ start(initializeNodeSystem(), require("os").platform());
   computeSignature,
   computeSignatureWithDiagnostics,
   computeSuggestionDiagnostics,
+  computedOptions,
   concatenate,
   concatenateDiagnosticMessageChains,
   consumesNodeCoreModules,

package/lib/typescript.d.ts

@@ -1087,6 +1087,7 @@ declare namespace ts {
                 displayName: string;
                 /**
                  * Full display name of item to be renamed.
+                 * If item to be renamed is a file, then this is the original text of the module specifer
                  */
                 fullDisplayName: string;
                 /**
@@ -6831,6 +6832,20 @@ declare namespace ts {
          * is `never`. Instead, use `type.flags & TypeFlags.Never`.
          */
         getNeverType(): Type;
+        /**
+         * Returns true if the "source" type is assignable to the "target" type.
+         *
+         * ```ts
+         * declare const abcLiteral: ts.Type; // Type of "abc"
+         * declare const stringType: ts.Type; // Type of string
+         *
+         * isTypeAssignableTo(abcLiteral, abcLiteral); // true; "abc" is assignable to "abc"
+         * isTypeAssignableTo(abcLiteral, stringType); // true; "abc" is assignable to string
+         * isTypeAssignableTo(stringType, abcLiteral); // false; string is not assignable to "abc"
+         * isTypeAssignableTo(stringType, stringType); // true; string is assignable to string
+         * ```
+         */
+        isTypeAssignableTo(source: Type, target: Type): boolean;
         /**
          * True if this type is the `Array` or `ReadonlyArray` type from lib.d.ts.
          * This function will _not_ return true if passed a type which
@@ -7896,6 +7911,7 @@ declare namespace ts {
         Unspecified = 4,
         EmbeddedStatement = 5,
         JsxAttributeValue = 6,
+        ImportTypeNodeAttributes = 7,
     }
     enum OuterExpressionKinds {
         Parentheses = 1,
@@ -11091,6 +11107,10 @@ declare namespace ts {
          */
         fileToRename?: string;
         displayName: string;
+        /**
+         * Full display name of item to be renamed.
+         * If item to be renamed is a file, then this is the original text of the module specifer
+         */
         fullDisplayName: string;
         kind: ScriptElementKind;
         kindModifiers: string;