typescript 4.8.0-dev.20220625 → 4.8.0-dev.20220628

package/lib/typescriptServices.js

@@ -294,7 +294,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = ts.versionMajorMinor + ".0-dev.20220625";
+    ts.version = ts.versionMajorMinor + ".0-dev.20220628";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -33144,7 +33144,7 @@ var ts;
             }
             return parseElement();
         }
-        function currentNode(parsingContext) {
+        function currentNode(parsingContext, pos) {
             // If we don't have a cursor or the parsing context isn't reusable, there's nothing to reuse.
             //
             // If there is an outstanding parse error that we've encountered, but not attached to
@@ -33157,7 +33157,7 @@ var ts;
             if (!syntaxCursor || !isReusableParsingContext(parsingContext) || parseErrorBeforeNextFinishedNode) {
                 return undefined;
             }
-            var node = syntaxCursor.currentNode(scanner.getStartPos());
+            var node = syntaxCursor.currentNode(pos !== null && pos !== void 0 ? pos : scanner.getStartPos());
             // Can't reuse a missing node.
             // Can't reuse a node that intersected the change range.
             // Can't reuse a node that contains a parse error.  This is necessary so that we
@@ -36779,24 +36779,19 @@ var ts;
             return modifier.kind === 135 /* DeclareKeyword */;
         }
         function parseDeclaration() {
-            // TODO: Can we hold onto the parsed decorators/modifiers and advance the scanner
-            //       if we can't reuse the declaration, so that we don't do this work twice?
-            //
             // `parseListElement` attempted to get the reused node at this position,
             // but the ambient context flag was not yet set, so the node appeared
             // not reusable in that context.
-            var isAmbient = ts.some(lookAhead(function () { return (parseDecorators(), parseModifiers()); }), isDeclareModifier);
-            if (isAmbient) {
-                var node = tryReuseAmbientDeclaration();
-                if (node) {
-                    return node;
-                }
-            }
             var pos = getNodePos();
             var hasJSDoc = hasPrecedingJSDocComment();
             var decorators = parseDecorators();
             var modifiers = parseModifiers();
+            var isAmbient = ts.some(modifiers, isDeclareModifier);
             if (isAmbient) {
+                var node = tryReuseAmbientDeclaration(pos);
+                if (node) {
+                    return node;
+                }
                 for (var _i = 0, _a = modifiers; _i < _a.length; _i++) {
                     var m = _a[_i];
                     m.flags |= 16777216 /* Ambient */;
@@ -36807,9 +36802,9 @@ var ts;
                 return parseDeclarationWorker(pos, hasJSDoc, decorators, modifiers);
             }
         }
-        function tryReuseAmbientDeclaration() {
+        function tryReuseAmbientDeclaration(pos) {
             return doInsideOfContext(16777216 /* Ambient */, function () {
-                var node = currentNode(parsingContext);
+                var node = currentNode(parsingContext, pos);
                 if (node) {
                     return consumeNode(node);
                 }
@@ -88245,13 +88240,20 @@ var ts;
                 if (!fileToDirective) {
                     return undefined;
                 }
+                // computed property name should use node as value
                 // property access can only be used as values, or types when within an expression with type arguments inside a heritage clause
                 // qualified names can only be used as types\namespaces
                 // identifiers are treated as values only if they appear in type queries
-                var meaning = 788968 /* Type */ | 1920 /* Namespace */;
-                if ((node.kind === 79 /* Identifier */ && isInTypeQuery(node)) || (node.kind === 206 /* PropertyAccessExpression */ && !isInHeritageClause(node))) {
+                var meaning;
+                if (node.parent.kind === 162 /* ComputedPropertyName */) {
                     meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
                 }
+                else {
+                    meaning = 788968 /* Type */ | 1920 /* Namespace */;
+                    if ((node.kind === 79 /* Identifier */ && isInTypeQuery(node)) || (node.kind === 206 /* PropertyAccessExpression */ && !isInHeritageClause(node))) {
+                        meaning = 111551 /* Value */ | 1048576 /* ExportValue */;
+                    }
+                }
                 var symbol = resolveEntityName(node, meaning, /*ignoreErrors*/ true);
                 return symbol && symbol !== unknownSymbol ? getTypeReferenceDirectivesForSymbol(symbol, meaning) : undefined;
             }
@@ -111363,7 +111365,6 @@ var ts;
         var _b = ts.performance.createTimer("printTime", "beforePrint", "afterPrint"), enter = _b.enter, exit = _b.exit;
         var bundleBuildInfo;
         var emitSkipped = false;
-        var exportedModulesFromDeclarationEmit;
         // Emit each output file
         enter();
         forEachEmittedFile(host, emitSourceFileOrBundle, ts.getSourceFilesToEmit(host, targetSourceFile, forceDtsEmit), forceDtsEmit, onlyBuildInfo, !targetSourceFile);
@@ -111373,7 +111374,6 @@ var ts;
             diagnostics: emitterDiagnostics.getDiagnostics(),
             emittedFiles: emittedFilesList,
             sourceMaps: sourceMapDataList,
-            exportedModulesFromDeclarationEmit: exportedModulesFromDeclarationEmit
         };
         function emitSourceFileOrBundle(_a, sourceFileOrBundle) {
             var jsFilePath = _a.jsFilePath, sourceMapFilePath = _a.sourceMapFilePath, declarationFilePath = _a.declarationFilePath, declarationMapPath = _a.declarationMapPath, buildInfoPath = _a.buildInfoPath;
@@ -111465,7 +111465,7 @@ var ts;
                 substituteNode: transform.substituteNode,
             });
             ts.Debug.assert(transform.transformed.length === 1, "Should only see one output from the transform");
-            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform.transformed[0], printer, compilerOptions);
+            printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, compilerOptions);
             // Clean up emit nodes on parse tree
             transform.dispose();
             if (bundleBuildInfo)
@@ -111501,7 +111501,7 @@ var ts;
                 noEmitHelpers: true,
                 module: compilerOptions.module,
                 target: compilerOptions.target,
-                sourceMap: compilerOptions.sourceMap,
+                sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
                 inlineSourceMap: compilerOptions.inlineSourceMap,
                 extendedDiagnostics: compilerOptions.extendedDiagnostics,
                 onlyPrintJsDocStyle: true,
@@ -111521,17 +111521,13 @@ var ts;
             emitSkipped = emitSkipped || declBlocked;
             if (!declBlocked || forceDtsEmit) {
                 ts.Debug.assert(declarationTransform.transformed.length === 1, "Should only see one output from the decl transform");
-                printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform.transformed[0], declarationPrinter, {
-                    sourceMap: !forceDtsEmit && compilerOptions.declarationMap,
+                printSourceFileOrBundle(declarationFilePath, declarationMapPath, declarationTransform, declarationPrinter, {
+                    sourceMap: printerOptions.sourceMap,
                     sourceRoot: compilerOptions.sourceRoot,
                     mapRoot: compilerOptions.mapRoot,
                     extendedDiagnostics: compilerOptions.extendedDiagnostics,
                     // Explicitly do not passthru either `inline` option
                 });
-                if (forceDtsEmit && declarationTransform.transformed[0].kind === 305 /* SourceFile */) {
-                    var sourceFile = declarationTransform.transformed[0];
-                    exportedModulesFromDeclarationEmit = sourceFile.exportedModulesFromDeclarationEmit;
-                }
             }
             declarationTransform.dispose();
             if (bundleBuildInfo)
@@ -111550,7 +111546,8 @@ var ts;
             }
             ts.forEachChild(node, collectLinkedAliases);
         }
-        function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, sourceFileOrBundle, printer, mapOptions) {
+        function printSourceFileOrBundle(jsFilePath, sourceMapFilePath, transform, printer, mapOptions) {
+            var sourceFileOrBundle = transform.transformed[0];
             var bundle = sourceFileOrBundle.kind === 306 /* Bundle */ ? sourceFileOrBundle : undefined;
             var sourceFile = sourceFileOrBundle.kind === 305 /* SourceFile */ ? sourceFileOrBundle : undefined;
             var sourceFiles = bundle ? bundle.sourceFiles : [sourceFile];
@@ -111584,7 +111581,7 @@ var ts;
                     var sourceMap = sourceMapGenerator.toString();
                     ts.writeFile(host, emitterDiagnostics, sourceMapFilePath, sourceMap, /*writeByteOrderMark*/ false, sourceFiles);
                     if (printer.bundleFileInfo)
-                        printer.bundleFileInfo.mapHash = ts.BuilderState.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
+                        printer.bundleFileInfo.mapHash = ts.computeSignature(sourceMap, ts.maybeBind(host, host.createHash));
                 }
             }
             else {
@@ -111592,11 +111589,11 @@ var ts;
             }
             // Write the output file
             var text = writer.getText();
