typescript 5.3.0-dev.20230823 → 5.3.0-dev.20230825

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.3";
-      version = `${versionMajorMinor}.0-dev.20230823`;
+      version = `${versionMajorMinor}.0-dev.20230825`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -13329,402 +13329,6 @@ ${lanes.join("\n")}
     const emitNode = node.emitNode;
     return emitNode && emitNode.internalFlags || 0;
   }
-  function getScriptTargetFeatures() {
-    return new Map(Object.entries({
-      Array: new Map(Object.entries({
-        es2015: [
-          "find",
-          "findIndex",
-          "fill",
-          "copyWithin",
-          "entries",
-          "keys",
-          "values"
-        ],
-        es2016: [
-          "includes"
-        ],
-        es2019: [
-          "flat",
-          "flatMap"
-        ],
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Iterator: new Map(Object.entries({
-        es2015: emptyArray
-      })),
-      AsyncIterator: new Map(Object.entries({
-        es2015: emptyArray
-      })),
-      Atomics: new Map(Object.entries({
-        es2017: emptyArray
-      })),
-      SharedArrayBuffer: new Map(Object.entries({
-        es2017: emptyArray
-      })),
-      AsyncIterable: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncIterableIterator: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncGenerator: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      AsyncGeneratorFunction: new Map(Object.entries({
-        es2018: emptyArray
-      })),
-      RegExp: new Map(Object.entries({
-        es2015: [
-          "flags",
-          "sticky",
-          "unicode"
-        ],
-        es2018: [
-          "dotAll"
-        ]
-      })),
-      Reflect: new Map(Object.entries({
-        es2015: [
-          "apply",
-          "construct",
-          "defineProperty",
-          "deleteProperty",
-          "get",
-          " getOwnPropertyDescriptor",
-          "getPrototypeOf",
-          "has",
-          "isExtensible",
-          "ownKeys",
-          "preventExtensions",
-          "set",
-          "setPrototypeOf"
-        ]
-      })),
-      ArrayConstructor: new Map(Object.entries({
-        es2015: [
-          "from",
-          "of"
-        ]
-      })),
-      ObjectConstructor: new Map(Object.entries({
-        es2015: [
-          "assign",
-          "getOwnPropertySymbols",
-          "keys",
-          "is",
-          "setPrototypeOf"
-        ],
-        es2017: [
-          "values",
-          "entries",
-          "getOwnPropertyDescriptors"
-        ],
-        es2019: [
-          "fromEntries"
-        ],
-        es2022: [
-          "hasOwn"
-        ]
-      })),
-      NumberConstructor: new Map(Object.entries({
-        es2015: [
-          "isFinite",
-          "isInteger",
-          "isNaN",
-          "isSafeInteger",
-          "parseFloat",
-          "parseInt"
-        ]
-      })),
-      Math: new Map(Object.entries({
-        es2015: [
-          "clz32",
-          "imul",
-          "sign",
-          "log10",
-          "log2",
-          "log1p",
-          "expm1",
-          "cosh",
-          "sinh",
-          "tanh",
-          "acosh",
-          "asinh",
-          "atanh",
-          "hypot",
-          "trunc",
-          "fround",
-          "cbrt"
-        ]
-      })),
-      Map: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      Set: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      PromiseConstructor: new Map(Object.entries({
-        es2015: [
-          "all",
-          "race",
-          "reject",
-          "resolve"
-        ],
-        es2020: [
-          "allSettled"
-        ],
-        es2021: [
-          "any"
-        ]
-      })),
-      Symbol: new Map(Object.entries({
-        es2015: [
-          "for",
-          "keyFor"
-        ],
-        es2019: [
-          "description"
-        ]
-      })),
-      WeakMap: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      WeakSet: new Map(Object.entries({
-        es2015: [
-          "entries",
-          "keys",
-          "values"
-        ]
-      })),
-      String: new Map(Object.entries({
-        es2015: [
-          "codePointAt",
-          "includes",
-          "endsWith",
-          "normalize",
-          "repeat",
-          "startsWith",
-          "anchor",
-          "big",
-          "blink",
-          "bold",
-          "fixed",
-          "fontcolor",
-          "fontsize",
-          "italics",
-          "link",
-          "small",
-          "strike",
-          "sub",
-          "sup"
-        ],
-        es2017: [
-          "padStart",
-          "padEnd"
-        ],
-        es2019: [
-          "trimStart",
-          "trimEnd",
-          "trimLeft",
-          "trimRight"
-        ],
-        es2020: [
-          "matchAll"
-        ],
-        es2021: [
-          "replaceAll"
-        ],
-        es2022: [
-          "at"
-        ]
-      })),
-      StringConstructor: new Map(Object.entries({
-        es2015: [
-          "fromCodePoint",
-          "raw"
-        ]
-      })),
-      DateTimeFormat: new Map(Object.entries({
-        es2017: [
-          "formatToParts"
-        ]
-      })),
-      Promise: new Map(Object.entries({
-        es2015: emptyArray,
-        es2018: [
-          "finally"
-        ]
-      })),
-      RegExpMatchArray: new Map(Object.entries({
-        es2018: [
-          "groups"
-        ]
-      })),
-      RegExpExecArray: new Map(Object.entries({
-        es2018: [
-          "groups"
-        ]
-      })),
-      Intl: new Map(Object.entries({
-        es2018: [
-          "PluralRules"
-        ]
-      })),
-      NumberFormat: new Map(Object.entries({
-        es2018: [
-          "formatToParts"
-        ]
-      })),
-      SymbolConstructor: new Map(Object.entries({
-        es2020: [
-          "matchAll"
-        ]
-      })),
-      DataView: new Map(Object.entries({
-        es2020: [
-          "setBigInt64",
-          "setBigUint64",
-          "getBigInt64",
-          "getBigUint64"
-        ]
-      })),
-      BigInt: new Map(Object.entries({
-        es2020: emptyArray
-      })),
-      RelativeTimeFormat: new Map(Object.entries({
-        es2020: [
-          "format",
-          "formatToParts",
-          "resolvedOptions"
-        ]
-      })),
-      Int8Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint8Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint8ClampedArray: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Int16Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint16Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Int32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Uint32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Float32Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Float64Array: new Map(Object.entries({
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      BigInt64Array: new Map(Object.entries({
-        es2020: emptyArray,
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      BigUint64Array: new Map(Object.entries({
-        es2020: emptyArray,
-        es2022: [
-          "at"
-        ],
-        es2023: [
-          "findLastIndex",
-          "findLast"
-        ]
-      })),
-      Error: new Map(Object.entries({
-        es2022: [
-          "cause"
-        ]
-      }))
-    }));
-  }
   function getLiteralText(node, sourceFile, flags) {
     if (sourceFile && canUseOriginalText(node, flags)) {
       return getSourceTextOfNodeFromSourceFile(sourceFile, node);
@@ -19303,7 +18907,7 @@ ${lanes.join("\n")}
     }
     return Debug.fail();
   }
-  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
+  var resolvingEmptyArray, externalHelpersModuleNameText, defaultMaximumTruncationLength, noTruncationMaximumTruncationLength, stringWriter, getScriptTargetFeatures, GetLiteralTextFlags, fullTripleSlashReferencePathRegEx, fullTripleSlashReferenceTypeReferenceDirectiveRegEx, fullTripleSlashLibReferenceRegEx, fullTripleSlashAMDReferencePathRegEx, fullTripleSlashAMDModuleRegEx, defaultLibReferenceRegEx, AssignmentKind, FunctionFlags, Associativity, OperatorPrecedence, templateSubstitutionRegExp, doubleQuoteEscapedCharsRegExp, singleQuoteEscapedCharsRegExp, backtickQuoteEscapedCharsRegExp, escapedCharsMap, nonAsciiCharacters, jsxDoubleQuoteEscapedCharsRegExp, jsxSingleQuoteEscapedCharsRegExp, jsxEscapedCharsMap, indentStrings, base64Digits, carriageReturnLineFeed, lineFeed, objectAllocator, objectAllocatorPatchers, localizedDiagnosticMessages, reservedCharacterPattern, wildcardCharCodes, commonPackageFolders, implicitExcludePathRegexPattern, filesMatcher, directoriesMatcher, excludeMatcher, wildcardMatchers, supportedTSExtensions, supportedTSExtensionsFlat, supportedTSExtensionsWithJson, supportedTSExtensionsForExtractExtension, supportedJSExtensions, supportedJSExtensionsFlat, allSupportedExtensions, allSupportedExtensionsWithJson, supportedDeclarationExtensions, supportedTSImplementationExtensions, extensionsNotSupportingExtensionlessResolution, ModuleSpecifierEnding, extensionsToRemove, emptyFileSystemEntries;
   var init_utilities = __esm({
     "src/compiler/utilities.ts"() {
       "use strict";
@@ -19313,6 +18917,402 @@ ${lanes.join("\n")}
       defaultMaximumTruncationLength = 160;
       noTruncationMaximumTruncationLength = 1e6;
       stringWriter = createSingleLineStringWriter();
+      getScriptTargetFeatures = /* @__PURE__ */ memoize(
+        () => new Map(Object.entries({
+          Array: new Map(Object.entries({
+            es2015: [
+              "find",
+              "findIndex",
+              "fill",
+              "copyWithin",
+              "entries",
+              "keys",
+              "values"
+            ],
+            es2016: [
+              "includes"
+            ],
+            es2019: [
+              "flat",
+              "flatMap"
+            ],
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Iterator: new Map(Object.entries({
+            es2015: emptyArray
+          })),
+          AsyncIterator: new Map(Object.entries({
+            es2015: emptyArray
+          })),
+          Atomics: new Map(Object.entries({
+            es2017: emptyArray
+          })),
+          SharedArrayBuffer: new Map(Object.entries({
+            es2017: emptyArray
+          })),
+          AsyncIterable: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncIterableIterator: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncGenerator: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          AsyncGeneratorFunction: new Map(Object.entries({
+            es2018: emptyArray
+          })),
+          RegExp: new Map(Object.entries({
+            es2015: [
+              "flags",
+              "sticky",
+              "unicode"
+            ],
+            es2018: [
+              "dotAll"
+            ]
+          })),
+          Reflect: new Map(Object.entries({
+            es2015: [
+              "apply",
+              "construct",
+              "defineProperty",
+              "deleteProperty",
+              "get",
+              "getOwnPropertyDescriptor",
+              "getPrototypeOf",
+              "has",
+              "isExtensible",
+              "ownKeys",
+              "preventExtensions",
+              "set",
+              "setPrototypeOf"
+            ]
+          })),
+          ArrayConstructor: new Map(Object.entries({
+            es2015: [
+              "from",
+              "of"
+            ]
+          })),
+          ObjectConstructor: new Map(Object.entries({
+            es2015: [
+              "assign",
+              "getOwnPropertySymbols",
+              "keys",
+              "is",
+              "setPrototypeOf"
+            ],
+            es2017: [
+              "values",
+              "entries",
+              "getOwnPropertyDescriptors"
+            ],
+            es2019: [
+              "fromEntries"
+            ],
+            es2022: [
+              "hasOwn"
+            ]
+          })),
+          NumberConstructor: new Map(Object.entries({
+            es2015: [
+              "isFinite",
+              "isInteger",
+              "isNaN",
+              "isSafeInteger",
+              "parseFloat",
+              "parseInt"
+            ]
+          })),
+          Math: new Map(Object.entries({
+            es2015: [
+              "clz32",
+              "imul",
+              "sign",
+              "log10",
+              "log2",
+              "log1p",
+              "expm1",
+              "cosh",
+              "sinh",
+              "tanh",
+              "acosh",
+              "asinh",
+              "atanh",
+              "hypot",
+              "trunc",
+              "fround",
+              "cbrt"
+            ]
+          })),
+          Map: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          Set: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          PromiseConstructor: new Map(Object.entries({
+            es2015: [
+              "all",
+              "race",
+              "reject",
+              "resolve"
+            ],
+            es2020: [
+              "allSettled"
+            ],
+            es2021: [
+              "any"
+            ]
+          })),
+          Symbol: new Map(Object.entries({
+            es2015: [
+              "for",
+              "keyFor"
+            ],
+            es2019: [
+              "description"
+            ]
+          })),
+          WeakMap: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          WeakSet: new Map(Object.entries({
+            es2015: [
+              "entries",
+              "keys",
+              "values"
+            ]
+          })),
+          String: new Map(Object.entries({
+            es2015: [
+              "codePointAt",
+              "includes",
+              "endsWith",
+              "normalize",
+              "repeat",
+              "startsWith",
+              "anchor",
+              "big",
+              "blink",
+              "bold",
+              "fixed",
+              "fontcolor",
+              "fontsize",
+              "italics",
+              "link",
+              "small",
+              "strike",
+              "sub",
+              "sup"
+            ],
+            es2017: [
+              "padStart",
+              "padEnd"
+            ],
+            es2019: [
+              "trimStart",
+              "trimEnd",
+              "trimLeft",
+              "trimRight"
+            ],
+            es2020: [
+              "matchAll"
+            ],
+            es2021: [
+              "replaceAll"
+            ],
+            es2022: [
+              "at"
+            ]
+          })),
+          StringConstructor: new Map(Object.entries({
+            es2015: [
+              "fromCodePoint",
+              "raw"
+            ]
+          })),
+          DateTimeFormat: new Map(Object.entries({
+            es2017: [
+              "formatToParts"
+            ]
+          })),
+          Promise: new Map(Object.entries({
+            es2015: emptyArray,
+            es2018: [
+              "finally"
+            ]
+          })),
+          RegExpMatchArray: new Map(Object.entries({
+            es2018: [
+              "groups"
+            ]
+          })),
+          RegExpExecArray: new Map(Object.entries({
+            es2018: [
+              "groups"
+            ]
+          })),
+          Intl: new Map(Object.entries({
+            es2018: [
+              "PluralRules"
+            ]
+          })),
+          NumberFormat: new Map(Object.entries({
+            es2018: [
+              "formatToParts"
+            ]
+          })),
+          SymbolConstructor: new Map(Object.entries({
+            es2020: [
+              "matchAll"
+            ]
+          })),
+          DataView: new Map(Object.entries({
+            es2020: [
+              "setBigInt64",
+              "setBigUint64",
+              "getBigInt64",
+              "getBigUint64"
+            ]
+          })),
+          BigInt: new Map(Object.entries({
+            es2020: emptyArray
+          })),
+          RelativeTimeFormat: new Map(Object.entries({
+            es2020: [
+              "format",
+              "formatToParts",
+              "resolvedOptions"
+            ]
+          })),
+          Int8Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint8Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint8ClampedArray: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Int16Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint16Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Int32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Uint32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Float32Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Float64Array: new Map(Object.entries({
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          BigInt64Array: new Map(Object.entries({
+            es2020: emptyArray,
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          BigUint64Array: new Map(Object.entries({
+            es2020: emptyArray,
+            es2022: [
+              "at"
+            ],
+            es2023: [
+              "findLastIndex",
+              "findLast"
+            ]
+          })),
+          Error: new Map(Object.entries({
+            es2022: [
+              "cause"
+            ]
+          }))
+        }))
+      );
       GetLiteralTextFlags = /* @__PURE__ */ ((GetLiteralTextFlags2) => {
         GetLiteralTextFlags2[GetLiteralTextFlags2["None"] = 0] = "None";
         GetLiteralTextFlags2[GetLiteralTextFlags2["NeverAsciiEscape"] = 1] = "NeverAsciiEscape";
@@ -32436,7 +32436,9 @@ ${lanes.join("\n")}
           let dotDotDotToken;
           let expression;
           if (token() !== 20 /* CloseBraceToken */) {
-            dotDotDotToken = parseOptionalToken(26 /* DotDotDotToken */);
+            if (!inExpressionContext) {
+              dotDotDotToken = parseOptionalToken(26 /* DotDotDotToken */);
+            }
             expression = parseExpression();
           }
           if (inExpressionContext) {
@@ -46887,6 +46889,9 @@ ${lanes.join("\n")}
         const sourceFiles = host.getSourceFiles();
         return sourceFiles.indexOf(declarationFile) <= sourceFiles.indexOf(useFile);
       }
+      if (!!(usage.flags & 16777216 /* JSDoc */) || isInTypeQuery(usage) || isInAmbientOrTypeNode(usage)) {
+        return true;
+      }
       if (declaration.pos <= usage.pos && !(isPropertyDeclaration(declaration) && isThisProperty(usage.parent) && !declaration.initializer && !declaration.exclamationToken)) {
         if (declaration.kind === 208 /* BindingElement */) {
           const errorBindingElement = getAncestor(usage, 208 /* BindingElement */);
@@ -46916,9 +46921,6 @@ ${lanes.join("\n")}
       if (usage.kind === 277 /* ExportAssignment */ && usage.isExportEquals) {
         return true;
       }
-      if (!!(usage.flags & 16777216 /* JSDoc */) || isInTypeQuery(usage) || isInAmbientOrTypeNode(usage)) {
-        return true;
-      }
       if (isUsedInFunctionOrInstanceProperty(usage, declaration)) {
         if (emitStandardClassFields && getContainingClass(declaration) && (isPropertyDeclaration(declaration) || isParameterPropertyDeclaration(declaration, declaration.parent))) {
           return !isPropertyImmediatelyReferencedWithinDeclaration(
@@ -53128,8 +53130,8 @@ ${lanes.join("\n")}
                     });
                   }
                 });
-                Debug.assert(setter && isFunctionLikeDeclaration(setter));
-                const paramSymbol = getSignatureFromDeclaration(setter).parameters[0];
+                Debug.assert(!!setter);
+                const paramSymbol = isFunctionLikeDeclaration(setter) ? getSignatureFromDeclaration(setter).parameters[0] : void 0;
                 result.push(setTextRange(
                   factory.createSetAccessorDeclaration(
                     factory.createModifiersFromModifierFlags(flag),
@@ -53905,7 +53907,7 @@ ${lanes.join("\n")}
       const pattern = declaration.parent;
       if (strictNullChecks && declaration.flags & 33554432 /* Ambient */ && isParameterDeclaration(declaration)) {
         parentType = getNonNullableType(parentType);
-      } else if (strictNullChecks && pattern.parent.initializer && !(getTypeFacts(getTypeOfInitializer(pattern.parent.initializer)) & 65536 /* EQUndefined */)) {
+      } else if (strictNullChecks && pattern.parent.initializer && !hasTypeFacts(getTypeOfInitializer(pattern.parent.initializer), 65536 /* EQUndefined */)) {
         parentType = getTypeWithFacts(parentType, 524288 /* NEUndefined */);
       }
       let type;
@@ -53948,7 +53950,7 @@ ${lanes.join("\n")}
         return type;
       }
       if (getEffectiveTypeAnnotationNode(walkUpBindingElementsAndPatterns(declaration))) {
-        return strictNullChecks && !(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
+        return strictNullChecks && !hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */) ? getNonUndefinedType(type) : type;
       }
       return widenTypeInferredFromInitializer(declaration, getUnionType([getNonUndefinedType(type), checkDeclarationInitializer(declaration, 0 /* Normal */)], 2 /* Subtype */));
     }
@@ -62056,7 +62058,7 @@ ${lanes.join("\n")}
         if (sourceType && targetType) {
           const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
           const targetSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(targetType));
-          const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && (getTypeFacts(sourceType) & 50331648 /* IsUndefinedOrNull */) === (getTypeFacts(targetType) & 50331648 /* IsUndefinedOrNull */);
+          const callbacks = sourceSig && targetSig && !getTypePredicateOfSignature(sourceSig) && !getTypePredicateOfSignature(targetSig) && getTypeFacts(sourceType, 50331648 /* IsUndefinedOrNull */) === getTypeFacts(targetType, 50331648 /* IsUndefinedOrNull */);
           let related = callbacks ? compareSignaturesRelated(targetSig, sourceSig, checkMode & 8 /* StrictArity */ | (strictVariance ? 2 /* StrictCallback */ : 1 /* BivariantCallback */), reportErrors2, errorReporter, incompatibleErrorReporter, compareTypes, reportUnreliableMarkers) : !(checkMode & 3 /* Callback */) && !strictVariance && compareTypes(
             sourceType,
             targetType,
@@ -65213,7 +65215,7 @@ ${lanes.join("\n")}
       return value.base10Value === "0";
     }
     function removeDefinitelyFalsyTypes(type) {
-      return filterType(type, (t) => !!(getTypeFacts(t) & 4194304 /* Truthy */));
+      return filterType(type, (t) => hasTypeFacts(t, 4194304 /* Truthy */));
     }
     function extractDefinitelyFalsyTypes(type) {
       return mapType(type, getDefinitelyFalsyPartOfType);
@@ -66489,12 +66491,14 @@ ${lanes.join("\n")}
       }
       function inferFromSignatures(source, target, kind) {
         const sourceSignatures = getSignaturesOfType(source, kind);
-        const targetSignatures = getSignaturesOfType(target, kind);
         const sourceLen = sourceSignatures.length;
-        const targetLen = targetSignatures.length;
-        const len = sourceLen < targetLen ? sourceLen : targetLen;
-        for (let i = 0; i < len; i++) {
-          inferFromSignature(getBaseSignature(sourceSignatures[sourceLen - len + i]), getErasedSignature(targetSignatures[targetLen - len + i]));
+        if (sourceLen > 0) {
+          const targetSignatures = getSignaturesOfType(target, kind);
+          const targetLen = targetSignatures.length;
+          for (let i = 0; i < targetLen; i++) {
+            const sourceIndex = Math.max(sourceLen - targetLen + i, 0);
+            inferFromSignature(getBaseSignature(sourceSignatures[sourceIndex]), getErasedSignature(targetSignatures[i]));
+          }
         }
       }
       function inferFromSignature(source, target) {
@@ -66956,7 +66960,13 @@ ${lanes.join("\n")}
       const resolved = resolveStructuredTypeMembers(type);
       return !!(resolved.callSignatures.length || resolved.constructSignatures.length || resolved.members.get("bind") && isTypeSubtypeOf(type, globalFunctionType));
     }
-    function getTypeFacts(type) {
+    function getTypeFacts(type, mask2) {
+      return getTypeFactsWorker(type, mask2) & mask2;
+    }
+    function hasTypeFacts(type, mask2) {
+      return getTypeFacts(type, mask2) !== 0;
+    }
+    function getTypeFactsWorker(type, callerOnlyNeeds) {
       if (type.flags & (2097152 /* Intersection */ | 465829888 /* Instantiable */)) {
         type = getBaseConstraintOfType(type) || unknownType;
       }
@@ -66989,6 +66999,10 @@ ${lanes.join("\n")}
         return strictNullChecks ? type === falseType || type === regularFalseType ? 12121864 /* FalseStrictFacts */ : 7927560 /* TrueStrictFacts */ : type === falseType || type === regularFalseType ? 12580616 /* FalseFacts */ : 16774920 /* TrueFacts */;
       }
       if (flags & 524288 /* Object */) {
+        const possibleFacts = strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ | 7880640 /* FunctionStrictFacts */ | 7888800 /* ObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ | 16728e3 /* FunctionFacts */ | 16736160 /* ObjectFacts */;
+        if ((callerOnlyNeeds & possibleFacts) === 0) {
+          return 0;
+        }
         return getObjectFlags(type) & 16 /* Anonymous */ && isEmptyObjectType(type) ? strictNullChecks ? 83427327 /* EmptyObjectStrictFacts */ : 83886079 /* EmptyObjectFacts */ : isFunctionObjectType(type) ? strictNullChecks ? 7880640 /* FunctionStrictFacts */ : 16728e3 /* FunctionFacts */ : strictNullChecks ? 7888800 /* ObjectStrictFacts */ : 16736160 /* ObjectFacts */;
       }
       if (flags & 16384 /* Void */) {
@@ -67010,20 +67024,20 @@ ${lanes.join("\n")}
         return 0 /* None */;
       }
       if (flags & 1048576 /* Union */) {
-        return reduceLeft(type.types, (facts, t) => facts | getTypeFacts(t), 0 /* None */);
+        return reduceLeft(type.types, (facts, t) => facts | getTypeFactsWorker(t, callerOnlyNeeds), 0 /* None */);
       }
       if (flags & 2097152 /* Intersection */) {
-        return getIntersectionTypeFacts(type);
+        return getIntersectionTypeFacts(type, callerOnlyNeeds);
       }
       return 83886079 /* UnknownFacts */;
     }
-    function getIntersectionTypeFacts(type) {
+    function getIntersectionTypeFacts(type, callerOnlyNeeds) {
       const ignoreObjects = maybeTypeOfKind(type, 402784252 /* Primitive */);
       let oredFacts = 0 /* None */;
       let andedFacts = 134217727 /* All */;
       for (const t of type.types) {
         if (!(ignoreObjects && t.flags & 524288 /* Object */)) {
-          const f = getTypeFacts(t);
+          const f = getTypeFactsWorker(t, callerOnlyNeeds);
           oredFacts |= f;
           andedFacts &= f;
         }
@@ -67031,19 +67045,19 @@ ${lanes.join("\n")}
       return oredFacts & 8256 /* OrFactsMask */ | andedFacts & 134209471 /* AndFactsMask */;
     }
     function getTypeWithFacts(type, include) {
-      return filterType(type, (t) => (getTypeFacts(t) & include) !== 0);
+      return filterType(type, (t) => hasTypeFacts(t, include));
     }
     function getAdjustedTypeWithFacts(type, facts) {
       const reduced = recombineUnknownType(getTypeWithFacts(strictNullChecks && type.flags & 2 /* Unknown */ ? unknownUnionType : type, facts));
       if (strictNullChecks) {
         switch (facts) {
           case 524288 /* NEUndefined */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 65536 /* EQUndefined */ ? getIntersectionType([t, getTypeFacts(t) & 131072 /* EQNull */ && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 65536 /* EQUndefined */) ? getIntersectionType([t, hasTypeFacts(t, 131072 /* EQNull */) && !maybeTypeOfKind(reduced, 65536 /* Null */) ? getUnionType([emptyObjectType, nullType]) : emptyObjectType]) : t);
           case 1048576 /* NENull */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 131072 /* EQNull */ ? getIntersectionType([t, getTypeFacts(t) & 65536 /* EQUndefined */ && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 131072 /* EQNull */) ? getIntersectionType([t, hasTypeFacts(t, 65536 /* EQUndefined */) && !maybeTypeOfKind(reduced, 32768 /* Undefined */) ? getUnionType([emptyObjectType, undefinedType]) : emptyObjectType]) : t);
           case 2097152 /* NEUndefinedOrNull */:
           case 4194304 /* Truthy */:
-            return mapType(reduced, (t) => getTypeFacts(t) & 262144 /* EQUndefinedOrNull */ ? getGlobalNonNullableTypeInstantiation(t) : t);
+            return mapType(reduced, (t) => hasTypeFacts(t, 262144 /* EQUndefinedOrNull */) ? getGlobalNonNullableTypeInstantiation(t) : t);
         }
       }
       return reduced;
@@ -68030,7 +68044,7 @@ ${lanes.join("\n")}
         return void 0;
       }
       function getDiscriminantPropertyAccess(expr, computedType) {
-        const type = declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
+        const type = !(computedType.flags & 1048576 /* Union */) && declaredType.flags & 1048576 /* Union */ ? declaredType : computedType;
         if (type.flags & 1048576 /* Union */) {
           const access = getCandidateDiscriminantPropertyAccess(expr);
           if (access) {
@@ -68380,14 +68394,14 @@ ${lanes.join("\n")}
           // the constituent based on its type facts. We use the strict subtype relation because it treats `object`
           // as a subtype of `{}`, and we need the type facts check because function types are subtypes of `object`,
           // but are classified as "function" according to `typeof`.
-          isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? getTypeFacts(t) & facts ? t : neverType : (
+          isTypeRelatedTo(t, impliedType, strictSubtypeRelation) ? hasTypeFacts(t, facts) ? t : neverType : (
             // We next check if the consituent is a supertype of the implied type. If so, we substitute the implied
             // type. This handles top types like `unknown` and `{}`, and supertypes like `{ toString(): string }`.
             isTypeSubtypeOf(impliedType, t) ? impliedType : (
               // Neither the constituent nor the implied type is a subtype of the other, however their domains may still
               // overlap. For example, an unconstrained type parameter and type `string`. If the type facts indicate
               // possible overlap, we form an intersection. Otherwise, we eliminate the constituent.
-              getTypeFacts(t) & facts ? getIntersectionType([t, impliedType]) : neverType
+              hasTypeFacts(t, facts) ? getIntersectionType([t, impliedType]) : neverType
             )
           )
         ));
@@ -68401,7 +68415,7 @@ ${lanes.join("\n")}
         const hasDefaultClause = clauseStart === clauseEnd || defaultIndex >= clauseStart && defaultIndex < clauseEnd;
         if (hasDefaultClause) {
           const notEqualFacts = getNotEqualFactsFromTypeofSwitch(clauseStart, clauseEnd, witnesses);
-          return filterType(type, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
+          return filterType(type, (t) => getTypeFacts(t, notEqualFacts) === notEqualFacts);
         }
         const clauseWitnesses = witnesses.slice(clauseStart, clauseEnd);
         return getUnionType(map(clauseWitnesses, (text) => text ? narrowTypeByTypeName(type, text) : neverType));
@@ -68539,7 +68553,7 @@ ${lanes.join("\n")}
                 false
               );
             }
-            if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !(getTypeFacts(predicate.type) & 65536 /* EQUndefined */)) {
+            if (strictNullChecks && assumeTrue && optionalChainContainsReference(predicateArgument, reference) && !hasTypeFacts(predicate.type, 65536 /* EQUndefined */)) {
               type = getAdjustedTypeWithFacts(type, 2097152 /* NEUndefinedOrNull */);
             }
             const access = getDiscriminantPropertyAccess(predicateArgument, type);
@@ -68673,7 +68687,7 @@ ${lanes.join("\n")}
           reportCircularityError(declaration.symbol);
           return true;
         }
-        const containsUndefined = !!(getTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */)) & 16777216 /* IsUndefined */);
+        const containsUndefined = !!hasTypeFacts(checkDeclarationInitializer(declaration, 0 /* Normal */), 16777216 /* IsUndefined */);
         if (!popTypeResolution()) {
           reportCircularityError(declaration.symbol);
           return true;
@@ -68683,7 +68697,7 @@ ${lanes.join("\n")}
       return links.parameterInitializerContainsUndefined;
     }
     function removeOptionalityFromDeclaredType(declaredType, declaration) {
-      const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && getTypeFacts(declaredType) & 16777216 /* IsUndefined */ && !parameterInitializerContainsUndefined(declaration);
+      const removeUndefined = strictNullChecks && declaration.kind === 169 /* Parameter */ && declaration.initializer && hasTypeFacts(declaredType, 16777216 /* IsUndefined */) && !parameterInitializerContainsUndefined(declaration);
       return removeUndefined ? getTypeWithFacts(declaredType, 524288 /* NEUndefined */) : declaredType;
     }
     function isConstraintPosition(type, node) {
@@ -71513,7 +71527,7 @@ ${lanes.join("\n")}
       return checkNonNullType(checkExpression(node), node);
     }
     function isNullableType(type) {
-      return !!(getTypeFacts(type) & 50331648 /* IsUndefinedOrNull */);
+      return hasTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
     }
     function getNonNullableTypeIfNeeded(type) {
       return isNullableType(type) ? getNonNullableType(type) : type;
@@ -71559,7 +71573,7 @@ ${lanes.join("\n")}
         error2(node, Diagnostics.Object_is_of_type_unknown);
         return errorType;
       }
-      const facts = getTypeFacts(type);
+      const facts = getTypeFacts(type, 50331648 /* IsUndefinedOrNull */);
       if (facts & 50331648 /* IsUndefinedOrNull */) {
         reportError(node, facts);
         const t = getNonNullableType(type);
@@ -75339,7 +75353,7 @@ ${lanes.join("\n")}
         if (operandConstraint.flags & 3 /* AnyOrUnknown */) {
           return (556800 /* AllTypeofNE */ & notEqualFacts) === 556800 /* AllTypeofNE */;
         }
-        return !someType(operandConstraint, (t) => (getTypeFacts(t) & notEqualFacts) === notEqualFacts);
+        return !someType(operandConstraint, (t) => getTypeFacts(t, notEqualFacts) === notEqualFacts);
       }
       const type = checkExpressionCached(node.expression);
       if (!isLiteralType(type)) {
@@ -75657,14 +75671,15 @@ ${lanes.join("\n")}
       if (symbol) {
         if (isReadonlySymbol(symbol)) {
           error2(expr, Diagnostics.The_operand_of_a_delete_operator_cannot_be_a_read_only_property);
+        } else {
+          checkDeleteExpressionMustBeOptional(expr, symbol);
         }
-        checkDeleteExpressionMustBeOptional(expr, symbol);
       }
       return booleanType;
     }
     function checkDeleteExpressionMustBeOptional(expr, symbol) {
       const type = getTypeOfSymbol(symbol);
-      if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : getTypeFacts(type) & 16777216 /* IsUndefined */)) {
+      if (strictNullChecks && !(type.flags & (3 /* AnyOrUnknown */ | 131072 /* Never */)) && !(exactOptionalPropertyTypes ? symbol.flags & 16777216 /* Optional */ : hasTypeFacts(type, 16777216 /* IsUndefined */))) {
         error2(expr, Diagnostics.The_operand_of_a_delete_operator_must_be_optional);
       }
     }
@@ -75799,7 +75814,7 @@ ${lanes.join("\n")}
           return getUnaryResultType(operandType);
         case 54 /* ExclamationToken */:
           checkTruthinessOfType(operandType, node.operand);
-          const facts = getTypeFacts(operandType) & (4194304 /* Truthy */ | 8388608 /* Falsy */);
+          const facts = getTypeFacts(operandType, 4194304 /* Truthy */ | 8388608 /* Falsy */);
           return facts === 4194304 /* Truthy */ ? falseType : facts === 8388608 /* Falsy */ ? trueType : booleanType;
         case 46 /* PlusPlusToken */:
         case 47 /* MinusMinusToken */:
@@ -76030,7 +76045,7 @@ ${lanes.join("\n")}
       if (exprOrAssignment.kind === 304 /* ShorthandPropertyAssignment */) {
         const prop = exprOrAssignment;
         if (prop.objectAssignmentInitializer) {
-          if (strictNullChecks && !(getTypeFacts(checkExpression(prop.objectAssignmentInitializer)) & 16777216 /* IsUndefined */)) {
+          if (strictNullChecks && !hasTypeFacts(checkExpression(prop.objectAssignmentInitializer), 16777216 /* IsUndefined */)) {
             sourceType = getTypeWithFacts(sourceType, 524288 /* NEUndefined */);
           }
           checkBinaryLikeExpression(prop.name, prop.equalsToken, prop.objectAssignmentInitializer, checkMode);
@@ -76442,7 +76457,7 @@ ${lanes.join("\n")}
           return checkInExpression(left, right, leftType, rightType);
         case 56 /* AmpersandAmpersandToken */:
         case 77 /* AmpersandAmpersandEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 4194304 /* Truthy */ ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 4194304 /* Truthy */) ? getUnionType([extractDefinitelyFalsyTypes(strictNullChecks ? leftType : getBaseTypeOfLiteralType(rightType)), rightType]) : leftType;
           if (operator === 77 /* AmpersandAmpersandEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -76450,7 +76465,7 @@ ${lanes.join("\n")}
         }
         case 57 /* BarBarToken */:
         case 76 /* BarBarEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 8388608 /* Falsy */ ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 8388608 /* Falsy */) ? getUnionType([getNonNullableType(removeDefinitelyFalsyTypes(leftType)), rightType], 2 /* Subtype */) : leftType;
           if (operator === 76 /* BarBarEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -76458,7 +76473,7 @@ ${lanes.join("\n")}
         }
         case 61 /* QuestionQuestionToken */:
         case 78 /* QuestionQuestionEqualsToken */: {
-          const resultType2 = getTypeFacts(leftType) & 262144 /* EQUndefinedOrNull */ ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
+          const resultType2 = hasTypeFacts(leftType, 262144 /* EQUndefinedOrNull */) ? getUnionType([getNonNullableType(leftType), rightType], 2 /* Subtype */) : leftType;
           if (operator === 78 /* QuestionQuestionEqualsToken */) {
             checkAssignmentOperator(rightType);
           }
@@ -79775,7 +79790,7 @@ ${lanes.join("\n")}
         }
         const type = location === condExpr2 ? condType : checkTruthinessExpression(location);
         const isPropertyExpressionCast = isPropertyAccessExpression(location) && isTypeAssertion(location.expression);
-        if (!(getTypeFacts(type) & 4194304 /* Truthy */) || isPropertyExpressionCast)
+        if (!hasTypeFacts(type, 4194304 /* Truthy */) || isPropertyExpressionCast)
           return;
         const callSignatures = getSignaturesOfType(type, 0 /* Call */);
         const isPromise = !!getAwaitedTypeOfPromise(type);
@@ -164012,11 +164027,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     function isSignatureSupportingReturnAnnotation(node) {
       return isArrowFunction(node) || isFunctionExpression(node) || isFunctionDeclaration(node) || isMethodDeclaration(node) || isGetAccessorDeclaration(node);
     }
-    function addParameterHints(text, parameter, position, isFirstVariadicArgument, sourceFile) {
+    function addParameterHints(text, parameter, position, isFirstVariadicArgument) {
       let hintText = `${isFirstVariadicArgument ? "..." : ""}${text}`;
       let displayParts;
       if (shouldUseInteractiveInlayHints(preferences)) {
-        displayParts = [getNodeDisplayPart(hintText, parameter, sourceFile), { text: ":" }];
+        displayParts = [getNodeDisplayPart(hintText, parameter), { text: ":" }];
         hintText = "";
       } else {
         hintText += ":";
@@ -164088,7 +164103,6 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       if (!signature || !candidates.length) {
         return;
       }
-      const sourceFile = shouldUseInteractiveInlayHints(preferences) ? expr.getSourceFile() : void 0;
       let signatureParamPos = 0;
       for (const originalArg of args) {
         const arg = skipParentheses(originalArg);
@@ -164123,7 +164137,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
           if (leadingCommentsContainsParameterName(arg, name)) {
             continue;
           }
-          addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument, sourceFile);
+          addParameterHints(name, parameter, originalArg.getStart(), isFirstVariadicArgument);
         }
       }
     }
@@ -164259,7 +164273,8 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       }
       return true;
     }
-    function getNodeDisplayPart(text, node, sourceFile) {
+    function getNodeDisplayPart(text, node) {
+      const sourceFile = node.getSourceFile();
       return {
         text,
         span: createTextSpanFromNode(node, sourceFile),
@@ -167147,11 +167162,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     if (documentation.length === 0 && isIdentifier(location) && symbol.valueDeclaration && isBindingElement(symbol.valueDeclaration)) {
       const declaration = symbol.valueDeclaration;
       const parent2 = declaration.parent;
-      if (isIdentifier(declaration.name) && isObjectBindingPattern(parent2)) {
-        const name = getTextOfIdentifierOrLiteral(declaration.name);
+      const name = declaration.propertyName || declaration.name;
+      if (isIdentifier(name) && isObjectBindingPattern(parent2)) {
+        const propertyName = getTextOfIdentifierOrLiteral(name);
         const objectType = typeChecker.getTypeAtLocation(parent2);
         documentation = firstDefined(objectType.isUnion() ? objectType.types : [objectType], (t) => {
-          const prop = t.getProperty(name);
+          const prop = t.getProperty(propertyName);
           return prop ? prop.getDocumentationComment(typeChecker) : void 0;
         }) || emptyArray;
       }
@@ -181002,14 +181018,22 @@ Project '${project.projectName}' (${ProjectKind[project.projectKind]}) ${counter
             return {
               ...hint,
               position: scriptInfo.positionToLineOffset(position),
-              displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => ({
-                text,
-                span: span && {
-                  start: scriptInfo.positionToLineOffset(span.start),
-                  end: scriptInfo.positionToLineOffset(span.start + span.length),
-                  file: file2
+              displayParts: displayParts == null ? void 0 : displayParts.map(({ text, span, file: file2 }) => {
+                if (span) {
+                  Debug.assertIsDefined(file2, "Target file should be defined together with its span.");
+                  const scriptInfo2 = this.projectService.getScriptInfo(file2);
+                  return {
+                    text,
+                    span: {
+                      start: scriptInfo2.positionToLineOffset(span.start),
+                      end: scriptInfo2.positionToLineOffset(span.start + span.length),
+                      file: file2
+                    }
+                  };
+                } else {
+                  return { text };
                 }
-              }))
+              })
             };
           });
         }