@typescript-deploys/pr-build 4.9.0-pr-50306-2 → 4.9.0-pr-50366-2

package/lib/tsserver.js

@@ -109,7 +109,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-insiders.20220815";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20220819";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1163,6 +1163,13 @@ var ts;
             : undefined;
     }
     ts.singleOrUndefined = singleOrUndefined;
+    /**
+     * Returns the only element of an array if it contains only one element; throws otherwise.
+     */
+    function single(array) {
+        return ts.Debug.checkDefined(singleOrUndefined(array));
+    }
+    ts.single = single;
     function singleOrMany(array) {
         return array && array.length === 1
             ? array[0]
@@ -6134,7 +6141,6 @@ var ts;
     var pollingChunkSize = createPollingIntervalBasedLevels(defaultChunkLevels);
     /* @internal */
     ts.unchangedPollThresholds = createPollingIntervalBasedLevels(defaultChunkLevels);
-    /* @internal */
     function setCustomPollingValues(system) {
         if (!system.getEnvironmentVariable) {
             return;
@@ -6177,7 +6183,6 @@ var ts;
                 createPollingIntervalBasedLevels(customLevels ? __assign(__assign({}, defaultLevels), customLevels) : defaultLevels);
         }
     }
-    ts.setCustomPollingValues = setCustomPollingValues;
     function pollWatchedFileQueue(host, queue, pollIndex, chunkSize, callbackOnWatchFileStat) {
         var definedValueCopyToIndex = pollIndex;
         // Max visit would be all elements of the queue
@@ -6223,7 +6228,6 @@ var ts;
             }
         }
     }
-    /* @internal */
     function createDynamicPriorityPollingWatchFile(host) {
         var watchedFiles = [];
         var changedFilesInLastPoll = [];
@@ -6332,7 +6336,6 @@ var ts;
             pollingIntervalQueue(pollingInterval).pollScheduled = host.setTimeout(pollingInterval === PollingInterval.Low ? pollLowPollingIntervalQueue : pollPollingIntervalQueue, pollingInterval, pollingIntervalQueue(pollingInterval));
         }
     }
-    ts.createDynamicPriorityPollingWatchFile = createDynamicPriorityPollingWatchFile;
     function createUseFsEventsOnParentDirectoryWatchFile(fsWatch, useCaseSensitiveFileNames) {
         // One file can have multiple watchers
         var fileWatcherCallbacks = ts.createMultiMap();
@@ -6411,42 +6414,36 @@ var ts;
             pollScheduled = host.setTimeout(pollQueue, PollingInterval.High);
         }
     }