-            ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos });
+            ts.writeFile(host, emitterDiagnostics, jsFilePath, text, !!compilerOptions.emitBOM, sourceFiles, { sourceMapUrlPos: sourceMapUrlPos, diagnostics: transform.diagnostics });
             // We store the hash of the text written in the buildinfo to ensure that text of the referenced d.ts file is same as whats in the buildinfo
             // This is needed because incremental can be toggled between two runs and we might use stale file text to do text manipulation in prepend mode
             if (printer.bundleFileInfo)
-                printer.bundleFileInfo.hash = ts.BuilderState.computeSignature(text, ts.maybeBind(host, host.createHash));
+                printer.bundleFileInfo.hash = ts.computeSignature(text, ts.maybeBind(host, host.createHash));
             // Reset state
             writer.clear();
         }
@@ -111761,25 +111758,25 @@ var ts;
         if (!jsFileText)
             return jsFilePath;
         // If the jsFileText is not same has what it was created with, tsbuildinfo is stale so dont use it
-        if (ts.BuilderState.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
+        if (ts.computeSignature(jsFileText, createHash) !== buildInfo.bundle.js.hash)
             return jsFilePath;
         var sourceMapText = sourceMapFilePath && host.readFile(sourceMapFilePath);
         // error if no source map or for now if inline sourcemap
         if ((sourceMapFilePath && !sourceMapText) || config.options.inlineSourceMap)
             return sourceMapFilePath || "inline sourcemap decoding";
-        if (sourceMapFilePath && ts.BuilderState.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
+        if (sourceMapFilePath && ts.computeSignature(sourceMapText, createHash) !== buildInfo.bundle.js.mapHash)
             return sourceMapFilePath;
         // read declaration text
         var declarationText = declarationFilePath && host.readFile(declarationFilePath);
         if (declarationFilePath && !declarationText)
             return declarationFilePath;
-        if (declarationFilePath && ts.BuilderState.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
+        if (declarationFilePath && ts.computeSignature(declarationText, createHash) !== buildInfo.bundle.dts.hash)
             return declarationFilePath;
         var declarationMapText = declarationMapPath && host.readFile(declarationMapPath);
         // error if no source map or for now if inline sourcemap
         if ((declarationMapPath && !declarationMapText) || config.options.inlineSourceMap)
             return declarationMapPath || "inline sourcemap decoding";
-        if (declarationMapPath && ts.BuilderState.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
+        if (declarationMapPath && ts.computeSignature(declarationMapText, createHash) !== buildInfo.bundle.dts.mapHash)
             return declarationMapPath;
         var buildInfoDirectory = ts.getDirectoryPath(ts.getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
         var ownPrependInput = ts.createInputFiles(jsFileText, declarationText, sourceMapFilePath, sourceMapText, declarationMapPath, declarationMapText, jsFilePath, declarationFilePath, buildInfoPath, buildInfo, 
@@ -111819,7 +111816,7 @@ var ts;
                         newBuildInfo.program = buildInfo.program;
                         if (newBuildInfo.program && changedDtsText !== undefined && config.options.composite) {
                             // Update the output signature
-                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, changedDtsData, createHash);
+                            newBuildInfo.program.outSignature = ts.computeSignature(changedDtsText, createHash, changedDtsData);
                             newBuildInfo.program.dtsChangeTime = ts.getCurrentTime(host).getTime();
                         }
                         // Update sourceFileInfo
@@ -120704,8 +120701,8 @@ var ts;
 (function (ts) {
     function getFileEmitOutput(program, sourceFile, emitOnlyDtsFiles, cancellationToken, customTransformers, forceDtsEmit) {
         var outputFiles = [];
-        var _a = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit), emitSkipped = _a.emitSkipped, diagnostics = _a.diagnostics, exportedModulesFromDeclarationEmit = _a.exportedModulesFromDeclarationEmit;
-        return { outputFiles: outputFiles, emitSkipped: emitSkipped, diagnostics: diagnostics, exportedModulesFromDeclarationEmit: exportedModulesFromDeclarationEmit };
+        var _a = program.emit(sourceFile, writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers, forceDtsEmit), emitSkipped = _a.emitSkipped, diagnostics = _a.diagnostics;
+        return { outputFiles: outputFiles, emitSkipped: emitSkipped, diagnostics: diagnostics };
         function writeFile(fileName, text, writeByteOrderMark) {
             outputFiles.push({ name: fileName, writeByteOrderMark: writeByteOrderMark, text: text });
         }
@@ -120929,23 +120926,23 @@ var ts;
         /**
          * Gets the files affected by the path from the program
          */
-        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash) {
+        function getFilesAffectedBy(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
             var _a, _b;
-            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash);
+            var result = getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName);
             (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.clear();
             (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
             return result;
         }
         BuilderState.getFilesAffectedBy = getFilesAffectedBy;
-        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash) {
+        function getFilesAffectedByWithOldState(state, programOfThisState, path, cancellationToken, computeHash, getCanonicalFileName) {
             var sourceFile = programOfThisState.getSourceFileByPath(path);
             if (!sourceFile) {
                 return ts.emptyArray;
             }
-            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash)) {
+            if (!updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
                 return [sourceFile];
             }
-            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash);
+            return (state.referencedMap ? getFilesAffectedByUpdatedShapeWhenModuleEmit : getFilesAffectedByUpdatedShapeWhenNonModuleEmit)(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName);
         }
         BuilderState.getFilesAffectedByWithOldState = getFilesAffectedByWithOldState;
         function updateSignatureOfFile(state, signature, path) {
@@ -120956,7 +120953,7 @@ var ts;
         /**
          * Returns if the shape of the signature has changed since last emit
          */
-        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, useFileVersionAsSignature) {
+        function updateShapeSignature(state, programOfThisState, sourceFile, cancellationToken, computeHash, getCanonicalFileName, useFileVersionAsSignature) {
             var _a;
             if (useFileVersionAsSignature === void 0) { useFileVersionAsSignature = state.useFileVersionAsSignature; }
             // If we have cached the result for this file, that means hence forth we should assume file shape is uptodate
@@ -120966,18 +120963,16 @@ var ts;
             var prevSignature = info.signature;
             var latestSignature;
             if (!sourceFile.isDeclarationFile && !useFileVersionAsSignature) {
-                var emitOutput_1 = getFileEmitOutput(programOfThisState, sourceFile, 
-                /*emitOnlyDtsFiles*/ true, cancellationToken, 
-                /*customTransformers*/ undefined, 
-                /*forceDtsEmit*/ true);
-                var firstDts_1 = ts.firstOrUndefined(emitOutput_1.outputFiles);
-                if (firstDts_1) {
-                    ts.Debug.assert(ts.isDeclarationFileName(firstDts_1.name), "File extension for signature expected to be dts", function () { return "Found: " + ts.getAnyExtensionFromPath(firstDts_1.name) + " for " + firstDts_1.name + ":: All output files: " + JSON.stringify(emitOutput_1.outputFiles.map(function (f) { return f.name; })); });
-                    latestSignature = computeSignature(firstDts_1.text, computeHash);
+                programOfThisState.emit(sourceFile, function (fileName, text, _writeByteOrderMark, _onError, sourceFiles, data) {
+                    ts.Debug.assert(ts.isDeclarationFileName(fileName), "File extension for signature expected to be dts: Got:: " + fileName);
+                    latestSignature = ts.computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data);
                     if (latestSignature !== prevSignature) {
-                        updateExportedModules(state, sourceFile, emitOutput_1.exportedModulesFromDeclarationEmit);
+                        updateExportedModules(state, sourceFile, sourceFiles[0].exportedModulesFromDeclarationEmit);
                     }
-                }
+                }, cancellationToken, 
+                /*emitOnlyDtsFiles*/ true, 
+                /*customTransformers*/ undefined, 
+                /*forceDtsEmit*/ true);
             }
             // Default is to use file version as signature
             if (latestSignature === undefined) {
@@ -121000,10 +120995,6 @@ var ts;
             return latestSignature !== prevSignature;
         }
         BuilderState.updateShapeSignature = updateShapeSignature;
-        function computeSignature(text, computeHash) {
-            return (computeHash || ts.generateDjb2Hash)(text);
-        }
-        BuilderState.computeSignature = computeSignature;
         /**
          * Coverts the declaration emit result into exported modules map
          */
@@ -121153,7 +121144,7 @@ var ts;
         /**
          * When program emits modular code, gets the files affected by the sourceFile whose shape has changed
          */
-        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash) {
+        function getFilesAffectedByUpdatedShapeWhenModuleEmit(state, programOfThisState, sourceFileWithUpdatedShape, cancellationToken, computeHash, getCanonicalFileName) {
             if (isFileAffectingGlobalScope(sourceFileWithUpdatedShape)) {
                 return getAllFilesExcludingDefaultLibraryFile(state, programOfThisState, sourceFileWithUpdatedShape);
             }
@@ -121173,7 +121164,7 @@ var ts;
                 if (!seenFileNamesMap.has(currentPath)) {
                     var currentSourceFile = programOfThisState.getSourceFileByPath(currentPath);
                     seenFileNamesMap.set(currentPath, currentSourceFile);
-                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash)) {
+                    if (currentSourceFile && updateShapeSignature(state, programOfThisState, currentSourceFile, cancellationToken, computeHash, getCanonicalFileName)) {
                         queue.push.apply(queue, getReferencedByPaths(state, currentSourceFile.resolvedPath));
                     }
                 }
@@ -121367,7 +121358,7 @@ var ts;
      * This is to allow the callers to be able to actually remove affected file only when the operation is complete
      * eg. if during diagnostics check cancellation token ends up cancelling the request, the affected file should be retained
      */
-    function getNextAffectedFile(state, cancellationToken, computeHash, host) {
+    function getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a, _b;
         while (true) {
             var affectedFiles = state.affectedFiles;
@@ -121379,7 +121370,7 @@ var ts;
                     if (!seenAffectedFiles.has(affectedFile.resolvedPath)) {
                         // Set the next affected file as seen and remove the cached semantic diagnostics
                         state.affectedFilesIndex = affectedFilesIndex;
-                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
+                        handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
                         return affectedFile;
                     }
                     affectedFilesIndex++;
@@ -121407,7 +121398,7 @@ var ts;
                 return program;
             }
             // Get next batch of affected files
-            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash);
+            state.affectedFiles = ts.BuilderState.getFilesAffectedByWithOldState(state, program, nextKey.value, cancellationToken, computeHash, getCanonicalFileName);
             state.currentChangedFilePath = nextKey.value;
             state.affectedFilesIndex = 0;
             if (!state.seenAffectedFiles)
@@ -121458,7 +121449,7 @@ var ts;
      *  Handles semantic diagnostics and dts emit for affectedFile and files, that are referencing modules that export entities from affected file
      *  This is because even though js emit doesnt change, dts emit / type used can change resulting in need for dts emit and js change
      */
-    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
+    function handleDtsMayChangeOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         removeSemanticDiagnosticsOf(state, affectedFile.resolvedPath);
         // If affected files is everything except default library, then nothing more to do
         if (state.allFilesExcludingDefaultLibraryFile === state.affectedFiles) {
@@ -121466,18 +121457,18 @@ var ts;
             // When a change affects the global scope, all files are considered to be affected without updating their signature
             // That means when affected file is handled, its signature can be out of date
             // To avoid this, ensure that we update the signature for any affected file in this scenario.
-            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash);
+            ts.BuilderState.updateShapeSignature(state, ts.Debug.checkDefined(state.program), affectedFile, cancellationToken, computeHash, getCanonicalFileName);
             return;
         }
         if (state.compilerOptions.assumeChangesOnlyAffectDirectDependencies)
             return;
-        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host);
+        handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host);
     }
     /**
      * Handle the dts may change, so they need to be added to pending emit if dts emit is enabled,
      * Also we need to make sure signature is updated for these files
      */
-    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, host) {
+    function handleDtsMayChangeOf(state, path, cancellationToken, computeHash, getCanonicalFileName, host) {
         removeSemanticDiagnosticsOf(state, path);
         if (!state.changedFilesSet.has(path)) {
             var program = ts.Debug.checkDefined(state.program);
@@ -121488,7 +121479,7 @@ var ts;
                 // This ensures that we dont later during incremental builds considering wrong signature.
                 // Eg where this also is needed to ensure that .tsbuildinfo generated by incremental build should be same as if it was first fresh build
                 // But we avoid expensive full shape computation, as using file version as shape is enough for correctness.
-                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, !host.disableUseFileVersionAsSignature);
+                ts.BuilderState.updateShapeSignature(state, program, sourceFile, cancellationToken, computeHash, getCanonicalFileName, !host.disableUseFileVersionAsSignature);
                 // If not dts emit, nothing more to do
                 if (ts.getEmitDeclarations(state.compilerOptions)) {
                     addToAffectedFilesPendingEmit(state, path, 0 /* DtsOnly */);
@@ -121513,20 +121504,20 @@ var ts;
         var newSignature = ts.Debug.checkDefined(state.fileInfos.get(path)).signature;
         return newSignature !== oldSignature;
     }
-    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host) {
+    function handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a;
         if (!((_a = state.fileInfos.get(filePath)) === null || _a === void 0 ? void 0 : _a.affectsGlobalScope))
             return false;
         // Every file needs to be handled
         ts.BuilderState.getAllFilesExcludingDefaultLibraryFile(state, state.program, /*firstSourceFile*/ undefined)
-            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, host); });
+            .forEach(function (file) { return handleDtsMayChangeOf(state, file.resolvedPath, cancellationToken, computeHash, getCanonicalFileName, host); });
         removeDiagnosticsOfLibraryFiles(state);
         return true;
     }
     /**
      * Iterate on referencing modules that export entities from affected file and delete diagnostics and add pending emit
      */