-    /* @internal */
-    function createSingleFileWatcherPerName(watchFile, useCaseSensitiveFileNames) {
-        var cache = new ts.Map();
-        var callbacksCache = ts.createMultiMap();
+    function createSingleWatcherPerName(cache, useCaseSensitiveFileNames, name, callback, createWatcher) {
         var toCanonicalFileName = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
-        return function (fileName, callback, pollingInterval, options) {
-            var path = toCanonicalFileName(fileName);
-            var existing = cache.get(path);
-            if (existing) {
-                existing.refCount++;
-            }
-            else {
-                cache.set(path, {
-                    watcher: watchFile(fileName, function (fileName, eventKind, modifiedTime) { return ts.forEach(callbacksCache.get(path), function (cb) { return cb(fileName, eventKind, modifiedTime); }); }, pollingInterval, options),
-                    refCount: 1
-                });
+        var path = toCanonicalFileName(name);
+        var existing = cache.get(path);
+        if (existing) {
+            existing.callbacks.push(callback);
+        }
+        else {
+            cache.set(path, {
+                watcher: createWatcher((
+                // Cant infer types correctly so lets satisfy checker
+                function (param1, param2, param3) { var _a; return (_a = cache.get(path)) === null || _a === void 0 ? void 0 : _a.callbacks.slice().forEach(function (cb) { return cb(param1, param2, param3); }); })),
+                callbacks: [callback]
+            });
+        }
+        return {
+            close: function () {
+                var watcher = cache.get(path);
+                if (!watcher)
+                    return;
+                if (!ts.orderedRemoveItem(watcher.callbacks, callback) || watcher.callbacks.length)
+                    return;
+                cache.delete(path);
+                ts.closeFileWatcherOf(watcher);
             }
-            callbacksCache.add(path, callback);
-            return {
-                close: function () {
-                    var watcher = ts.Debug.checkDefined(cache.get(path));
-                    callbacksCache.remove(path, callback);
-                    watcher.refCount--;
-                    if (watcher.refCount)
-                        return;
-                    cache.delete(path);
-                    ts.closeFileWatcherOf(watcher);
-                }
-            };
         };
     }
-    ts.createSingleFileWatcherPerName = createSingleFileWatcherPerName;
     /**
      * Returns true if file status changed
      */
-    /*@internal*/
     function onWatchedFileStat(watchedFile, modifiedTime) {
         var oldTime = watchedFile.mtime.getTime();
         var newTime = modifiedTime.getTime();
@@ -6458,7 +6455,6 @@ var ts;
         }
         return false;
     }
-    ts.onWatchedFileStat = onWatchedFileStat;
     /*@internal*/
     function getFileWatcherEventKind(oldTime, newTime) {
         return oldTime === 0
@@ -6486,7 +6482,6 @@ var ts;
      * that means if this is recursive watcher, watch the children directories as well
      * (eg on OS that dont support recursive watch using fs.watch use fs.watchFile)
      */
-    /*@internal*/
     function createDirectoryWatcherSupportingRecursive(_a) {
         var watchDirectory = _a.watchDirectory, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, fileSystemEntryExists = _a.fileSystemEntryExists, realpath = _a.realpath, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout;
         var cache = new ts.Map();
@@ -6695,18 +6690,15 @@ var ts;
             return ts.stringContains(toCanonicalFilePath(path), searchPath);
         }
     }
-    ts.createDirectoryWatcherSupportingRecursive = createDirectoryWatcherSupportingRecursive;
     /*@internal*/
     var FileSystemEntryKind;
     (function (FileSystemEntryKind) {
         FileSystemEntryKind[FileSystemEntryKind["File"] = 0] = "File";
         FileSystemEntryKind[FileSystemEntryKind["Directory"] = 1] = "Directory";
     })(FileSystemEntryKind = ts.FileSystemEntryKind || (ts.FileSystemEntryKind = {}));
-    /*@internal*/
     function createFileWatcherCallback(callback) {
         return function (_fileName, eventKind, modifiedTime) { return callback(eventKind === FileWatcherEventKind.Changed ? "change" : "rename", "", modifiedTime); };
     }
-    ts.createFileWatcherCallback = createFileWatcherCallback;
     function createFsWatchCallbackForFileWatcherCallback(fileName, callback, getModifiedTime) {
         return function (eventName, _relativeFileName, modifiedTime) {
             if (eventName === "rename") {
@@ -6740,7 +6732,10 @@ var ts;
     }
     /*@internal*/
     function createSystemWatchFunctions(_a) {
-        var pollingWatchFile = _a.pollingWatchFile, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
+        var pollingWatchFileWorker = _a.pollingWatchFileWorker, getModifiedTime = _a.getModifiedTime, setTimeout = _a.setTimeout, clearTimeout = _a.clearTimeout, fsWatchWorker = _a.fsWatchWorker, fileSystemEntryExists = _a.fileSystemEntryExists, useCaseSensitiveFileNames = _a.useCaseSensitiveFileNames, getCurrentDirectory = _a.getCurrentDirectory, fsSupportsRecursiveFsWatch = _a.fsSupportsRecursiveFsWatch, getAccessibleSortedChildDirectories = _a.getAccessibleSortedChildDirectories, realpath = _a.realpath, tscWatchFile = _a.tscWatchFile, useNonPollingWatchers = _a.useNonPollingWatchers, tscWatchDirectory = _a.tscWatchDirectory, defaultWatchFileKind = _a.defaultWatchFileKind, inodeWatching = _a.inodeWatching, sysLog = _a.sysLog;
+        var pollingWatches = new ts.Map();
+        var fsWatches = new ts.Map();
+        var fsWatchesRecursive = new ts.Map();
         var dynamicPollingWatchFile;
         var fixedChunkSizePollingWatchFile;
         var nonPollingWatchFile;
@@ -6804,7 +6799,7 @@ var ts;
                         // Use notifications from FS to watch with falling back to fs.watchFile
                         generateWatchFileOptions(ts.WatchFileKind.UseFsEventsOnParentDirectory, ts.PollingWatchKind.PriorityInterval, options) :
                         // Default to do not use fixed polling interval
-                        { watchFile: (defaultWatchFileKind === null || defaultWatchFileKind === void 0 ? void 0 : defaultWatchFileKind()) || ts.WatchFileKind.FixedPollingInterval };
+                        { watchFile: (defaultWatchFileKind === null || defaultWatchFileKind === void 0 ? void 0 : defaultWatchFileKind()) || ts.WatchFileKind.UseFsEvents };
             }
         }
         function generateWatchFileOptions(watchFile, fallbackPolling, options) {
@@ -6875,7 +6870,13 @@ var ts;
                     };
             }
         }
+        function pollingWatchFile(fileName, callback, pollingInterval, options) {
+            return createSingleWatcherPerName(pollingWatches, useCaseSensitiveFileNames, fileName, callback, function (cb) { return pollingWatchFileWorker(fileName, cb, pollingInterval, options); });
+        }
         function fsWatch(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
+            return createSingleWatcherPerName(recursive ? fsWatchesRecursive : fsWatches, useCaseSensitiveFileNames, fileOrDirectory, callback, function (cb) { return fsWatchHandlingPresence(fileOrDirectory, entryKind, cb, recursive, fallbackPollingInterval, fallbackOptions); });
+        }
+        function fsWatchHandlingPresence(fileOrDirectory, entryKind, callback, recursive, fallbackPollingInterval, fallbackOptions) {
             var lastDirectoryPartWithDirectorySeparator;
             var lastDirectoryPart;
             if (inodeWatching) {
@@ -7054,7 +7055,7 @@ var ts;
             var fsSupportsRecursiveFsWatch = isNode4OrLater && (process.platform === "win32" || process.platform === "darwin");
             var getCurrentDirectory = ts.memoize(function () { return process.cwd(); });
             var _b = createSystemWatchFunctions({
-                pollingWatchFile: createSingleFileWatcherPerName(fsWatchFileWorker, useCaseSensitiveFileNames),
+                pollingWatchFileWorker: fsWatchFileWorker,
                 getModifiedTime: getModifiedTime,
                 setTimeout: setTimeout,
                 clearTimeout: clearTimeout,
@@ -8901,7 +8902,7 @@ var ts;
         Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashnode_and_then_add_node_to_the_types_field_in_your_tsconfig: diag(2591, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_node_Try_npm_i_save_dev_types_Slashno_2591", "Cannot find name '{0}'. Do you need to install type definitions for node? Try `npm i --save-dev @types/node` and then add 'node' to the types field in your tsconfig."),
         Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slashjquery_and_then_add_jquery_to_the_types_field_in_your_tsconfig: diag(2592, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_jQuery_Try_npm_i_save_dev_types_Slash_2592", "Cannot find name '{0}'. Do you need to install type definitions for jQuery? Try `npm i --save-dev @types/jquery` and then add 'jquery' to the types field in your tsconfig."),
         Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_types_Slashjest_or_npm_i_save_dev_types_Slashmocha_and_then_add_jest_or_mocha_to_the_types_field_in_your_tsconfig: diag(2593, ts.DiagnosticCategory.Error, "Cannot_find_name_0_Do_you_need_to_install_type_definitions_for_a_test_runner_Try_npm_i_save_dev_type_2593", "Cannot find name '{0}'. Do you need to install type definitions for a test runner? Try `npm i --save-dev @types/jest` or `npm i --save-dev @types/mocha` and then add 'jest' or 'mocha' to the types field in your tsconfig."),
-        This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts.DiagnosticCategory.Error, "This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the__2594", "This module is declared with using 'export =', and can only be used with a default import when using the '{0}' flag."),
+        This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag: diag(2594, ts.DiagnosticCategory.Error, "This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag_2594", "This module is declared with 'export =', and can only be used with a default import when using the '{0}' flag."),
         _0_can_only_be_imported_by_using_a_default_import: diag(2595, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_default_import_2595", "'{0}' can only be imported by using a default import."),
         _0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import: diag(2596, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_turning_on_the_esModuleInterop_flag_and_using_a_default_import_2596", "'{0}' can only be imported by turning on the 'esModuleInterop' flag and using a default import."),
         _0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import: diag(2597, ts.DiagnosticCategory.Error, "_0_can_only_be_imported_by_using_a_require_call_or_by_using_a_default_import_2597", "'{0}' can only be imported by using a 'require' call or by using a default import."),
@@ -18128,7 +18129,7 @@ var ts;
                 }
                 diagnostics = nonFileDiagnostics;
             }
-            ts.insertSorted(diagnostics, diagnostic, compareDiagnostics);
+            ts.insertSorted(diagnostics, diagnostic, compareDiagnosticsSkipRelatedInformation);
         }
         function getGlobalDiagnostics() {
             hasReadNonFileDiagnostics = true;
@@ -43105,10 +43106,12 @@ var ts;
         if (resolved) {
             var fileName = resolved.fileName, packageId = resolved.packageId;
             var resolvedFileName = options.preserveSymlinks ? fileName : realPath(fileName, host, traceEnabled);
+            var pathsAreEqual = arePathsEqual(fileName, resolvedFileName, host);
             resolvedTypeReferenceDirective = {
                 primary: primary,
-                resolvedFileName: resolvedFileName,
-                originalPath: arePathsEqual(fileName, resolvedFileName, host) ? undefined : fileName,
+                // If the fileName and realpath are differing only in casing prefer fileName so that we can issue correct errors for casing under forceConsistentCasingInFileNames
+                resolvedFileName: pathsAreEqual ? fileName : resolvedFileName,
+                originalPath: pathsAreEqual ? undefined : fileName,
                 packageId: packageId,
                 isExternalLibraryImport: pathContainsNodeModules(fileName),
             };
@@ -43893,8 +43896,10 @@ var ts;
                 var resolvedValue = resolved_1.value;
                 if (!compilerOptions.preserveSymlinks && resolvedValue && !resolvedValue.originalPath) {
                     var path = realPath(resolvedValue.path, host, traceEnabled);
-                    var originalPath = arePathsEqual(path, resolvedValue.path, host) ? undefined : resolvedValue.path;
-                    resolvedValue = __assign(__assign({}, resolvedValue), { path: path, originalPath: originalPath });
+                    var pathsAreEqual = arePathsEqual(path, resolvedValue.path, host);
+                    var originalPath = pathsAreEqual ? undefined : resolvedValue.path;
+                    // If the path and realpath are differing only in casing prefer path so that we can issue correct errors for casing under forceConsistentCasingInFileNames
+                    resolvedValue = __assign(__assign({}, resolvedValue), { path: pathsAreEqual ? resolvedValue.path : path, originalPath: originalPath });
                 }
                 // For node_modules lookups, get the real path so that multiple accesses to an `npm link`-ed module do not create duplicate files.
                 return { value: resolvedValue && { resolved: resolvedValue, isExternalLibraryImport: true } };
@@ -51055,7 +51060,7 @@ var ts;
                         var exportAssignment = exportEqualsSymbol.valueDeclaration;
                         var err = error(node.name, ts.Diagnostics.Module_0_can_only_be_default_imported_using_the_1_flag, symbolToString(moduleSymbol), compilerOptionName);
                         if (exportAssignment) {
-                            ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_using_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName));
+                            ts.addRelatedInfo(err, ts.createDiagnosticForNode(exportAssignment, ts.Diagnostics.This_module_is_declared_with_export_and_can_only_be_used_with_a_default_import_when_using_the_0_flag, compilerOptionName));
                         }
                     }
                     else {
@@ -65728,7 +65733,8 @@ var ts;
                             return 0 /* False */;
                         }
                     }
-                    var isPerformingCommonPropertyChecks = relation !== comparableRelation && !(intersectionState & 2 /* Target */) &&
+                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || relation === comparableRelation && isLiteralType(source)) &&
+                        !(intersectionState & 2 /* Target */) &&
                         source.flags & (131068 /* Primitive */ | 524288 /* Object */ | 2097152 /* Intersection */) && source !== globalObjectType &&
                         target.flags & (524288 /* Object */ | 2097152 /* Intersection */) && isWeakType(target) &&
                         (getPropertiesOfType(source).length > 0 || typeHasCallOrConstructSignatures(source));
@@ -66505,7 +66511,7 @@ var ts;
                                     // create a new chain for the constraint error
                                     resetErrorInfo(saveErrorInfo);
                                 }
-                                if (result = isRelatedTo(source, constraint, 2 /* Target */, reportErrors)) {
+                                if (result = isRelatedTo(source, constraint, 2 /* Target */, reportErrors, /* headMessage */ undefined, intersectionState)) {
                                     return result;
                                 }
                                 // prefer the shorter chain of the constraint comparison chain, and the direct comparison chain
@@ -68211,7 +68217,7 @@ var ts;
             if (!isLiteralOfContextualType(type, contextualType)) {
                 type = getWidenedUniqueESSymbolType(getWidenedLiteralType(type));
             }
-            return type;
+            return getRegularTypeOfLiteralType(type);
         }
         function getWidenedLiteralLikeTypeForContextualReturnTypeIfNeeded(type, contextualSignatureReturnType, isAsync) {
             if (type && isUnitType(type)) {
@@ -90408,6 +90414,7 @@ var ts;
 })(ts || (ts = {}));
 var ts;
 (function (ts) {
+    var _a;
     function visitNode(node, visitor, test, lift) {
         if (node === undefined || visitor === undefined) {
             return node;
@@ -90622,12 +90629,10 @@ var ts;
         return updated;
     }
     ts.visitFunctionBody = visitFunctionBody;
-    /**
-     * Visits an iteration body, adding any block-scoped variables required by the transformation.
-     */
-    function visitIterationBody(body, visitor, context) {
+    function visitIterationBody(body, visitor, context, nodeVisitor) {
+        if (nodeVisitor === void 0) { nodeVisitor = visitNode; }
         context.startBlockScope();
-        var updated = visitNode(body, visitor, ts.isStatement, context.factory.liftToBlock);
+        var updated = nodeVisitor(body, visitor, ts.isStatement, context.factory.liftToBlock);
         var declarations = context.endBlockScope();
         if (ts.some(declarations)) {
             if (ts.isBlock(updated)) {
@@ -90646,456 +90651,443 @@ var ts;
         if (node === undefined) {
             return undefined;
         }
-        var kind = node.kind;
-        // No need to visit nodes with no children.
-        if ((kind > 0 /* FirstToken */ && kind <= 160 /* LastToken */) || kind === 192 /* ThisType */) {
-            return node;
-        }
-        var factory = context.factory;
-        switch (kind) {
-            // Names
-            case 79 /* Identifier */:
-                ts.Debug.type(node);
-                return factory.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, ts.isTypeNodeOrTypeParameterDeclaration));
-            case 161 /* QualifiedName */:
-                ts.Debug.type(node);
-                return factory.updateQualifiedName(node, nodeVisitor(node.left, visitor, ts.isEntityName), nodeVisitor(node.right, visitor, ts.isIdentifier));
-            case 162 /* ComputedPropertyName */:
-                ts.Debug.type(node);
-                return factory.updateComputedPropertyName(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            // Signature elements
-            case 163 /* TypeParameter */:
-                ts.Debug.type(node);
-                return factory.updateTypeParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.constraint, visitor, ts.isTypeNode), nodeVisitor(node.default, visitor, ts.isTypeNode));
-            case 164 /* Parameter */:
-                ts.Debug.type(node);
-                return factory.updateParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            case 165 /* Decorator */:
-                ts.Debug.type(node);
-                return factory.updateDecorator(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            // Type elements
-            case 166 /* PropertySignature */:
-                ts.Debug.type(node);
-                return factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 167 /* PropertyDeclaration */:
-                ts.Debug.type(node);
-                return factory.updatePropertyDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), 
-                // QuestionToken and ExclamationToken is uniqued in Property Declaration and the signature of 'updateProperty' is that too
-                nodeVisitor(node.questionToken || node.exclamationToken, tokenVisitor, ts.isQuestionOrExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            case 168 /* MethodSignature */:
-                ts.Debug.type(node);
-                return factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 169 /* MethodDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateMethodDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 171 /* Constructor */:
-                ts.Debug.type(node);
-                return factory.updateConstructorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 172 /* GetAccessor */:
-                ts.Debug.type(node);
-                return factory.updateGetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 173 /* SetAccessor */:
-                ts.Debug.type(node);
-                return factory.updateSetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 170 /* ClassStaticBlockDeclaration */:
-                ts.Debug.type(node);
-                context.startLexicalEnvironment();
-                context.suspendLexicalEnvironment();
-                return factory.updateClassStaticBlockDeclaration(node, visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 174 /* CallSignature */:
-                ts.Debug.type(node);
-                return factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 175 /* ConstructSignature */:
-                ts.Debug.type(node);
-                return factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 176 /* IndexSignature */:
-                ts.Debug.type(node);
-                return factory.updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            // Types
-            case 177 /* TypePredicate */:
-                ts.Debug.type(node);
-                return factory.updateTypePredicateNode(node, nodeVisitor(node.assertsModifier, visitor, ts.isAssertsKeyword), nodeVisitor(node.parameterName, visitor, ts.isIdentifierOrThisTypeNode), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 178 /* TypeReference */:
-                ts.Debug.type(node);
-                return factory.updateTypeReferenceNode(node, nodeVisitor(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
-            case 179 /* FunctionType */:
-                ts.Debug.type(node);
-                return factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 180 /* ConstructorType */:
-                ts.Debug.type(node);
-                return factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 181 /* TypeQuery */:
-                ts.Debug.type(node);
-                return factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
-            case 182 /* TypeLiteral */:
-                ts.Debug.type(node);
-                return factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
-            case 183 /* ArrayType */:
-                ts.Debug.type(node);
-                return factory.updateArrayTypeNode(node, nodeVisitor(node.elementType, visitor, ts.isTypeNode));
-            case 184 /* TupleType */:
-                ts.Debug.type(node);
-                return factory.updateTupleTypeNode(node, nodesVisitor(node.elements, visitor, ts.isTypeNode));
-            case 185 /* OptionalType */:
-                ts.Debug.type(node);
-                return factory.updateOptionalTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 186 /* RestType */:
-                ts.Debug.type(node);
-                return factory.updateRestTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 187 /* UnionType */:
-                ts.Debug.type(node);
-                return factory.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
-            case 188 /* IntersectionType */:
-                ts.Debug.type(node);
-                return factory.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
-            case 189 /* ConditionalType */:
-                ts.Debug.type(node);
-                return factory.updateConditionalTypeNode(node, nodeVisitor(node.checkType, visitor, ts.isTypeNode), nodeVisitor(node.extendsType, visitor, ts.isTypeNode), nodeVisitor(node.trueType, visitor, ts.isTypeNode), nodeVisitor(node.falseType, visitor, ts.isTypeNode));
-            case 190 /* InferType */:
-                ts.Debug.type(node);
-                return factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
-            case 200 /* ImportType */:
-                ts.Debug.type(node);
-                return factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isNode), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
-            case 295 /* ImportTypeAssertionContainer */:
-                ts.Debug.type(node);
-                return factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isNode), node.multiLine);
-            case 197 /* NamedTupleMember */:
-                ts.Debug.type(node);
-                return factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 191 /* ParenthesizedType */:
-                ts.Debug.type(node);
-                return factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 193 /* TypeOperator */:
-                ts.Debug.type(node);
-                return factory.updateTypeOperatorNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 194 /* IndexedAccessType */:
-                ts.Debug.type(node);
-                return factory.updateIndexedAccessTypeNode(node, nodeVisitor(node.objectType, visitor, ts.isTypeNode), nodeVisitor(node.indexType, visitor, ts.isTypeNode));
-            case 195 /* MappedType */:
-                ts.Debug.type(node);
-                return factory.updateMappedTypeNode(node, nodeVisitor(node.readonlyToken, tokenVisitor, ts.isReadonlyKeywordOrPlusOrMinusToken), nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.nameType, visitor, ts.isTypeNode), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionOrPlusOrMinusToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodesVisitor(node.members, visitor, ts.isTypeElement));
-            case 196 /* LiteralType */:
-                ts.Debug.type(node);
-                return factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isExpression));
-            case 198 /* TemplateLiteralType */:
-                ts.Debug.type(node);
-                return factory.updateTemplateLiteralType(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateLiteralTypeSpan));
-            case 199 /* TemplateLiteralTypeSpan */:
-                ts.Debug.type(node);
-                return factory.updateTemplateLiteralTypeSpan(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
-            // Binding patterns
-            case 201 /* ObjectBindingPattern */:
-                ts.Debug.type(node);
-                return factory.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement));
-            case 202 /* ArrayBindingPattern */:
-                ts.Debug.type(node);
-                return factory.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement));
-            case 203 /* BindingElement */:
-                ts.Debug.type(node);
-                return factory.updateBindingElement(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.propertyName, visitor, ts.isPropertyName), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            // Expression
-            case 204 /* ArrayLiteralExpression */:
-                ts.Debug.type(node);
-                return factory.updateArrayLiteralExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
-            case 205 /* ObjectLiteralExpression */:
-                ts.Debug.type(node);
-                return factory.updateObjectLiteralExpression(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike));
-            case 206 /* PropertyAccessExpression */:
-                if (node.flags & 32 /* OptionalChain */) {
-                    ts.Debug.type(node);
-                    return factory.updatePropertyAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.name, visitor, ts.isMemberName));
-                }
-                ts.Debug.type(node);
-                return factory.updatePropertyAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.name, visitor, ts.isMemberName));
-            case 207 /* ElementAccessExpression */:
-                if (node.flags & 32 /* OptionalChain */) {
-                    ts.Debug.type(node);
-                    return factory.updateElementAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.argumentExpression, visitor, ts.isExpression));
-                }
-                ts.Debug.type(node);
-                return factory.updateElementAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.argumentExpression, visitor, ts.isExpression));
-            case 208 /* CallExpression */:
-                if (node.flags & 32 /* OptionalChain */) {
-                    ts.Debug.type(node);
-                    return factory.updateCallChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
-                }
-                ts.Debug.type(node);
-                return factory.updateCallExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
-            case 209 /* NewExpression */:
-                ts.Debug.type(node);
-                return factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
-            case 210 /* TaggedTemplateExpression */:
-                ts.Debug.type(node);
-                return factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
-            case 211 /* TypeAssertionExpression */:
-                ts.Debug.type(node);
-                return factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 212 /* ParenthesizedExpression */:
-                ts.Debug.type(node);
-                return factory.updateParenthesizedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 213 /* FunctionExpression */:
-                ts.Debug.type(node);
-                return factory.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 214 /* ArrowFunction */:
-                ts.Debug.type(node);
-                return factory.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, ts.isEqualsGreaterThanToken), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 215 /* DeleteExpression */:
-                ts.Debug.type(node);
-                return factory.updateDeleteExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 216 /* TypeOfExpression */:
-                ts.Debug.type(node);
-                return factory.updateTypeOfExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 217 /* VoidExpression */:
-                ts.Debug.type(node);
-                return factory.updateVoidExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 218 /* AwaitExpression */:
-                ts.Debug.type(node);
-                return factory.updateAwaitExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 219 /* PrefixUnaryExpression */:
-                ts.Debug.type(node);
-                return factory.updatePrefixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
-            case 220 /* PostfixUnaryExpression */:
-                ts.Debug.type(node);
-                return factory.updatePostfixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
-            case 221 /* BinaryExpression */:
-                ts.Debug.type(node);
-                return factory.updateBinaryExpression(node, nodeVisitor(node.left, visitor, ts.isExpression), nodeVisitor(node.operatorToken, tokenVisitor, ts.isBinaryOperatorToken), nodeVisitor(node.right, visitor, ts.isExpression));
-            case 222 /* ConditionalExpression */:
-                ts.Debug.type(node);
-                return factory.updateConditionalExpression(node, nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.whenTrue, visitor, ts.isExpression), nodeVisitor(node.colonToken, tokenVisitor, ts.isColonToken), nodeVisitor(node.whenFalse, visitor, ts.isExpression));
-            case 223 /* TemplateExpression */:
-                ts.Debug.type(node);
-                return factory.updateTemplateExpression(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan));
-            case 224 /* YieldExpression */:
-                ts.Debug.type(node);
-                return factory.updateYieldExpression(node, nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 225 /* SpreadElement */:
-                ts.Debug.type(node);
-                return factory.updateSpreadElement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 226 /* ClassExpression */:
-                ts.Debug.type(node);
-                return factory.updateClassExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
-            case 228 /* ExpressionWithTypeArguments */:
-                ts.Debug.type(node);
-                return factory.updateExpressionWithTypeArguments(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
-            case 229 /* AsExpression */:
-                ts.Debug.type(node);
-                return factory.updateAsExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 230 /* NonNullExpression */:
-                if (node.flags & 32 /* OptionalChain */) {
-                    ts.Debug.type(node);
-                    return factory.updateNonNullChain(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-                }
-                ts.Debug.type(node);
-                return factory.updateNonNullExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 231 /* MetaProperty */:
-                ts.Debug.type(node);
-                return factory.updateMetaProperty(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
-            // Misc
-            case 233 /* TemplateSpan */:
-                ts.Debug.type(node);
-                return factory.updateTemplateSpan(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
-            // Element
-            case 235 /* Block */:
-                ts.Debug.type(node);
-                return factory.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
-            case 237 /* VariableStatement */:
-                ts.Debug.type(node);
-                return factory.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.declarationList, visitor, ts.isVariableDeclarationList));
-            case 238 /* ExpressionStatement */:
-                ts.Debug.type(node);
-                return factory.updateExpressionStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 239 /* IfStatement */:
-                ts.Debug.type(node);
-                return factory.updateIfStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.thenStatement, visitor, ts.isStatement, factory.liftToBlock), nodeVisitor(node.elseStatement, visitor, ts.isStatement, factory.liftToBlock));
-            case 240 /* DoStatement */:
-                ts.Debug.type(node);
-                return factory.updateDoStatement(node, visitIterationBody(node.statement, visitor, context), nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 241 /* WhileStatement */:
-                ts.Debug.type(node);
-                return factory.updateWhileStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context));
-            case 242 /* ForStatement */:
-                ts.Debug.type(node);
-                return factory.updateForStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.incrementor, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context));
-            case 243 /* ForInStatement */:
-                ts.Debug.type(node);
-                return factory.updateForInStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context));
-            case 244 /* ForOfStatement */:
-                ts.Debug.type(node);
-                return factory.updateForOfStatement(node, nodeVisitor(node.awaitModifier, tokenVisitor, ts.isAwaitKeyword), nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context));
-            case 245 /* ContinueStatement */:
-                ts.Debug.type(node);
-                return factory.updateContinueStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
-            case 246 /* BreakStatement */:
-                ts.Debug.type(node);
-                return factory.updateBreakStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
-            case 247 /* ReturnStatement */:
-                ts.Debug.type(node);
-                return factory.updateReturnStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 248 /* WithStatement */:
-                ts.Debug.type(node);
-                return factory.updateWithStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
-            case 249 /* SwitchStatement */:
-                ts.Debug.type(node);
-                return factory.updateSwitchStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.caseBlock, visitor, ts.isCaseBlock));
-            case 250 /* LabeledStatement */:
-                ts.Debug.type(node);
-                return factory.updateLabeledStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier), nodeVisitor(node.statement, visitor, ts.isStatement, factory.liftToBlock));
-            case 251 /* ThrowStatement */:
-                ts.Debug.type(node);
-                return factory.updateThrowStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 252 /* TryStatement */:
-                ts.Debug.type(node);
-                return factory.updateTryStatement(node, nodeVisitor(node.tryBlock, visitor, ts.isBlock), nodeVisitor(node.catchClause, visitor, ts.isCatchClause), nodeVisitor(node.finallyBlock, visitor, ts.isBlock));
-            case 254 /* VariableDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateVariableDeclaration(node, nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.exclamationToken, tokenVisitor, ts.isExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            case 255 /* VariableDeclarationList */:
-                ts.Debug.type(node);
-                return factory.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration));
-            case 256 /* FunctionDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateFunctionDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
-            case 257 /* ClassDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateClassDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
-            case 258 /* InterfaceDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateInterfaceDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement));
-            case 259 /* TypeAliasDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateTypeAliasDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
-            case 260 /* EnumDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateEnumDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember));
-            case 261 /* ModuleDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateModuleDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isModuleName), nodeVisitor(node.body, visitor, ts.isModuleBody));
-            case 262 /* ModuleBlock */:
-                ts.Debug.type(node);
-                return factory.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
-            case 263 /* CaseBlock */:
-                ts.Debug.type(node);
-                return factory.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause));
-            case 264 /* NamespaceExportDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateNamespaceExportDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
-            case 265 /* ImportEqualsDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateImportEqualsDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference));
-            case 266 /* ImportDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateImportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.importClause, visitor, ts.isImportClause), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause));
-            case 293 /* AssertClause */:
-                ts.Debug.type(node);
-                return factory.updateAssertClause(node, nodesVisitor(node.elements, visitor, ts.isAssertEntry), node.multiLine);
-            case 294 /* AssertEntry */:
-                ts.Debug.type(node);
-                return factory.updateAssertEntry(node, nodeVisitor(node.name, visitor, ts.isAssertionKey), nodeVisitor(node.value, visitor, ts.isExpressionNode));
-            case 267 /* ImportClause */:
-                ts.Debug.type(node);
-                return factory.updateImportClause(node, node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.namedBindings, visitor, ts.isNamedImportBindings));
-            case 268 /* NamespaceImport */:
-                ts.Debug.type(node);
-                return factory.updateNamespaceImport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
-            case 274 /* NamespaceExport */:
-                ts.Debug.type(node);
-                return factory.updateNamespaceExport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
-            case 269 /* NamedImports */:
-                ts.Debug.type(node);
-                return factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
-            case 270 /* ImportSpecifier */:
-                ts.Debug.type(node);
-                return factory.updateImportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
-            case 271 /* ExportAssignment */:
-                ts.Debug.type(node);
-                return factory.updateExportAssignment(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 272 /* ExportDeclaration */:
-                ts.Debug.type(node);
-                return factory.updateExportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.exportClause, visitor, ts.isNamedExportBindings), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause));
-            case 273 /* NamedExports */:
-                ts.Debug.type(node);
-                return factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
-            case 275 /* ExportSpecifier */:
-                ts.Debug.type(node);
-                return factory.updateExportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
-            // Module references
-            case 277 /* ExternalModuleReference */:
-                ts.Debug.type(node);
-                return factory.updateExternalModuleReference(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            // JSX
-            case 278 /* JsxElement */:
-                ts.Debug.type(node);
-                return factory.updateJsxElement(node, nodeVisitor(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingElement, visitor, ts.isJsxClosingElement));
-            case 279 /* JsxSelfClosingElement */:
-                ts.Debug.type(node);
-                return factory.updateJsxSelfClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
-            case 280 /* JsxOpeningElement */:
-                ts.Debug.type(node);
-                return factory.updateJsxOpeningElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
-            case 281 /* JsxClosingElement */:
-                ts.Debug.type(node);
-                return factory.updateJsxClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression));
-            case 282 /* JsxFragment */:
-                ts.Debug.type(node);
-                return factory.updateJsxFragment(node, nodeVisitor(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingFragment, visitor, ts.isJsxClosingFragment));
-            case 285 /* JsxAttribute */:
-                ts.Debug.type(node);
-                return factory.updateJsxAttribute(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.initializer, visitor, ts.isStringLiteralOrJsxExpression));
-            case 286 /* JsxAttributes */:
-                ts.Debug.type(node);
-                return factory.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike));
-            case 287 /* JsxSpreadAttribute */:
-                ts.Debug.type(node);
-                return factory.updateJsxSpreadAttribute(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 288 /* JsxExpression */:
-                ts.Debug.type(node);
-                return factory.updateJsxExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            // Clauses
-            case 289 /* CaseClause */:
-                ts.Debug.type(node);
-                return factory.updateCaseClause(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement));
-            case 290 /* DefaultClause */:
-                ts.Debug.type(node);
-                return factory.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement));
-            case 291 /* HeritageClause */:
-                ts.Debug.type(node);
-                return factory.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments));
-            case 292 /* CatchClause */:
-                ts.Debug.type(node);
-                return factory.updateCatchClause(node, nodeVisitor(node.variableDeclaration, visitor, ts.isVariableDeclaration), nodeVisitor(node.block, visitor, ts.isBlock));
-            // Property assignments
-            case 296 /* PropertyAssignment */:
-                ts.Debug.type(node);
-                return factory.updatePropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            case 297 /* ShorthandPropertyAssignment */:
-                ts.Debug.type(node);
-                return factory.updateShorthandPropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.objectAssignmentInitializer, visitor, ts.isExpression));
-            case 298 /* SpreadAssignment */:
-                ts.Debug.type(node);
-                return factory.updateSpreadAssignment(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            // Enum
-            case 299 /* EnumMember */:
-                ts.Debug.type(node);
-                return factory.updateEnumMember(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
-            // Top-level nodes
-            case 305 /* SourceFile */:
-                ts.Debug.type(node);
-                return factory.updateSourceFile(node, visitLexicalEnvironment(node.statements, visitor, context));
-            // Transformation nodes
-            case 350 /* PartiallyEmittedExpression */:
-                ts.Debug.type(node);
-                return factory.updatePartiallyEmittedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
-            case 351 /* CommaListExpression */:
-                ts.Debug.type(node);
-                return factory.updateCommaListExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
-            default:
-                // No need to visit nodes with no children.
-                return node;
-        }
+        var fn = visitEachChildTable[node.kind];
+        return fn === undefined ? node : fn(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor);
     }
     ts.visitEachChild = visitEachChild;
+    // NOTE: Before you can add a new method to `visitEachChildTable`, you must first ensure the `Node` subtype you
+    //       wish to add is defined in the `HasChildren` union in types.ts.
+    var visitEachChildTable = (_a = {},
+        _a[79 /* Identifier */] = function visitEachChildOfIdentifier(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateIdentifier(node, nodesVisitor(node.typeArguments, visitor, ts.isTypeNodeOrTypeParameterDeclaration));
+        },
+        _a[161 /* QualifiedName */] = function visitEachChildOfQualifiedName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateQualifiedName(node, nodeVisitor(node.left, visitor, ts.isEntityName), nodeVisitor(node.right, visitor, ts.isIdentifier));
+        },
+        _a[162 /* ComputedPropertyName */] = function visitEachChildOfComputedPropertyName(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateComputedPropertyName(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        // Signature elements
+        _a[163 /* TypeParameter */] = function visitEachChildOfTypeParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.constraint, visitor, ts.isTypeNode), nodeVisitor(node.default, visitor, ts.isTypeNode));
+        },
+        _a[164 /* Parameter */] = function visitEachChildOfParameterDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateParameterDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        _a[165 /* Decorator */] = function visitEachChildOfDecorator(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateDecorator(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        // Type elements
+        _a[166 /* PropertySignature */] = function visitEachChildOfPropertySignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updatePropertySignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[167 /* PropertyDeclaration */] = function visitEachChildOfPropertyDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            var _a;
+            return context.factory.updatePropertyDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), 
+            // QuestionToken and ExclamationToken are mutually exclusive in PropertyDeclaration
+            nodeVisitor((_a = node.questionToken) !== null && _a !== void 0 ? _a : node.exclamationToken, tokenVisitor, ts.isQuestionOrExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        _a[168 /* MethodSignature */] = function visitEachChildOfMethodSignature(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateMethodSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[169 /* MethodDeclaration */] = function visitEachChildOfMethodDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateMethodDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[171 /* Constructor */] = function visitEachChildOfConstructorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateConstructorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[172 /* GetAccessor */] = function visitEachChildOfGetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateGetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[173 /* SetAccessor */] = function visitEachChildOfSetAccessorDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateSetAccessorDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isPropertyName), visitParameterList(node.parameters, visitor, context, nodesVisitor), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[170 /* ClassStaticBlockDeclaration */] = function visitEachChildOfClassStaticBlockDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            context.startLexicalEnvironment();
+            context.suspendLexicalEnvironment();
+            return context.factory.updateClassStaticBlockDeclaration(node, visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[174 /* CallSignature */] = function visitEachChildOfCallSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateCallSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[175 /* ConstructSignature */] = function visitEachChildOfConstructSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateConstructSignature(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[176 /* IndexSignature */] = function visitEachChildOfIndexSignatureDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateIndexSignature(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        // Types
+        _a[177 /* TypePredicate */] = function visitEachChildOfTypePredicateNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypePredicateNode(node, nodeVisitor(node.assertsModifier, visitor, ts.isAssertsKeyword), nodeVisitor(node.parameterName, visitor, ts.isIdentifierOrThisTypeNode), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[178 /* TypeReference */] = function visitEachChildOfTypeReferenceNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeReferenceNode(node, nodeVisitor(node.typeName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
+        },
+        _a[179 /* FunctionType */] = function visitEachChildOfFunctionTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateFunctionTypeNode(node, nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[180 /* ConstructorType */] = function visitEachChildOfConstructorTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateConstructorTypeNode(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.parameters, visitor, ts.isParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[181 /* TypeQuery */] = function visitEachChildOfTypeQueryNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeQueryNode(node, nodeVisitor(node.exprName, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
+        },
+        _a[182 /* TypeLiteral */] = function visitEachChildOfTypeLiteralNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeLiteralNode(node, nodesVisitor(node.members, visitor, ts.isTypeElement));
+        },
+        _a[183 /* ArrayType */] = function visitEachChildOfArrayTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateArrayTypeNode(node, nodeVisitor(node.elementType, visitor, ts.isTypeNode));
+        },
+        _a[184 /* TupleType */] = function visitEachChildOfTupleTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTupleTypeNode(node, nodesVisitor(node.elements, visitor, ts.isTypeNode));
+        },
+        _a[185 /* OptionalType */] = function visitEachChildOfOptionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateOptionalTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[186 /* RestType */] = function visitEachChildOfRestTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateRestTypeNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[187 /* UnionType */] = function visitEachChildOfUnionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateUnionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
+        },
+        _a[188 /* IntersectionType */] = function visitEachChildOfIntersectionTypeNode(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateIntersectionTypeNode(node, nodesVisitor(node.types, visitor, ts.isTypeNode));
+        },
+        _a[189 /* ConditionalType */] = function visitEachChildOfConditionalTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateConditionalTypeNode(node, nodeVisitor(node.checkType, visitor, ts.isTypeNode), nodeVisitor(node.extendsType, visitor, ts.isTypeNode), nodeVisitor(node.trueType, visitor, ts.isTypeNode), nodeVisitor(node.falseType, visitor, ts.isTypeNode));
+        },
+        _a[190 /* InferType */] = function visitEachChildOfInferTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateInferTypeNode(node, nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration));
+        },
+        _a[200 /* ImportType */] = function visitEachChildOfImportTypeNode(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportTypeNode(node, nodeVisitor(node.argument, visitor, ts.isTypeNode), nodeVisitor(node.assertions, visitor, ts.isImportTypeAssertionContainer), nodeVisitor(node.qualifier, visitor, ts.isEntityName), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), node.isTypeOf);
+        },
+        _a[295 /* ImportTypeAssertionContainer */] = function visitEachChildOfImportTypeAssertionContainer(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportTypeAssertionContainer(node, nodeVisitor(node.assertClause, visitor, ts.isAssertClause), node.multiLine);
+        },
+        _a[197 /* NamedTupleMember */] = function visitEachChildOfNamedTupleMember(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateNamedTupleMember(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[191 /* ParenthesizedType */] = function visitEachChildOfParenthesizedType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateParenthesizedType(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[193 /* TypeOperator */] = function visitEachChildOfTypeOperatorNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeOperatorNode(node, nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[194 /* IndexedAccessType */] = function visitEachChildOfIndexedAccessType(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateIndexedAccessTypeNode(node, nodeVisitor(node.objectType, visitor, ts.isTypeNode), nodeVisitor(node.indexType, visitor, ts.isTypeNode));
+        },
+        _a[195 /* MappedType */] = function visitEachChildOfMappedType(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateMappedTypeNode(node, nodeVisitor(node.readonlyToken, tokenVisitor, ts.isReadonlyKeywordOrPlusOrMinusToken), nodeVisitor(node.typeParameter, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.nameType, visitor, ts.isTypeNode), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionOrPlusOrMinusToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodesVisitor(node.members, visitor, ts.isTypeElement));
+        },
+        _a[196 /* LiteralType */] = function visitEachChildOfLiteralTypeNode(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateLiteralTypeNode(node, nodeVisitor(node.literal, visitor, ts.isExpression));
+        },
+        _a[198 /* TemplateLiteralType */] = function visitEachChildOfTemplateLiteralType(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTemplateLiteralType(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateLiteralTypeSpan));
+        },
+        _a[199 /* TemplateLiteralTypeSpan */] = function visitEachChildOfTemplateLiteralTypeSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTemplateLiteralTypeSpan(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
+        },
+        // Binding patterns
+        _a[201 /* ObjectBindingPattern */] = function visitEachChildOfObjectBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateObjectBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isBindingElement));
+        },
+        _a[202 /* ArrayBindingPattern */] = function visitEachChildOfArrayBindingPattern(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateArrayBindingPattern(node, nodesVisitor(node.elements, visitor, ts.isArrayBindingElement));
+        },
+        _a[203 /* BindingElement */] = function visitEachChildOfBindingElement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateBindingElement(node, nodeVisitor(node.dotDotDotToken, tokenVisitor, ts.isDotDotDotToken), nodeVisitor(node.propertyName, visitor, ts.isPropertyName), nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        // Expression
+        _a[204 /* ArrayLiteralExpression */] = function visitEachChildOfArrayLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateArrayLiteralExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
+        },
+        _a[205 /* ObjectLiteralExpression */] = function visitEachChildOfObjectLiteralExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateObjectLiteralExpression(node, nodesVisitor(node.properties, visitor, ts.isObjectLiteralElementLike));
+        },
+        _a[206 /* PropertyAccessExpression */] = function visitEachChildOfPropertyAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return ts.isPropertyAccessChain(node) ?
+                context.factory.updatePropertyAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.name, visitor, ts.isMemberName)) :
+                context.factory.updatePropertyAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.name, visitor, ts.isMemberName));
+        },
+        _a[207 /* ElementAccessExpression */] = function visitEachChildOfElementAccessExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return ts.isElementAccessChain(node) ?
+                context.factory.updateElementAccessChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodeVisitor(node.argumentExpression, visitor, ts.isExpression)) :
+                context.factory.updateElementAccessExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.argumentExpression, visitor, ts.isExpression));
+        },
+        _a[208 /* CallExpression */] = function visitEachChildOfCallExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return ts.isCallChain(node) ?
+                context.factory.updateCallChain(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.questionDotToken, tokenVisitor, ts.isQuestionDotToken), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression)) :
+                context.factory.updateCallExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
+        },
+        _a[209 /* NewExpression */] = function visitEachChildOfNewExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNewExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodesVisitor(node.arguments, visitor, ts.isExpression));
+        },
+        _a[210 /* TaggedTemplateExpression */] = function visitEachChildOfTaggedTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTaggedTemplateExpression(node, nodeVisitor(node.tag, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.template, visitor, ts.isTemplateLiteral));
+        },
+        _a[211 /* TypeAssertionExpression */] = function visitEachChildOfTypeAssertionExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeAssertion(node, nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[212 /* ParenthesizedExpression */] = function visitEachChildOfParenthesizedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateParenthesizedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[213 /* FunctionExpression */] = function visitEachChildOfFunctionExpression(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateFunctionExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[214 /* ArrowFunction */] = function visitEachChildOfArrowFunction(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateArrowFunction(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.equalsGreaterThanToken, tokenVisitor, ts.isEqualsGreaterThanToken), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[215 /* DeleteExpression */] = function visitEachChildOfDeleteExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateDeleteExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[216 /* TypeOfExpression */] = function visitEachChildOfTypeOfExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeOfExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[217 /* VoidExpression */] = function visitEachChildOfVoidExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateVoidExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[218 /* AwaitExpression */] = function visitEachChildOfAwaitExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateAwaitExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[219 /* PrefixUnaryExpression */] = function visitEachChildOfPrefixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updatePrefixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
+        },
+        _a[220 /* PostfixUnaryExpression */] = function visitEachChildOfPostfixUnaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updatePostfixUnaryExpression(node, nodeVisitor(node.operand, visitor, ts.isExpression));
+        },
+        _a[221 /* BinaryExpression */] = function visitEachChildOfBinaryExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateBinaryExpression(node, nodeVisitor(node.left, visitor, ts.isExpression), nodeVisitor(node.operatorToken, tokenVisitor, ts.isBinaryOperatorToken), nodeVisitor(node.right, visitor, ts.isExpression));
+        },
+        _a[222 /* ConditionalExpression */] = function visitEachChildOfConditionalExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateConditionalExpression(node, nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.questionToken, tokenVisitor, ts.isQuestionToken), nodeVisitor(node.whenTrue, visitor, ts.isExpression), nodeVisitor(node.colonToken, tokenVisitor, ts.isColonToken), nodeVisitor(node.whenFalse, visitor, ts.isExpression));
+        },
+        _a[223 /* TemplateExpression */] = function visitEachChildOfTemplateExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTemplateExpression(node, nodeVisitor(node.head, visitor, ts.isTemplateHead), nodesVisitor(node.templateSpans, visitor, ts.isTemplateSpan));
+        },
+        _a[224 /* YieldExpression */] = function visitEachChildOfYieldExpression(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateYieldExpression(node, nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[225 /* SpreadElement */] = function visitEachChildOfSpreadElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateSpreadElement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[226 /* ClassExpression */] = function visitEachChildOfClassExpression(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateClassExpression(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
+        },
+        _a[228 /* ExpressionWithTypeArguments */] = function visitEachChildOfExpressionWithTypeArguments(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExpressionWithTypeArguments(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode));
+        },
+        _a[229 /* AsExpression */] = function visitEachChildOfAsExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateAsExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[230 /* NonNullExpression */] = function visitEachChildOfNonNullExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return ts.isOptionalChain(node) ?
+                context.factory.updateNonNullChain(node, nodeVisitor(node.expression, visitor, ts.isExpression)) :
+                context.factory.updateNonNullExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[231 /* MetaProperty */] = function visitEachChildOfMetaProperty(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateMetaProperty(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        // Misc
+        _a[233 /* TemplateSpan */] = function visitEachChildOfTemplateSpan(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTemplateSpan(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.literal, visitor, ts.isTemplateMiddleOrTemplateTail));
+        },
+        // Element
+        _a[235 /* Block */] = function visitEachChildOfBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+        },
+        _a[237 /* VariableStatement */] = function visitEachChildOfVariableStatement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateVariableStatement(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.declarationList, visitor, ts.isVariableDeclarationList));
+        },
+        _a[238 /* ExpressionStatement */] = function visitEachChildOfExpressionStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExpressionStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[239 /* IfStatement */] = function visitEachChildOfIfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateIfStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.thenStatement, visitor, ts.isStatement, context.factory.liftToBlock), nodeVisitor(node.elseStatement, visitor, ts.isStatement, context.factory.liftToBlock));
+        },
+        _a[240 /* DoStatement */] = function visitEachChildOfDoStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateDoStatement(node, visitIterationBody(node.statement, visitor, context, nodeVisitor), nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[241 /* WhileStatement */] = function visitEachChildOfWhileStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateWhileStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor));
+        },
+        _a[242 /* ForStatement */] = function visitEachChildOfForStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateForStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.condition, visitor, ts.isExpression), nodeVisitor(node.incrementor, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor));
+        },
+        _a[243 /* ForInStatement */] = function visitEachChildOfForInStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateForInStatement(node, nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor));
+        },
+        _a[244 /* ForOfStatement */] = function visitEachChildOfForOfStatement(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateForOfStatement(node, nodeVisitor(node.awaitModifier, tokenVisitor, ts.isAwaitKeyword), nodeVisitor(node.initializer, visitor, ts.isForInitializer), nodeVisitor(node.expression, visitor, ts.isExpression), visitIterationBody(node.statement, visitor, context, nodeVisitor));
+        },
+        _a[245 /* ContinueStatement */] = function visitEachChildOfContinueStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateContinueStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
+        },
+        _a[246 /* BreakStatement */] = function visitEachChildOfBreakStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateBreakStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier));
+        },
+        _a[247 /* ReturnStatement */] = function visitEachChildOfReturnStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateReturnStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[248 /* WithStatement */] = function visitEachChildOfWithStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateWithStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.statement, visitor, ts.isStatement, context.factory.liftToBlock));
+        },
+        _a[249 /* SwitchStatement */] = function visitEachChildOfSwitchStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateSwitchStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodeVisitor(node.caseBlock, visitor, ts.isCaseBlock));
+        },
+        _a[250 /* LabeledStatement */] = function visitEachChildOfLabeledStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateLabeledStatement(node, nodeVisitor(node.label, visitor, ts.isIdentifier), nodeVisitor(node.statement, visitor, ts.isStatement, context.factory.liftToBlock));
+        },
+        _a[251 /* ThrowStatement */] = function visitEachChildOfThrowStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateThrowStatement(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[252 /* TryStatement */] = function visitEachChildOfTryStatement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTryStatement(node, nodeVisitor(node.tryBlock, visitor, ts.isBlock), nodeVisitor(node.catchClause, visitor, ts.isCatchClause), nodeVisitor(node.finallyBlock, visitor, ts.isBlock));
+        },
+        _a[254 /* VariableDeclaration */] = function visitEachChildOfVariableDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateVariableDeclaration(node, nodeVisitor(node.name, visitor, ts.isBindingName), nodeVisitor(node.exclamationToken, tokenVisitor, ts.isExclamationToken), nodeVisitor(node.type, visitor, ts.isTypeNode), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        _a[255 /* VariableDeclarationList */] = function visitEachChildOfVariableDeclarationList(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateVariableDeclarationList(node, nodesVisitor(node.declarations, visitor, ts.isVariableDeclaration));
+        },
+        _a[256 /* FunctionDeclaration */] = function visitEachChildOfFunctionDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, tokenVisitor) {
+            return context.factory.updateFunctionDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.asteriskToken, tokenVisitor, ts.isAsteriskToken), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), visitParameterList(node.parameters, visitor, context, nodesVisitor), nodeVisitor(node.type, visitor, ts.isTypeNode), visitFunctionBody(node.body, visitor, context, nodeVisitor));
+        },
+        _a[257 /* ClassDeclaration */] = function visitEachChildOfClassDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateClassDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifierLike), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isClassElement));
+        },
+        _a[258 /* InterfaceDeclaration */] = function visitEachChildOfInterfaceDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateInterfaceDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodesVisitor(node.heritageClauses, visitor, ts.isHeritageClause), nodesVisitor(node.members, visitor, ts.isTypeElement));
+        },
+        _a[259 /* TypeAliasDeclaration */] = function visitEachChildOfTypeAliasDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateTypeAliasDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.typeParameters, visitor, ts.isTypeParameterDeclaration), nodeVisitor(node.type, visitor, ts.isTypeNode));
+        },
+        _a[260 /* EnumDeclaration */] = function visitEachChildOfEnumDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateEnumDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isIdentifier), nodesVisitor(node.members, visitor, ts.isEnumMember));
+        },
+        _a[261 /* ModuleDeclaration */] = function visitEachChildOfModuleDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateModuleDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.name, visitor, ts.isModuleName), nodeVisitor(node.body, visitor, ts.isModuleBody));
+        },
+        _a[262 /* ModuleBlock */] = function visitEachChildOfModuleBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateModuleBlock(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+        },
+        _a[263 /* CaseBlock */] = function visitEachChildOfCaseBlock(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateCaseBlock(node, nodesVisitor(node.clauses, visitor, ts.isCaseOrDefaultClause));
+        },
+        _a[264 /* NamespaceExportDeclaration */] = function visitEachChildOfNamespaceExportDeclaration(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNamespaceExportDeclaration(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        _a[265 /* ImportEqualsDeclaration */] = function visitEachChildOfImportEqualsDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportEqualsDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.moduleReference, visitor, ts.isModuleReference));
+        },
+        _a[266 /* ImportDeclaration */] = function visitEachChildOfImportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.importClause, visitor, ts.isImportClause), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause));
+        },
+        _a[293 /* AssertClause */] = function visitEachChildOfAssertClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateAssertClause(node, nodesVisitor(node.elements, visitor, ts.isAssertEntry), node.multiLine);
+        },
+        _a[294 /* AssertEntry */] = function visitEachChildOfAssertEntry(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateAssertEntry(node, nodeVisitor(node.name, visitor, ts.isAssertionKey), nodeVisitor(node.value, visitor, ts.isExpression));
+        },
+        _a[267 /* ImportClause */] = function visitEachChildOfImportClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportClause(node, node.isTypeOnly, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.namedBindings, visitor, ts.isNamedImportBindings));
+        },
+        _a[268 /* NamespaceImport */] = function visitEachChildOfNamespaceImport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNamespaceImport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        _a[274 /* NamespaceExport */] = function visitEachChildOfNamespaceExport(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNamespaceExport(node, nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        _a[269 /* NamedImports */] = function visitEachChildOfNamedImports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNamedImports(node, nodesVisitor(node.elements, visitor, ts.isImportSpecifier));
+        },
+        _a[270 /* ImportSpecifier */] = function visitEachChildOfImportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateImportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        _a[271 /* ExportAssignment */] = function visitEachChildOfExportAssignment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExportAssignment(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[272 /* ExportDeclaration */] = function visitEachChildOfExportDeclaration(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExportDeclaration(node, nodesVisitor(node.modifiers, visitor, ts.isModifier), node.isTypeOnly, nodeVisitor(node.exportClause, visitor, ts.isNamedExportBindings), nodeVisitor(node.moduleSpecifier, visitor, ts.isExpression), nodeVisitor(node.assertClause, visitor, ts.isAssertClause));
+        },
+        _a[273 /* NamedExports */] = function visitEachChildOfNamedExports(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateNamedExports(node, nodesVisitor(node.elements, visitor, ts.isExportSpecifier));
+        },
+        _a[275 /* ExportSpecifier */] = function visitEachChildOfExportSpecifier(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExportSpecifier(node, node.isTypeOnly, nodeVisitor(node.propertyName, visitor, ts.isIdentifier), nodeVisitor(node.name, visitor, ts.isIdentifier));
+        },
+        // Module references
+        _a[277 /* ExternalModuleReference */] = function visitEachChildOfExternalModuleReference(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateExternalModuleReference(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        // JSX
+        _a[278 /* JsxElement */] = function visitEachChildOfJsxElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxElement(node, nodeVisitor(node.openingElement, visitor, ts.isJsxOpeningElement), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingElement, visitor, ts.isJsxClosingElement));
+        },
+        _a[279 /* JsxSelfClosingElement */] = function visitEachChildOfJsxSelfClosingElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxSelfClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
+        },
+        _a[280 /* JsxOpeningElement */] = function visitEachChildOfJsxOpeningElement(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxOpeningElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression), nodesVisitor(node.typeArguments, visitor, ts.isTypeNode), nodeVisitor(node.attributes, visitor, ts.isJsxAttributes));
+        },
+        _a[281 /* JsxClosingElement */] = function visitEachChildOfJsxClosingElement(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxClosingElement(node, nodeVisitor(node.tagName, visitor, ts.isJsxTagNameExpression));
+        },
+        _a[282 /* JsxFragment */] = function visitEachChildOfJsxFragment(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxFragment(node, nodeVisitor(node.openingFragment, visitor, ts.isJsxOpeningFragment), nodesVisitor(node.children, visitor, ts.isJsxChild), nodeVisitor(node.closingFragment, visitor, ts.isJsxClosingFragment));
+        },
+        _a[285 /* JsxAttribute */] = function visitEachChildOfJsxAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxAttribute(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.initializer, visitor, ts.isStringLiteralOrJsxExpression));
+        },
+        _a[286 /* JsxAttributes */] = function visitEachChildOfJsxAttributes(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxAttributes(node, nodesVisitor(node.properties, visitor, ts.isJsxAttributeLike));
+        },
+        _a[287 /* JsxSpreadAttribute */] = function visitEachChildOfJsxSpreadAttribute(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxSpreadAttribute(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[288 /* JsxExpression */] = function visitEachChildOfJsxExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateJsxExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        // Clauses
+        _a[289 /* CaseClause */] = function visitEachChildOfCaseClause(node, visitor, context, nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateCaseClause(node, nodeVisitor(node.expression, visitor, ts.isExpression), nodesVisitor(node.statements, visitor, ts.isStatement));
+        },
+        _a[290 /* DefaultClause */] = function visitEachChildOfDefaultClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateDefaultClause(node, nodesVisitor(node.statements, visitor, ts.isStatement));
+        },
+        _a[291 /* HeritageClause */] = function visitEachChildOfHeritageClause(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateHeritageClause(node, nodesVisitor(node.types, visitor, ts.isExpressionWithTypeArguments));
+        },
+        _a[292 /* CatchClause */] = function visitEachChildOfCatchClause(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateCatchClause(node, nodeVisitor(node.variableDeclaration, visitor, ts.isVariableDeclaration), nodeVisitor(node.block, visitor, ts.isBlock));
+        },
+        // Property assignments
+        _a[296 /* PropertyAssignment */] = function visitEachChildOfPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updatePropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        _a[297 /* ShorthandPropertyAssignment */] = function visitEachChildOfShorthandPropertyAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateShorthandPropertyAssignment(node, nodeVisitor(node.name, visitor, ts.isIdentifier), nodeVisitor(node.objectAssignmentInitializer, visitor, ts.isExpression));
+        },
+        _a[298 /* SpreadAssignment */] = function visitEachChildOfSpreadAssignment(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateSpreadAssignment(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        // Enum
+        _a[299 /* EnumMember */] = function visitEachChildOfEnumMember(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updateEnumMember(node, nodeVisitor(node.name, visitor, ts.isPropertyName), nodeVisitor(node.initializer, visitor, ts.isExpression));
+        },
+        // Top-level nodes
+        _a[305 /* SourceFile */] = function visitEachChildOfSourceFile(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateSourceFile(node, visitLexicalEnvironment(node.statements, visitor, context, /*start*/ undefined, /*ensureUseStrict*/ undefined, nodesVisitor));
+        },
+        // Transformation nodes
+        _a[350 /* PartiallyEmittedExpression */] = function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+            return context.factory.updatePartiallyEmittedExpression(node, nodeVisitor(node.expression, visitor, ts.isExpression));
+        },
+        _a[351 /* CommaListExpression */] = function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+            return context.factory.updateCommaListExpression(node, nodesVisitor(node.elements, visitor, ts.isExpression));
+        },
+        _a);
     /**
      * Extracts the single node from a NodeArray.
      *
@@ -138495,6 +138487,8 @@ var ts;
                 // Similarly, skip past the symbol for 'export ='
                 if (importedSymbol.escapedName === "export=") {
                     importedSymbol = getExportEqualsLocalSymbol(importedSymbol, checker);
+                    if (importedSymbol === undefined)
+                        return undefined;
                 }
                 // If the import has a different name than the export, do not continue searching.
                 // If `importedName` is undefined, do continue searching as the export is anonymous.
@@ -138516,19 +138510,19 @@ var ts;
         FindAllReferences.getImportOrExportSymbol = getImportOrExportSymbol;
         function getExportEqualsLocalSymbol(importedSymbol, checker) {
             if (importedSymbol.flags & 2097152 /* Alias */) {
-                return ts.Debug.checkDefined(checker.getImmediateAliasedSymbol(importedSymbol));
+                return checker.getImmediateAliasedSymbol(importedSymbol);
             }
             var decl = ts.Debug.checkDefined(importedSymbol.valueDeclaration);
             if (ts.isExportAssignment(decl)) { // `export = class {}`
-                return ts.Debug.checkDefined(decl.expression.symbol);
+                return decl.expression.symbol;
             }
             else if (ts.isBinaryExpression(decl)) { // `module.exports = class {}`
-                return ts.Debug.checkDefined(decl.right.symbol);
+                return decl.right.symbol;
             }
             else if (ts.isSourceFile(decl)) { // json module
-                return ts.Debug.checkDefined(decl.symbol);
+                return decl.symbol;
             }