-    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, host) {
+    function handleDtsMayChangeOfReferencingExportOfAffectedFile(state, affectedFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a;
         // If there was change in signature (dts output) for the changed file,
         // then only we need to handle pending file emit
@@ -121544,9 +121535,9 @@ var ts;
                 var currentPath = queue.pop();
                 if (!seenFileNamesMap.has(currentPath)) {
                     seenFileNamesMap.set(currentPath, true);
-                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, host))
+                    if (handleDtsMayChangeOfGlobalScope(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host))
                         return;
-                    handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, host);
+                    handleDtsMayChangeOf(state, currentPath, cancellationToken, computeHash, getCanonicalFileName, host);
                     if (isChangedSignature(state, currentPath)) {
                         var currentSourceFile = ts.Debug.checkDefined(state.program).getSourceFileByPath(currentPath);
                         queue.push.apply(queue, ts.BuilderState.getReferencedByPaths(state, currentSourceFile.resolvedPath));
@@ -121558,11 +121549,11 @@ var ts;
         // Go through exported modules from cache first
         // If exported modules has path, all files referencing file exported from are affected
         (_a = state.exportedModulesMap.getKeys(affectedFile.resolvedPath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, host))
+            if (handleDtsMayChangeOfGlobalScope(state, exportedFromPath, cancellationToken, computeHash, getCanonicalFileName, host))
                 return true;
             var references = state.referencedMap.getKeys(exportedFromPath);
             return references && ts.forEachKey(references, function (filePath) {
-                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
+                return handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
             });
         });
     }
@@ -121570,22 +121561,22 @@ var ts;
      * handle dts and semantic diagnostics on file and iterate on anything that exports this file
      * return true when all work is done and we can exit handling dts emit and semantic diagnostics
      */
-    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, host) {
+    function handleDtsMayChangeOfFileAndExportsOfFile(state, filePath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host) {
         var _a, _b;
         if (!ts.tryAddToSet(seenFileAndExportsOfFile, filePath))
             return undefined;
-        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, host))
+        if (handleDtsMayChangeOfGlobalScope(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host))
             return true;
-        handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, host);
+        handleDtsMayChangeOf(state, filePath, cancellationToken, computeHash, getCanonicalFileName, host);
         // If exported modules has path, all files referencing file exported from are affected
         (_a = state.exportedModulesMap.getKeys(filePath)) === null || _a === void 0 ? void 0 : _a.forEach(function (exportedFromPath) {
-            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, host);
+            return handleDtsMayChangeOfFileAndExportsOfFile(state, exportedFromPath, seenFileAndExportsOfFile, cancellationToken, computeHash, getCanonicalFileName, host);
         });
         // Remove diagnostics of files that import this file (without going to exports of referencing files)
         (_b = state.referencedMap.getKeys(filePath)) === null || _b === void 0 ? void 0 : _b.forEach(function (referencingFilePath) {
             return !seenFileAndExportsOfFile.has(referencingFilePath) && // Not already removed diagnostic file
                 handleDtsMayChangeOf(// Dont add to seen since this is not yet done with the export removal
-                state, referencingFilePath, cancellationToken, computeHash, host);
+                state, referencingFilePath, cancellationToken, computeHash, getCanonicalFileName, host);
         });
         return undefined;
     }