-            return ts.Debug.fail();
+            return undefined;
         }
         // If a reference is a class expression, the exported node would be its parent.
         // If a reference is a variable declaration, the exported node would be the variable statement.
@@ -154805,13 +154799,15 @@ var ts;
             errorCodes: errorCodes,
             getCodeActions: function (context) {
                 var errorCode = context.errorCode, preferences = context.preferences, sourceFile = context.sourceFile, span = context.span, program = context.program;
-                var info = getFixesInfo(context, errorCode, span.start, /*useAutoImportProvider*/ true);
+                var info = getFixInfos(context, errorCode, span.start, /*useAutoImportProvider*/ true);
                 if (!info)
                     return undefined;
-                var fixes = info.fixes, symbolName = info.symbolName, errorIdentifierText = info.errorIdentifierText;
                 var quotePreference = ts.getQuotePreference(sourceFile, preferences);
-                return fixes.map(function (fix) { return codeActionForFix(context, sourceFile, symbolName, fix, 
-                /*includeSymbolNameInDescription*/ symbolName !== errorIdentifierText, quotePreference, program.getCompilerOptions()); });
+                return info.map(function (_a) {
+                    var fix = _a.fix, symbolName = _a.symbolName, errorIdentifierText = _a.errorIdentifierText;
+                    return codeActionForFix(context, sourceFile, symbolName, fix, 
+                    /*includeSymbolNameInDescription*/ symbolName !== errorIdentifierText, quotePreference, program.getCompilerOptions());
+                });
             },
             fixIds: [importFixId],
             getAllCodeActions: function (context) {
@@ -154836,10 +154832,10 @@ var ts;
             var newImports = new ts.Map();
             return { addImportFromDiagnostic: addImportFromDiagnostic, addImportFromExportedSymbol: addImportFromExportedSymbol, writeFixes: writeFixes, hasFixes: hasFixes };
             function addImportFromDiagnostic(diagnostic, context) {
-                var info = getFixesInfo(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
-                if (!info || !info.fixes.length)
+                var info = getFixInfos(context, diagnostic.code, diagnostic.start, useAutoImportProvider);
+                if (!info || !info.length)
                     return;
-                addImport(info);
+                addImport(ts.first(info));
             }
             function addImportFromExportedSymbol(exportedSymbol, isValidTypeOnlyUseSite) {
                 var moduleSymbol = ts.Debug.checkDefined(exportedSymbol.parent);
@@ -154850,13 +154846,12 @@ var ts;
                 var useRequire = shouldUseRequire(sourceFile, program);
                 var fix = getImportFixForSymbol(sourceFile, exportInfo, moduleSymbol, program, /*useNamespaceInfo*/ undefined, !!isValidTypeOnlyUseSite, useRequire, host, preferences);
                 if (fix) {
-                    addImport({ fixes: [fix], symbolName: symbolName, errorIdentifierText: undefined });
+                    addImport({ fix: fix, symbolName: symbolName, errorIdentifierText: undefined });
                 }
             }
             function addImport(info) {
                 var _a, _b;
-                var fixes = info.fixes, symbolName = info.symbolName;
-                var fix = ts.first(fixes);
+                var fix = info.fix, symbolName = info.symbolName;
                 switch (fix.kind) {
                     case 0 /* UseNamespace */:
                         addToNamespace.push(fix);
@@ -155040,7 +155035,7 @@ var ts;
         codefix.getImportCompletionAction = getImportCompletionAction;
         function getPromoteTypeOnlyCompletionAction(sourceFile, symbolToken, program, host, formatContext, preferences) {
             var compilerOptions = program.getCompilerOptions();
-            var symbolName = getSymbolName(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions);
+            var symbolName = ts.single(getSymbolNamesToImport(sourceFile, program.getTypeChecker(), symbolToken, compilerOptions));
             var fix = getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program);
             var includeSymbolNameInDescription = symbolName !== symbolToken.text;
             return fix && codeFixActionToCodeAction(codeActionForFix({ host: host, formatContext: formatContext, preferences: preferences }, sourceFile, symbolName, fix, includeSymbolNameInDescription, 1 /* Double */, compilerOptions));
@@ -155345,7 +155340,7 @@ var ts;
                 return { kind: 3 /* AddNew */, moduleSpecifier: moduleSpecifier, importKind: importKind, addAsTypeOnly: addAsTypeOnly, useRequire: useRequire };
             }
         }
-        function getFixesInfo(context, errorCode, pos, useAutoImportProvider) {
+        function getFixInfos(context, errorCode, pos, useAutoImportProvider) {
             var symbolToken = ts.getTokenAtPosition(context.sourceFile, pos);
             var info;
             if (errorCode === ts.Diagnostics._0_refers_to_a_UMD_global_but_the_current_file_is_a_module_Consider_adding_an_import_instead.code) {
@@ -155355,19 +155350,23 @@ var ts;
                 return undefined;
             }
             else if (errorCode === ts.Diagnostics._0_cannot_be_used_as_a_value_because_it_was_imported_using_import_type.code) {
-                var symbolName_1 = getSymbolName(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions());
+                var symbolName_1 = ts.single(getSymbolNamesToImport(context.sourceFile, context.program.getTypeChecker(), symbolToken, context.program.getCompilerOptions()));
                 var fix = getTypeOnlyPromotionFix(context.sourceFile, symbolToken, symbolName_1, context.program);
-                return fix && { fixes: [fix], symbolName: symbolName_1, errorIdentifierText: symbolToken.text };
+                return fix && [{ fix: fix, symbolName: symbolName_1, errorIdentifierText: symbolToken.text }];
             }
             else {
                 info = getFixesInfoForNonUMDImport(context, symbolToken, useAutoImportProvider);
             }
             var packageJsonImportFilter = ts.createPackageJsonImportFilter(context.sourceFile, context.preferences, context.host);
-            return info && __assign(__assign({}, info), { fixes: sortFixes(info.fixes, context.sourceFile, context.program, packageJsonImportFilter, context.host) });
+            return info && sortFixInfo(info, context.sourceFile, context.program, packageJsonImportFilter, context.host);
         }
-        function sortFixes(fixes, sourceFile, program, packageJsonImportFilter, host) {
+        function sortFixInfo(fixes, sourceFile, program, packageJsonImportFilter, host) {
             var _toPath = function (fileName) { return ts.toPath(fileName, host.getCurrentDirectory(), ts.hostGetCanonicalFileName(host)); };
-            return ts.sort(fixes, function (a, b) { return ts.compareValues(a.kind, b.kind) || compareModuleSpecifiers(a, b, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath); });
+            return ts.sort(fixes, function (a, b) {
+                return ts.compareBooleans(!!a.isJsxNamespaceFix, !!b.isJsxNamespaceFix) ||
+                    ts.compareValues(a.fix.kind, b.fix.kind) ||
+                    compareModuleSpecifiers(a.fix, b.fix, sourceFile, program, packageJsonImportFilter.allowsImportingSpecifier, _toPath);
+            });
         }
         function getBestFix(fixes, sourceFile, program, packageJsonImportFilter, host) {
             if (!ts.some(fixes))
@@ -155418,7 +155417,6 @@ var ts;
             return 0 /* EqualTo */;
         }
         function getFixesInfoForUMDImport(_a, token) {
-            var _b;
             var sourceFile = _a.sourceFile, program = _a.program, host = _a.host, preferences = _a.preferences;
             var checker = program.getTypeChecker();
             var umdSymbol = getUmdSymbol(token, checker);
@@ -155430,7 +155428,7 @@ var ts;
             var useRequire = shouldUseRequire(sourceFile, program);
             var position = ts.isIdentifier(token) ? token.getStart(sourceFile) : undefined;
             var fixes = getImportFixes(exportInfo, position ? { position: position, symbolName: symbolName } : undefined, /*isValidTypeOnlyUseSite*/ false, useRequire, program, sourceFile, host, preferences).fixes;
-            return { fixes: fixes, symbolName: symbolName, errorIdentifierText: (_b = ts.tryCast(token, ts.isIdentifier)) === null || _b === void 0 ? void 0 : _b.text };
+            return fixes.map(function (fix) { var _a; return ({ fix: fix, symbolName: symbolName, errorIdentifierText: (_a = ts.tryCast(token, ts.isIdentifier)) === null || _a === void 0 ? void 0 : _a.text }); });
         }
         function getUmdSymbol(token, checker) {
             // try the identifier to see if it is the umd symbol
@@ -155491,19 +155489,20 @@ var ts;
             var sourceFile = _a.sourceFile, program = _a.program, cancellationToken = _a.cancellationToken, host = _a.host, preferences = _a.preferences;
             var checker = program.getTypeChecker();
             var compilerOptions = program.getCompilerOptions();
-            var symbolName = getSymbolName(sourceFile, checker, symbolToken, compilerOptions);
-            // "default" is a keyword and not a legal identifier for the import, but appears as an identifier.
-            if (symbolName === "default" /* Default */) {
-                return undefined;
-            }
-            var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
-            var useRequire = shouldUseRequire(sourceFile, program);
-            var exportInfo = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
-            var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfo.entries(), function (_a) {
-                var _ = _a[0], exportInfos = _a[1];
-                return getImportFixes(exportInfos, { symbolName: symbolName, position: symbolToken.getStart(sourceFile) }, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes;
-            }));
-            return { fixes: fixes, symbolName: symbolName, errorIdentifierText: symbolToken.text };
+            return ts.flatMap(getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions), function (symbolName) {
+                // "default" is a keyword and not a legal identifier for the import, but appears as an identifier.
+                if (symbolName === "default" /* Default */) {
+                    return undefined;
+                }
+                var isValidTypeOnlyUseSite = ts.isValidTypeOnlyAliasUseSite(symbolToken);
+                var useRequire = shouldUseRequire(sourceFile, program);
+                var exportInfo = getExportInfos(symbolName, ts.isJSXTagName(symbolToken), ts.getMeaningFromLocation(symbolToken), cancellationToken, sourceFile, program, useAutoImportProvider, host, preferences);
+                var fixes = ts.arrayFrom(ts.flatMapIterator(exportInfo.entries(), function (_a) {
+                    var _ = _a[0], exportInfos = _a[1];
+                    return getImportFixes(exportInfos, { symbolName: symbolName, position: symbolToken.getStart(sourceFile) }, isValidTypeOnlyUseSite, useRequire, program, sourceFile, host, preferences).fixes;
+                }));
+                return fixes.map(function (fix) { return ({ fix: fix, symbolName: symbolName, errorIdentifierText: symbolToken.text, isJsxNamespaceFix: symbolName !== symbolToken.text }); });
+            });
         }
         function getTypeOnlyPromotionFix(sourceFile, symbolToken, symbolName, program) {
             var checker = program.getTypeChecker();
@@ -155515,15 +155514,16 @@ var ts;
                 return undefined;
             return { kind: 4 /* PromoteTypeOnly */, typeOnlyAliasDeclaration: typeOnlyAliasDeclaration };
         }
-        function getSymbolName(sourceFile, checker, symbolToken, compilerOptions) {
+        function getSymbolNamesToImport(sourceFile, checker, symbolToken, compilerOptions) {
             var parent = symbolToken.parent;
             if ((ts.isJsxOpeningLikeElement(parent) || ts.isJsxClosingElement(parent)) && parent.tagName === symbolToken && ts.jsxModeNeedsExplicitImport(compilerOptions.jsx)) {
                 var jsxNamespace = checker.getJsxNamespace(sourceFile);
                 if (needsJsxNamespaceFix(jsxNamespace, symbolToken, checker)) {
-                    return jsxNamespace;
+                    var needsComponentNameFix = !ts.isIntrinsicJsxName(symbolToken.text) && !checker.resolveName(symbolToken.text, symbolToken, 111551 /* Value */, /*excludeGlobals*/ false);
+                    return needsComponentNameFix ? [symbolToken.text, jsxNamespace] : [jsxNamespace];
                 }
             }
-            return symbolToken.text;
+            return [symbolToken.text];
         }
         function needsJsxNamespaceFix(jsxNamespace, symbolToken, checker) {
             if (ts.isIntrinsicJsxName(symbolToken.text))
@@ -159732,23 +159732,36 @@ var ts;
          * @param body If defined, this will be the body of the member node passed to `addClassElement`. Otherwise, the body will default to a stub.
          */
         function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, context, preferences, importAdder, addClassElement, body, preserveOptional, isAmbient) {
+            var _a;
             if (preserveOptional === void 0) { preserveOptional = 3 /* All */; }
             if (isAmbient === void 0) { isAmbient = false; }
             var declarations = symbol.getDeclarations();
-            if (!(declarations && declarations.length)) {
-                return undefined;
-            }
+            var declaration = declarations === null || declarations === void 0 ? void 0 : declarations[0];
             var checker = context.program.getTypeChecker();
             var scriptTarget = ts.getEmitScriptTarget(context.program.getCompilerOptions());
-            var declaration = declarations[0];
+            /**
+             * (#49811)
+             * Note that there are cases in which the symbol declaration is not present. For example, in the code below both
+             * `MappedIndirect.ax` and `MappedIndirect.ay` have no declaration node attached (due to their mapped-type
+             * parent):
+             *
+             * >>> ```ts
+             * >>> type Base = { ax: number; ay: string };
+             * >>> type BaseKeys = keyof Base;
+             * >>> type MappedIndirect = { [K in BaseKeys]: boolean };
+             * >>> ```
+             *
+             * In such cases, we assume the declaration to be a `PropertySignature`.
+             */
+            var kind = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.kind) !== null && _a !== void 0 ? _a : 166 /* PropertySignature */;
             var name = ts.getSynthesizedDeepClone(ts.getNameOfDeclaration(declaration), /*includeTrivia*/ false);
-            var visibilityModifier = createVisibilityModifier(ts.getEffectiveModifierFlags(declaration));
+            var visibilityModifier = createVisibilityModifier(declaration ? ts.getEffectiveModifierFlags(declaration) : 0 /* None */);
             var modifiers = visibilityModifier ? ts.factory.createNodeArray([visibilityModifier]) : undefined;
             var type = checker.getWidenedType(checker.getTypeOfSymbolAtLocation(symbol, enclosingDeclaration));
             var optional = !!(symbol.flags & 16777216 /* Optional */);
             var ambient = !!(enclosingDeclaration.flags & 16777216 /* Ambient */) || isAmbient;
             var quotePreference = ts.getQuotePreference(sourceFile, preferences);
-            switch (declaration.kind) {
+            switch (kind) {
                 case 166 /* PropertySignature */:
                 case 167 /* PropertyDeclaration */:
                     var flags = quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : undefined;
@@ -159760,11 +159773,12 @@ var ts;
                             importSymbols(importAdder, importableReference.symbols);
                         }
                     }
-                    addClassElement(ts.factory.createPropertyDeclaration(modifiers, name, optional && (preserveOptional & 2 /* Property */) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
+                    addClassElement(ts.factory.createPropertyDeclaration(modifiers, declaration ? name : symbol.getName(), optional && (preserveOptional & 2 /* Property */) ? ts.factory.createToken(57 /* QuestionToken */) : undefined, typeNode, 
                     /*initializer*/ undefined));
                     break;
                 case 172 /* GetAccessor */:
                 case 173 /* SetAccessor */: {
+                    ts.Debug.assertIsDefined(declarations);
                     var typeNode_1 = checker.typeToTypeNode(type, enclosingDeclaration, /*flags*/ undefined, getNoopSymbolTrackerWithResolver(context));
                     var allAccessors = ts.getAllAccessorDeclarations(declarations, declaration);
                     var orderedAccessors = allAccessors.secondAccessor
@@ -159800,6 +159814,7 @@ var ts;
                     // If there is more than one overload but no implementation signature
                     // (eg: an abstract method or interface declaration), there is a 1-1
                     // correspondence of declarations and signatures.
+                    ts.Debug.assertIsDefined(declarations);
                     var signatures = type.isUnion() ? ts.flatMap(type.types, function (t) { return t.getCallSignatures(); }) : type.getCallSignatures();
                     if (!ts.some(signatures)) {
                         break;
@@ -159810,8 +159825,8 @@ var ts;
                         outputMethod(quotePreference, signature, modifiers, name, ambient ? undefined : body || createStubbedMethodBody(quotePreference));
                         break;
                     }
-                    for (var _a = 0, signatures_1 = signatures; _a < signatures_1.length; _a++) {
-                        var signature = signatures_1[_a];
+                    for (var _b = 0, signatures_1 = signatures; _b < signatures_1.length; _b++) {
+                        var signature = signatures_1[_b];
                         // Ensure nodes are fresh so they can have different positions when going through formatting.
                         outputMethod(quotePreference, signature, ts.getSynthesizedDeepClones(modifiers, /*includeTrivia*/ false), ts.getSynthesizedDeepClone(name, /*includeTrivia*/ false));
                     }
@@ -184049,20 +184064,6 @@ var ts;
             }
             // Override sys.write because fs.writeSync is not reliable on Node 4
             sys.write = function (s) { return writeMessage(sys.bufferFrom(s, "utf8")); };
-            // REVIEW: for now this implementation uses polling.
-            // The advantage of polling is that it works reliably
-            // on all os and with network mounted files.
-            // For 90 referenced files, the average time to detect
-            // changes is 2*msInterval (by default 5 seconds).
-            // The overhead of this is .04 percent (1/2500) with
-            // average pause of < 1 millisecond (and max
-            // pause less than 1.5 milliseconds); question is
-            // do we anticipate reference sets in the 100s and
-            // do we care about waiting 10-20 seconds to detect
-            // changes for large reference sets? If so, do we want
-            // to increase the chunk size or decrease the interval
-            // time dynamically to match the large reference set?
-            sys.defaultWatchFileKind = function () { return ts.WatchFileKind.FixedChunkSizePolling; };
             /* eslint-disable no-restricted-globals */
             sys.setTimeout = setTimeout;
             sys.clearTimeout = clearTimeout;