@@ -121904,8 +121895,39 @@ var ts;
         return { host: host, newProgram: newProgram, oldProgram: oldProgram, configFileParsingDiagnostics: configFileParsingDiagnostics || ts.emptyArray };
     }
     ts.getBuilderCreationParameters = getBuilderCreationParameters;
-    function computeSignature(text, data, computeHash) {
-        return ts.BuilderState.computeSignature((data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text, computeHash);
+    function getTextHandlingSourceMapForSignature(text, data) {
+        return (data === null || data === void 0 ? void 0 : data.sourceMapUrlPos) !== undefined ? text.substring(0, data.sourceMapUrlPos) : text;
+    }
+    function computeSignatureWithDiagnostics(sourceFile, text, computeHash, getCanonicalFileName, data) {
+        var _a;
+        text = getTextHandlingSourceMapForSignature(text, data);
+        var sourceFileDirectory;
+        if ((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length) {
+            text += data.diagnostics.map(function (diagnostic) {
+                return "" + locationInfo(diagnostic) + ts.DiagnosticCategory[diagnostic.category] + diagnostic.code + ": " + flattenDiagnosticMessageText(diagnostic.messageText);
+            }).join("\n");
+        }
+        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(text);
+        function flattenDiagnosticMessageText(diagnostic) {
+            return ts.isString(diagnostic) ?
+                diagnostic :
+                diagnostic === undefined ?
+                    "" :
+                    !diagnostic.next ?
+                        diagnostic.messageText :
+                        diagnostic.messageText + diagnostic.next.map(flattenDiagnosticMessageText).join("\n");
+        }
+        function locationInfo(diagnostic) {
+            if (diagnostic.file.resolvedPath === sourceFile.resolvedPath)
+                return "(" + diagnostic.start + "," + diagnostic.length + ")";
+            if (sourceFileDirectory === undefined)
+                sourceFileDirectory = ts.getDirectoryPath(sourceFile.resolvedPath);
+            return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourceFileDirectory, diagnostic.file.resolvedPath, getCanonicalFileName)) + "(" + diagnostic.start + "," + diagnostic.length + ")";
+        }
+    }
+    ts.computeSignatureWithDiagnostics = computeSignatureWithDiagnostics;
+    function computeSignature(text, computeHash, data) {
+        return (computeHash !== null && computeHash !== void 0 ? computeHash : ts.generateDjb2Hash)(getTextHandlingSourceMapForSignature(text, data));
     }
     ts.computeSignature = computeSignature;
     function createBuilderProgram(kind, _a) {
@@ -121966,7 +121988,7 @@ var ts;
          * in that order would be used to write the files
          */
         function emitNextAffectedFile(writeFile, cancellationToken, emitOnlyDtsFiles, customTransformers) {
-            var affected = getNextAffectedFile(state, cancellationToken, computeHash, host);
+            var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
             var emitKind = 1 /* Full */;
             var isPendingEmitFile = false;
             if (!affected) {
@@ -122003,32 +122025,35 @@ var ts;
         }
         function getWriteFileCallback(writeFile, customTransformers) {
             return function (fileName, text, writeByteOrderMark, onError, sourceFiles, data) {
-                var _a, _b, _c;
+                var _a, _b, _c, _d, _e, _f, _g;
                 if (ts.isDeclarationFileName(fileName)) {
                     if (!ts.outFile(state.compilerOptions)) {
                         ts.Debug.assert((sourceFiles === null || sourceFiles === void 0 ? void 0 : sourceFiles.length) === 1);
-                        var newSignature = void 0;
+                        var emitSignature = void 0;
                         if (!customTransformers) {
                             var file = sourceFiles[0];
                             var info = state.fileInfos.get(file.resolvedPath);
                             if (info.signature === file.version) {
-                                newSignature = computeSignature(text, data, computeHash);
-                                if (newSignature !== file.version) { // Update it
+                                var signature = computeSignatureWithDiagnostics(file, text, computeHash, getCanonicalFileName, data);
+                                // With d.ts diagnostics they are also part of the signature so emitSignature will be different from it since its just hash of d.ts
+                                if (!((_a = data === null || data === void 0 ? void 0 : data.diagnostics) === null || _a === void 0 ? void 0 : _a.length))
+                                    emitSignature = signature;
+                                if (signature !== file.version) { // Update it
                                     if (host.storeFilesChangingSignatureDuringEmit)
-                                        (state.filesChangingSignature || (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
+                                        ((_b = state.filesChangingSignature) !== null && _b !== void 0 ? _b : (state.filesChangingSignature = new ts.Set())).add(file.resolvedPath);
                                     if (state.exportedModulesMap)
                                         ts.BuilderState.updateExportedModules(state, file, file.exportedModulesFromDeclarationEmit);
                                     if (state.affectedFiles) {
                                         // Keep old signature so we know what to undo if cancellation happens
-                                        var existing = (_a = state.oldSignatures) === null || _a === void 0 ? void 0 : _a.get(file.resolvedPath);
+                                        var existing = (_c = state.oldSignatures) === null || _c === void 0 ? void 0 : _c.get(file.resolvedPath);
                                         if (existing === undefined)
-                                            (state.oldSignatures || (state.oldSignatures = new ts.Map())).set(file.resolvedPath, info.signature || false);
-                                        info.signature = newSignature;
+                                            ((_d = state.oldSignatures) !== null && _d !== void 0 ? _d : (state.oldSignatures = new ts.Map())).set(file.resolvedPath, info.signature || false);
+                                        info.signature = signature;
                                     }
                                     else {
                                         // These are directly commited
-                                        info.signature = newSignature;
-                                        (_b = state.oldExportedModulesMap) === null || _b === void 0 ? void 0 : _b.clear();
+                                        info.signature = signature;
+                                        (_e = state.oldExportedModulesMap) === null || _e === void 0 ? void 0 : _e.clear();
                                     }
                                 }
                             }
@@ -122038,16 +122063,16 @@ var ts;
                         // and would need their d.ts change time in --build mode
                         if (state.compilerOptions.composite) {
                             var filePath = sourceFiles[0].resolvedPath;
-                            var oldSignature = (_c = state.emitSignatures) === null || _c === void 0 ? void 0 : _c.get(filePath);
-                            newSignature || (newSignature = computeSignature(text, data, computeHash));
-                            if (newSignature !== oldSignature) {
-                                (state.emitSignatures || (state.emitSignatures = new ts.Map())).set(filePath, newSignature);
+                            var oldSignature = (_f = state.emitSignatures) === null || _f === void 0 ? void 0 : _f.get(filePath);
+                            emitSignature !== null && emitSignature !== void 0 ? emitSignature : (emitSignature = computeSignature(text, computeHash, data));
+                            if (emitSignature !== oldSignature) {
+                                ((_g = state.emitSignatures) !== null && _g !== void 0 ? _g : (state.emitSignatures = new ts.Map())).set(filePath, emitSignature);
                                 state.hasChangedEmitSignature = true;
                             }
                         }
                     }
                     else if (state.compilerOptions.composite) {
-                        var newSignature = computeSignature(text, data, computeHash);
+                        var newSignature = computeSignature(text, computeHash, data);
                         if (newSignature !== state.outSignature) {
                             state.outSignature = newSignature;
                             state.hasChangedEmitSignature = true;
@@ -122127,7 +122152,7 @@ var ts;
          */
         function getSemanticDiagnosticsOfNextAffectedFile(cancellationToken, ignoreSourceFile) {
             while (true) {
-                var affected = getNextAffectedFile(state, cancellationToken, computeHash, host);
+                var affected = getNextAffectedFile(state, cancellationToken, computeHash, getCanonicalFileName, host);
                 if (!affected) {
                     // Done
                     return undefined;
@@ -128992,12 +129017,18 @@ var ts;
                 // flag causes us to return the first node whose end position matches the position and which produces and acceptable token
                 // kind. Meanwhile, if includePrecedingTokenAtEndPosition is unset, we look for the first node whose start is <= the
                 // position and whose end is greater than the position.
+                // There are more sophisticated end tests later, but this one is very fast
+                // and allows us to skip a bunch of work
+                var end = children[middle].getEnd();
+                if (end < position) {
+                    return -1 /* LessThan */;
+                }
                 var start = allowPositionInLeadingTrivia ? children[middle].getFullStart() : children[middle].getStart(sourceFile, /*includeJsDoc*/ true);
                 if (start > position) {
                     return 1 /* GreaterThan */;
                 }
                 // first element whose start position is before the input and whose end position is after or equal to the input
-                if (nodeContainsPosition(children[middle])) {
+                if (nodeContainsPosition(children[middle], start, end)) {
                     if (children[middle - 1]) {
                         // we want the _first_ element that contains the position, so left-recur if the prior node also contains the position
                         if (nodeContainsPosition(children[middle - 1])) {
@@ -129029,13 +129060,16 @@ var ts;
                 case "continue-outer": continue outer;
             }
         }
-        function nodeContainsPosition(node) {
-            var start = allowPositionInLeadingTrivia ? node.getFullStart() : node.getStart(sourceFile, /*includeJsDoc*/ true);
+        function nodeContainsPosition(node, start, end) {
+            end !== null && end !== void 0 ? end : (end = node.getEnd());
+            if (end < position) {
+                return false;
+            }
+            start !== null && start !== void 0 ? start : (start = allowPositionInLeadingTrivia ? node.getFullStart() : node.getStart(sourceFile, /*includeJsDoc*/ true));
             if (start > position) {
                 // If this child begins after position, then all subsequent children will as well.
                 return false;
             }
-            var end = node.getEnd();
             if (position < end || (position === end && (node.kind === 1 /* EndOfFileToken */ || includeEndPosition))) {
                 return true;
             }