tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/declarations-syntactic.js

@@ -2,12 +2,11 @@
 // overloads and enum values exactly; types from annotations and the isolatedDeclarations
 // rules (literals, `as const`, annotated function expressions). Types that need inference
 // are reported to the tracker and written as `any`.
-import { AsExpression, BigIntLiteral, ObjectLiteralExpression, BindingElement, BindingPattern, ComputedPropertyName, ElementAccessExpression, ExportDeclaration, ExportSpecifier, ExternalModuleReference, FunctionTypeNode, Identifier, ImportAttribute, ImportAttributes, ImportEqualsDeclaration, KeywordTypeNode, LiteralTypeNode, MethodSignatureDeclaration, ModuleDeclaration, NodeVisitor, NumericLiteral, ParameterDeclaration, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertySignatureDeclaration, QualifiedName, SetAccessorDeclaration, GetAccessorDeclaration, HeritageClause, StringLiteral, NoSubstitutionTemplateLiteral, TemplateMiddle, TemplateTail, TypePredicateNode, TupleTypeNode, TypeLiteralNode, TypeOperatorNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getAsteriskToken, getBody, getExpression, getInitializer, getMembers, getName, getText, getParameters, getSymbol, getType, } from '../ast.js';
+import { AsExpression, BigIntLiteral, ObjectLiteralExpression, BindingElement, BindingPattern, ComputedPropertyName, ElementAccessExpression, ExportDeclaration, ExportSpecifier, ExternalModuleReference, FunctionTypeNode, Identifier, ImportEqualsDeclaration, KeywordTypeNode, LiteralTypeNode, MethodSignatureDeclaration, ModuleDeclaration, NodeVisitor, NumericLiteral, ParameterDeclaration, PrefixUnaryExpression, PrivateIdentifier, PropertyAccessExpression, PropertySignatureDeclaration, QualifiedName, SetAccessorDeclaration, GetAccessorDeclaration, HeritageClause, StringLiteral, NoSubstitutionTemplateLiteral, TemplateMiddle, TemplateTail, TypePredicateNode, TupleTypeNode, TypeLiteralNode, TypeOperatorNode, TypeQueryNode, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getAsteriskToken, getBody, getExpression, getInitializer, getMembers, getName, getParameters, getSymbol, getType, } from '../ast.js';
 import { isAmbientModule, isFunctionLike, nodeIsPresent } from '../ast-utilities.js';
 import { getContainerFlags } from '../binder.js';
 import { getCombinedModifierFlags, getCombinedNodeFlags, getRootDeclaration, getSourceFileOfNode, hasSyntacticModifier, isEntityNameExpression, isExternalOrCommonJSModule, isGlobalSourceFile, isIdentifierNamed, isModuleAugmentationExternal, isParameterPropertyDeclaration, isStringOrNumericLiteralLike, skipParentheses, } from '../binder-utilities.js';
 import { NameResolver } from '../name-resolver.js';
-import { ModuleKind as ModuleKinds } from '../options.js';
 import { combinePaths, getDirectoryPath, getNormalizedAbsolutePath, normalizePath } from '../path.js';
 import { isIdentifierText } from '../scanner.js';
 import { DeclarationEmitResolver, SymbolAccessibilityResult, accessible, } from './declarations-resolver.js';
@@ -125,7 +124,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         const meaning = 111551 /* SymbolFlags.Value */ | 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */ | 2097152 /* SymbolFlags.Alias */;
         const parent = node.parent;
         let symbol = undefined;
-        if (node.kind !== 10 /* SyntaxKind.StringLiteral */ && parent.kind === 278 /* SyntaxKind.ExportAssignment */)
+        if (node.kind !== 10 /* SyntaxKind.StringLiteral */ && parent.kind === 279 /* SyntaxKind.ExportAssignment */)
             symbol = this.resolveName(node, getIdentifierText(node), meaning);
         else if (parent instanceof ExportSpecifier) {
             const declaration = parent.parent.parent;
@@ -163,23 +162,23 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     }
     determineIfDeclarationIsVisible(node) {
         switch (node.kind) {
-            case 331 /* SyntaxKind.JSDocCallbackTag */:
-            case 338 /* SyntaxKind.JSDocTypedefTag */: {
+            case 332 /* SyntaxKind.JSDocCallbackTag */:
+            case 339 /* SyntaxKind.JSDocTypedefTag */: {
                 // Top-level JSDoc type aliases are exported.
                 const host = node.parent?.parent?.parent;
-                return host !== undefined && host.kind === 307 /* SyntaxKind.SourceFile */;
+                return host !== undefined && host.kind === 308 /* SyntaxKind.SourceFile */;
             }
-            case 209 /* SyntaxKind.BindingElement */:
+            case 210 /* SyntaxKind.BindingElement */:
                 return this.isDeclarationVisible(node.parent.parent);
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 267 /* SyntaxKind.EnumDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */: {
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */: {
                 if (node instanceof VariableDeclaration &&
                     node.name instanceof BindingPattern &&
                     node.name.elements.nodes.length === 0)
@@ -189,50 +188,50 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
                 const parent = getDeclarationContainer(node);
                 // Unexported declarations are visible only in global files; ambient module members are exported.
                 if ((getCombinedModifierFlags(node) & 32 /* ModifierFlags.Export */) === 0 &&
-                    !(node.kind !== 272 /* SyntaxKind.ImportEqualsDeclaration */ &&
-                        parent.kind !== 307 /* SyntaxKind.SourceFile */ &&
+                    !(node.kind !== 273 /* SyntaxKind.ImportEqualsDeclaration */ &&
+                        parent.kind !== 308 /* SyntaxKind.SourceFile */ &&
                         (parent.flags & 8388608 /* NodeFlags.Ambient */) !== 0))
                     return isGlobalSourceFile(parent);
                 return this.isDeclarationVisible(parent);
             }
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 172 /* SyntaxKind.PropertySignature */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 174 /* SyntaxKind.MethodSignature */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 173 /* SyntaxKind.PropertySignature */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 175 /* SyntaxKind.MethodSignature */:
                 if (this.getEffectiveDeclarationFlags(node, 2 /* ModifierFlags.Private */ | 4 /* ModifierFlags.Protected */) !== 0)
                     return false;
                 return this.isDeclarationVisible(node.parent);
-            case 177 /* SyntaxKind.Constructor */:
-            case 181 /* SyntaxKind.ConstructSignature */:
-            case 180 /* SyntaxKind.CallSignature */:
-            case 182 /* SyntaxKind.IndexSignature */:
-            case 170 /* SyntaxKind.Parameter */:
-            case 269 /* SyntaxKind.ModuleBlock */:
-            case 185 /* SyntaxKind.FunctionType */:
-            case 186 /* SyntaxKind.ConstructorType */:
-            case 188 /* SyntaxKind.TypeLiteral */:
-            case 184 /* SyntaxKind.TypeReference */:
-            case 189 /* SyntaxKind.ArrayType */:
-            case 190 /* SyntaxKind.TupleType */:
-            case 193 /* SyntaxKind.UnionType */:
-            case 194 /* SyntaxKind.IntersectionType */:
-            case 197 /* SyntaxKind.ParenthesizedType */:
-            case 203 /* SyntaxKind.NamedTupleMember */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 182 /* SyntaxKind.ConstructSignature */:
+            case 181 /* SyntaxKind.CallSignature */:
+            case 183 /* SyntaxKind.IndexSignature */:
+            case 171 /* SyntaxKind.Parameter */:
+            case 270 /* SyntaxKind.ModuleBlock */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 189 /* SyntaxKind.TypeLiteral */:
+            case 185 /* SyntaxKind.TypeReference */:
+            case 190 /* SyntaxKind.ArrayType */:
+            case 191 /* SyntaxKind.TupleType */:
+            case 194 /* SyntaxKind.UnionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
+            case 204 /* SyntaxKind.NamedTupleMember */:
                 return this.isDeclarationVisible(node.parent);
             // Imports are visible only once something refers to them.
-            case 274 /* SyntaxKind.ImportClause */:
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 275 /* SyntaxKind.ImportClause */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 return false;
-            case 169 /* SyntaxKind.TypeParameter */:
-            case 307 /* SyntaxKind.SourceFile */:
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 170 /* SyntaxKind.TypeParameter */:
+            case 308 /* SyntaxKind.SourceFile */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 return true;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 return false;
-            case 282 /* SyntaxKind.ExportSpecifier */: {
+            case 283 /* SyntaxKind.ExportSpecifier */: {
                 const declaration = node.parent.parent;
                 if (declaration instanceof ExportDeclaration && declaration.moduleSpecifier === undefined)
                     return this.isDeclarationVisible(declaration.parent);
@@ -281,7 +280,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
                 this.isDeclarationVisible(anyImport.parent))
                 statement = anyImport;
             else if (declaration instanceof VariableDeclaration &&
-                declaration.parent.parent.kind === 244 /* SyntaxKind.VariableStatement */ &&
+                declaration.parent.parent.kind === 245 /* SyntaxKind.VariableStatement */ &&
                 !hasSyntacticModifier(declaration.parent.parent, 32 /* ModifierFlags.Export */) &&
                 this.isDeclarationVisible(declaration.parent.parent.parent))
                 statement = declaration.parent.parent;
@@ -291,10 +290,10 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
                 statement = declaration;
             else if (declaration instanceof BindingElement && (symbol.flags & 2 /* SymbolFlags.BlockScopedVariable */) !== 0) {
                 const root = getRootDeclaration(declaration);
-                if (root.kind === 170 /* SyntaxKind.Parameter */)
+                if (root.kind === 171 /* SyntaxKind.Parameter */)
                     return undefined;
                 const variableStatement = root.parent?.parent;
-                if (variableStatement === undefined || variableStatement.kind !== 244 /* SyntaxKind.VariableStatement */)
+                if (variableStatement === undefined || variableStatement.kind !== 245 /* SyntaxKind.VariableStatement */)
                     return undefined;
                 // Already exported: nothing to keep.
                 if (hasSyntacticModifier(variableStatement, 32 /* ModifierFlags.Export */))
@@ -326,15 +325,15 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         const parent = node.parent;
         // Class and interface members are never implicitly exported or ambient.
         if (parent !== undefined &&
-            parent.kind !== 265 /* SyntaxKind.InterfaceDeclaration */ &&
-            parent.kind !== 264 /* SyntaxKind.ClassDeclaration */ &&
-            parent.kind !== 232 /* SyntaxKind.ClassExpression */ &&
+            parent.kind !== 266 /* SyntaxKind.InterfaceDeclaration */ &&
+            parent.kind !== 265 /* SyntaxKind.ClassDeclaration */ &&
+            parent.kind !== 233 /* SyntaxKind.ClassExpression */ &&
             (node.flags & 8388608 /* NodeFlags.Ambient */) !== 0) {
             const container = getEnclosingContainer(node);
             if (container !== undefined &&
                 (container.flags & 64 /* NodeFlags.ExportContext */) !== 0 &&
                 (result & 128 /* ModifierFlags.Ambient */) === 0 &&
-                !(parent.kind === 269 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
+                !(parent.kind === 270 /* SyntaxKind.ModuleBlock */ && isGlobalScopeAugmentation(parent.parent)))
                 result |= 32 /* ModifierFlags.Export */;
             result |= 128 /* ModifierFlags.Ambient */;
         }
@@ -343,7 +342,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     isImplementationOfOverload(node) {
         if ((node.flags & 16 /* NodeFlags.Synthesized */) !== 0 || !nodeIsPresent(getBody(node)))
             return false;
-        if (node.kind === 178 /* SyntaxKind.GetAccessor */ || node.kind === 179 /* SyntaxKind.SetAccessor */)
+        if (node.kind === 179 /* SyntaxKind.GetAccessor */ || node.kind === 180 /* SyntaxKind.SetAccessor */)
             return false;
         const symbol = this.getSymbolOfDeclaration(node);
         if (symbol === undefined)
@@ -394,7 +393,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
             return undefined;
         const name = node.name.text;
         const left = node.expression;
-        if (left.kind === 79 /* SyntaxKind.Identifier */ || left.kind === 212 /* SyntaxKind.PropertyAccessExpression */) {
+        if (left.kind === 79 /* SyntaxKind.Identifier */ || left.kind === 213 /* SyntaxKind.PropertyAccessExpression */) {
             const symbol = this.resolveEntityNameExpression(left, 111551 /* SymbolFlags.Value */ | 1920 /* SymbolFlags.Namespace */);
             if (symbol !== undefined && (symbol.flags & 2097152 /* SymbolFlags.Alias */) === 0) {
                 const member = (symbol.exports ?? emptyTable).get(name);
@@ -489,14 +488,14 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
             case 132 /* SyntaxKind.AnyKeyword */:
             case 159 /* SyntaxKind.UnknownKeyword */:
                 return true;
-            case 197 /* SyntaxKind.ParenthesizedType */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
                 return this.typeContainsUndefined(getType(type), location);
-            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 for (const member of typesOf(type))
                     if (this.typeContainsUndefined(member, location))
                         return true;
                 return false;
-            case 184 /* SyntaxKind.TypeReference */: {
+            case 185 /* SyntaxKind.TypeReference */: {
                 // An unresolved name or import is an error type, which counts as containing `undefined`.
                 const symbol = this.resolveName(location, getIdentifierText(getFirstIdentifier(type.typeName)), 788968 /* SymbolFlags.Type */ | 1920 /* SymbolFlags.Namespace */);
                 return symbol === undefined || (symbol.flags & 2097152 /* SymbolFlags.Alias */) !== 0;
@@ -513,7 +512,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         // Properties assigned to a function-valued variable are bound to the function.
         if (node instanceof VariableDeclaration)
             host = node.initializer;
-        else if (node.kind !== 263 /* SyntaxKind.FunctionDeclaration */)
+        else if (node.kind !== 264 /* SyntaxKind.FunctionDeclaration */)
             host = undefined;
         if (host === undefined || !isFunctionLike(host))
             return result;
@@ -556,27 +555,6 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
     getTypeReferenceSerializationKind(typeName, location) {
         return this.emitResolver.getTypeReferenceSerializationKind(typeName, location);
     }
-    getResolutionModeOverride(node) {
-        if (!(node instanceof ImportAttributes))
-            return undefined;
-        for (const element of node.attributes.nodes) {
-            if (!(element instanceof ImportAttribute))
-                continue;
-            const name = element.name;
-            if (name === undefined || (name.kind !== 10 /* SyntaxKind.StringLiteral */ && name.kind !== 79 /* SyntaxKind.Identifier */))
-                continue;
-            if (getText(name) !== 'resolution-mode')
-                continue;
-            const value = element.value;
-            if (!(value instanceof StringLiteral))
-                return undefined;
-            if (value.text === 'import')
-                return ModuleKinds.ESNext;
-            if (value.text === 'require')
-                return ModuleKinds.CommonJS;
-        }
-        return undefined;
-    }
     getSourceFileFromReference(file, reference) {
         const path = normalizePath(combinePaths(getDirectoryPath(file.fileName), reference.fileName));
         for (const candidate of [path, path + '.ts', path + '.tsx', path + '.d.ts']) {
@@ -605,10 +583,10 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         if ((declaration.flags & 16 /* NodeFlags.Synthesized */) !== 0)
             return undefined;
         const writer = new PseudoTypeWriter(this, context, tracker, enclosingDeclaration, flags);
-        const isAccessor = declaration.kind === 178 /* SyntaxKind.GetAccessor */ || declaration.kind === 179 /* SyntaxKind.SetAccessor */;
+        const isAccessor = declaration.kind === 179 /* SyntaxKind.GetAccessor */ || declaration.kind === 180 /* SyntaxKind.SetAccessor */;
         this.pseudo.uncertain = 0;
         let type = isAccessor ? this.pseudo.getTypeOfAccessor(declaration) : this.pseudo.getTypeOfDeclaration(declaration);
-        if (declaration.kind === 170 /* SyntaxKind.Parameter */ &&
+        if (declaration.kind === 171 /* SyntaxKind.Parameter */ &&
             this.requiresAddingImplicitUndefined(declaration, enclosingDeclaration) &&
             !this.pseudoContainsUndefined(type))
             type = new UnionType([type, undefinedType]);
@@ -631,7 +609,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
             return false;
         }
         if (type instanceof DirectType)
-            return couldAlreadyReferToUndefined(type) && type.typeNode.kind !== 184 /* SyntaxKind.TypeReference */;
+            return couldAlreadyReferToUndefined(type) && type.typeNode.kind !== 185 /* SyntaxKind.TypeReference */;
         return type.kind === 5 /* PseudoTypeKind.Undefined */;
     }
     createReturnTypeOfSignatureDeclaration(context, signature, enclosingDeclaration, flags, tracker) {
@@ -647,7 +625,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
                 return context.factory.created(new KeywordTypeNode(115 /* SyntaxKind.VoidKeyword */));
             }
         }
-        if (type instanceof NoResultType && getBody(signature) === undefined && signature.kind !== 178 /* SyntaxKind.GetAccessor */) {
+        if (type instanceof NoResultType && getBody(signature) === undefined && signature.kind !== 179 /* SyntaxKind.GetAccessor */) {
             // A signature without a body or annotation returns `any`.
             writer.reportFallback(type, false);
             return undefined;
@@ -659,7 +637,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
         return undefined;
     }
     createLiteralConstValue(context, node, _tracker) {
-        const initializer = node.kind === 278 /* SyntaxKind.ExportAssignment */ ? getExpression(node) : getInitializer(node);
+        const initializer = node.kind === 279 /* SyntaxKind.ExportAssignment */ ? getExpression(node) : getInitializer(node);
         if (initializer === undefined)
             return undefined;
         const literal = literalOf(skipParentheses(initializer));
@@ -679,7 +657,7 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
                 return factory.created(new BigIntLiteral(literal.text, 0 /* TokenFlags.None */));
             case 8 /* SyntaxKind.NumericLiteral */:
                 return createNumberExpression(context, Number(literal.text));
-            case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+            case 226 /* SyntaxKind.PrefixUnaryExpression */: {
                 const unary = literal;
                 const operand = unary.operand;
                 if (operand instanceof BigIntLiteral)
@@ -711,9 +689,9 @@ export class SyntacticDeclarationEmitResolver extends DeclarationEmitResolver {
             if (this.isLateBindableExpression(name.expression))
                 continue;
             this.countFallback(member, true);
-            if (isFunctionLike(member) && getType(member) === undefined && member.kind !== 179 /* SyntaxKind.SetAccessor */)
+            if (isFunctionLike(member) && getType(member) === undefined && member.kind !== 180 /* SyntaxKind.SetAccessor */)
                 writer.write(this.pseudo.getReturnTypeOfSignature(member));
-            else if (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && getType(member) === undefined)
+            else if (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && getType(member) === undefined)
                 writer.write(this.pseudo.getTypeOfDeclaration(member));
         }
         return [];
@@ -940,7 +918,7 @@ class PseudoTypeWriter {
             return undefined;
         const result = factory.created(new ParameterDeclaration(undefined, parameter.rest ? factory.createToken(25 /* SyntaxKind.DotDotDotToken */) : undefined, this.cloneParameterName(parameter.name), parameter.optional ? factory.createToken(57 /* SyntaxKind.QuestionToken */) : undefined, type, undefined));
         const original = parameter.name.parent;
-        if (original !== undefined && original.kind === 170 /* SyntaxKind.Parameter */)
+        if (original !== undefined && original.kind === 171 /* SyntaxKind.Parameter */)
             this.context.assignCommentRange(result, original);
         return result;
     }
@@ -1094,7 +1072,7 @@ class PseudoTypeWriter {
     }
     /** JSDoc types such as `?T` can't be reused as written. */
     markJSDocType(node) {
-        if (node.kind >= 308 /* SyntaxKind.FirstJSDocNode */ && node.kind <= 343 /* SyntaxKind.LastJSDocNode */)
+        if (node.kind >= 309 /* SyntaxKind.FirstJSDocNode */ && node.kind <= 344 /* SyntaxKind.LastJSDocNode */)
             this.reuseFailed = true;
         return true;
     }
@@ -1104,7 +1082,7 @@ class PseudoTypeWriter {
             name = node.typeName;
         else if (node instanceof TypeQueryNode)
             name = node.exprName;
-        else if (node.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */)
+        else if (node.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */)
             name = node.expression;
         if (name === undefined || !(isEntityNameExpression(name, false) || name instanceof QualifiedName))
             return false;
@@ -1137,7 +1115,7 @@ class PseudoTypeWriter {
 function isSignatureLocal(symbol) {
     const declaration = symbol.valueDeclaration ?? (declarationCount(symbol) > 0 ? symbol.declaration : undefined);
     return (declaration !== undefined &&
-        (declaration.kind === 170 /* SyntaxKind.Parameter */ || declaration.kind === 169 /* SyntaxKind.TypeParameter */));
+        (declaration.kind === 171 /* SyntaxKind.Parameter */ || declaration.kind === 170 /* SyntaxKind.TypeParameter */));
 }
 class EntityNameTracker extends NodeVisitor {
     writer;
@@ -1154,7 +1132,7 @@ class EntityNameTracker extends NodeVisitor {
 /** Single-line tuples and mapped types, and string literals without escapes, as tsgo's node reuse. */
 function styleReusedNodes(context, node) {
     const kind = node.kind;
-    if (kind === 190 /* SyntaxKind.TupleType */ || kind === 201 /* SyntaxKind.MappedType */)
+    if (kind === 191 /* SyntaxKind.TupleType */ || kind === 202 /* SyntaxKind.MappedType */)
         context.addEmitFlags(node, 1 /* EmitFlags.SingleLine */);
     else if (kind === 10 /* SyntaxKind.StringLiteral */ || kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */)
         context.addEmitFlags(node, 131072 /* EmitFlags.NoAsciiEscaping */);
@@ -1224,7 +1202,7 @@ export function tryGetTextOfPropertyName(name) {
         case 8 /* SyntaxKind.NumericLiteral */:
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
             return literalText(name);
-        case 168 /* SyntaxKind.ComputedPropertyName */: {
+        case 169 /* SyntaxKind.ComputedPropertyName */: {
             const expression = name.expression;
             return isStringOrNumericLiteralLike(expression) ? literalText(expression) : undefined;
         }
@@ -1233,12 +1211,12 @@ export function tryGetTextOfPropertyName(name) {
 }
 /** Whether a declaration's type is a literal or `unique symbol`: a computed name it names is late-bound. */
 function hasLiteralOrUniqueSymbolType(declaration) {
-    if (declaration.kind === 306 /* SyntaxKind.EnumMember */)
+    if (declaration.kind === 307 /* SyntaxKind.EnumMember */)
         return true;
     const type = getType(declaration);
     if (type !== undefined)
         return ((type instanceof TypeOperatorNode && type.operator === 158 /* SyntaxKind.UniqueKeyword */) ||
-            type.kind === 202 /* SyntaxKind.LiteralType */);
+            type.kind === 203 /* SyntaxKind.LiteralType */);
     const initializer = getInitializer(declaration);
     if (initializer === undefined)
         return false;
@@ -1250,13 +1228,13 @@ function hasLiteralOrUniqueSymbolType(declaration) {
         if ((getCombinedNodeFlags(declaration) & 2 /* NodeFlags.Const */) === 0)
             return false;
         // `const sym = Symbol()` is a unique symbol.
-        if (value.kind === 214 /* SyntaxKind.CallExpression */ && isIdentifierNamed(getExpression(value), 'Symbol'))
+        if (value.kind === 215 /* SyntaxKind.CallExpression */ && isIdentifierNamed(getExpression(value), 'Symbol'))
             return true;
         return isStringOrNumericLiteralLike(value);
     }
-    if (declaration.kind === 173 /* SyntaxKind.PropertyDeclaration */)
+    if (declaration.kind === 174 /* SyntaxKind.PropertyDeclaration */)
         return hasSyntacticModifier(declaration, 8 /* ModifierFlags.Readonly */) && isStringOrNumericLiteralLike(value);
-    if (declaration.kind === 303 /* SyntaxKind.PropertyAssignment */)
+    if (declaration.kind === 304 /* SyntaxKind.PropertyAssignment */)
         return isInConstContext(value) && isStringOrNumericLiteralLike(value);
     return false;
 }
@@ -1270,7 +1248,7 @@ function objectLiteralProperties(node) {
 /** Whether a function's body returns no values, so its inferred return type is `void`. */
 function isTriviallyVoid(fn) {
     const body = getBody(fn);
-    if (body === undefined || body.kind !== 242 /* SyntaxKind.Block */)
+    if (body === undefined || body.kind !== 243 /* SyntaxKind.Block */)
         return false;
     if (hasSyntacticModifier(fn, 1024 /* ModifierFlags.Async */) || getAsteriskToken(fn) !== undefined)
         return false;
@@ -1278,11 +1256,11 @@ function isTriviallyVoid(fn) {
         if (statement.expression !== undefined)
             return false;
     switch (fn.kind) {
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 175 /* SyntaxKind.MethodDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 176 /* SyntaxKind.MethodDeclaration */:
             return true;
-        case 219 /* SyntaxKind.FunctionExpression */:
-        case 220 /* SyntaxKind.ArrowFunction */:
+        case 220 /* SyntaxKind.FunctionExpression */:
+        case 221 /* SyntaxKind.ArrowFunction */:
             // Without an implicit return, function expressions return `never`.
             return (fn.flags & 256 /* NodeFlags.HasImplicitReturn */) !== 0;
     }
@@ -1310,7 +1288,7 @@ function literalOf(node) {
         case 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */:
         case 9 /* SyntaxKind.BigIntLiteral */:
             return node;
-        case 225 /* SyntaxKind.PrefixUnaryExpression */: {
+        case 226 /* SyntaxKind.PrefixUnaryExpression */: {
             const unary = node;
             const operand = unary.operand.kind;
             if (unary.operator === 40 /* SyntaxKind.MinusToken */ &&
@@ -1359,15 +1337,15 @@ function getFirstIdentifier(node) {
 /** What a reference to an entity name means: a value, a namespace or a type. */
 export function getMeaningOfEntityNameReference(entityName) {
     const parent = entityName.parent;
-    if (parent.kind === 187 /* SyntaxKind.TypeQuery */ ||
-        (parent.kind === 234 /* SyntaxKind.ExpressionWithTypeArguments */ && !isPartOfTypeNode(parent)) ||
-        parent.kind === 168 /* SyntaxKind.ComputedPropertyName */ ||
-        (parent.kind === 183 /* SyntaxKind.TypePredicate */ && getTypePredicateParameterName(parent) === entityName) ||
-        parent.kind === 227 /* SyntaxKind.BinaryExpression */)
+    if (parent.kind === 188 /* SyntaxKind.TypeQuery */ ||
+        (parent.kind === 235 /* SyntaxKind.ExpressionWithTypeArguments */ && !isPartOfTypeNode(parent)) ||
+        parent.kind === 169 /* SyntaxKind.ComputedPropertyName */ ||
+        (parent.kind === 184 /* SyntaxKind.TypePredicate */ && getTypePredicateParameterName(parent) === entityName) ||
+        parent.kind === 228 /* SyntaxKind.BinaryExpression */)
         return 111551 /* SymbolFlags.Value */ | 1048576 /* SymbolFlags.ExportValue */;
-    if (entityName.kind === 167 /* SyntaxKind.QualifiedName */ ||
-        entityName.kind === 212 /* SyntaxKind.PropertyAccessExpression */ ||
-        parent.kind === 272 /* SyntaxKind.ImportEqualsDeclaration */ ||
+    if (entityName.kind === 168 /* SyntaxKind.QualifiedName */ ||
+        entityName.kind === 213 /* SyntaxKind.PropertyAccessExpression */ ||
+        parent.kind === 273 /* SyntaxKind.ImportEqualsDeclaration */ ||
         (parent instanceof QualifiedName && parent.left === entityName) ||
         (parent instanceof PropertyAccessExpression && parent.expression === entityName) ||
         (parent instanceof ElementAccessExpression && parent.expression === entityName))
@@ -1383,52 +1361,52 @@ function isPartOfTypeNode(node) {
     if (parent === undefined)
         return false;
     if (parent instanceof HeritageClause)
-        return (!(parent.parent.kind === 264 /* SyntaxKind.ClassDeclaration */ || parent.parent.kind === 232 /* SyntaxKind.ClassExpression */) ||
+        return (!(parent.parent.kind === 265 /* SyntaxKind.ClassDeclaration */ || parent.parent.kind === 233 /* SyntaxKind.ClassExpression */) ||
             parent.token === 118 /* SyntaxKind.ImplementsKeyword */);
     return (parent !== undefined &&
-        (parent.kind === 324 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 323 /* SyntaxKind.JSDocAugmentsTag */));
+        (parent.kind === 325 /* SyntaxKind.JSDocImplementsTag */ || parent.kind === 324 /* SyntaxKind.JSDocAugmentsTag */));
 }
 function isDeclarationKind(kind) {
     switch (kind) {
-        case 261 /* SyntaxKind.VariableDeclaration */:
-        case 170 /* SyntaxKind.Parameter */:
-        case 173 /* SyntaxKind.PropertyDeclaration */:
-        case 172 /* SyntaxKind.PropertySignature */:
-        case 303 /* SyntaxKind.PropertyAssignment */:
-        case 304 /* SyntaxKind.ShorthandPropertyAssignment */:
-        case 209 /* SyntaxKind.BindingElement */:
-        case 278 /* SyntaxKind.ExportAssignment */:
-        case 306 /* SyntaxKind.EnumMember */:
+        case 262 /* SyntaxKind.VariableDeclaration */:
+        case 171 /* SyntaxKind.Parameter */:
+        case 174 /* SyntaxKind.PropertyDeclaration */:
+        case 173 /* SyntaxKind.PropertySignature */:
+        case 304 /* SyntaxKind.PropertyAssignment */:
+        case 305 /* SyntaxKind.ShorthandPropertyAssignment */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 279 /* SyntaxKind.ExportAssignment */:
+        case 307 /* SyntaxKind.EnumMember */:
             return true;
     }
     return false;
 }
 export function getAnyImportSyntax(node) {
     switch (node.kind) {
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             return node;
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return node.parent;
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return node.parent?.parent;
-        case 277 /* SyntaxKind.ImportSpecifier */:
+        case 278 /* SyntaxKind.ImportSpecifier */:
             return node.parent?.parent?.parent;
     }
     return undefined;
 }
 export function isLateVisibilityPaintedStatement(node) {
     switch (node.kind) {
-        case 273 /* SyntaxKind.ImportDeclaration */:
-        case 346 /* SyntaxKind.JSImportDeclaration */:
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-        case 244 /* SyntaxKind.VariableStatement */:
-        case 264 /* SyntaxKind.ClassDeclaration */:
-        case 263 /* SyntaxKind.FunctionDeclaration */:
-        case 268 /* SyntaxKind.ModuleDeclaration */:
-        case 266 /* SyntaxKind.TypeAliasDeclaration */:
-        case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-        case 265 /* SyntaxKind.InterfaceDeclaration */:
-        case 267 /* SyntaxKind.EnumDeclaration */:
+        case 274 /* SyntaxKind.ImportDeclaration */:
+        case 347 /* SyntaxKind.JSImportDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 245 /* SyntaxKind.VariableStatement */:
+        case 265 /* SyntaxKind.ClassDeclaration */:
+        case 264 /* SyntaxKind.FunctionDeclaration */:
+        case 269 /* SyntaxKind.ModuleDeclaration */:
+        case 267 /* SyntaxKind.TypeAliasDeclaration */:
+        case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+        case 266 /* SyntaxKind.InterfaceDeclaration */:
+        case 268 /* SyntaxKind.EnumDeclaration */:
             return true;
     }
     return false;
@@ -1438,12 +1416,12 @@ export function getDeclarationContainer(node) {
     let current = getRootDeclaration(node);
     while (current !== undefined) {
         switch (current.kind) {
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 262 /* SyntaxKind.VariableDeclarationList */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
-            case 276 /* SyntaxKind.NamedImports */:
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 274 /* SyntaxKind.ImportClause */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 263 /* SyntaxKind.VariableDeclarationList */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
+            case 277 /* SyntaxKind.NamedImports */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 275 /* SyntaxKind.ImportClause */:
                 current = current.parent;
                 continue;
         }
@@ -1465,13 +1443,13 @@ export function isExternalModuleAugmentation(node) {
 }
 function isImplicitlyExportedJSDocDeclaration(node) {
     const parent = node.parent;
-    if (parent === undefined || parent.kind !== 307 /* SyntaxKind.SourceFile */)
+    if (parent === undefined || parent.kind !== 308 /* SyntaxKind.SourceFile */)
         return false;
     if (!isExternalOrCommonJSModule(parent))
         return false;
-    if (node.kind === 345 /* SyntaxKind.JSTypeAliasDeclaration */)
+    if (node.kind === 346 /* SyntaxKind.JSTypeAliasDeclaration */)
         return true;
-    return node.kind === 268 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
+    return node.kind === 269 /* SyntaxKind.ModuleDeclaration */ && (node.flags & 8 /* NodeFlags.Reparsed */) !== 0;
 }
 /** Merges global symbol tables as the checker does; conflicting declarations stay apart. */
 function mergeInto(target, source, mergedSymbols) {
@@ -1560,21 +1538,21 @@ class AliasMarker extends NodeVisitor {
     }
     visitNode(node) {
         switch (node.kind) {
-            case 278 /* SyntaxKind.ExportAssignment */: {
+            case 279 /* SyntaxKind.ExportAssignment */: {
                 const expression = getExpression(node);
                 if (expression instanceof Identifier)
                     this.resolver.markLinkedAliases(expression);
                 return false;
             }
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 if (node instanceof ExportSpecifier)
                     this.resolver.markLinkedAliases(node.propertyName ?? node.name);
                 return false;
             // Exports are statements of files and namespaces.
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 269 /* SyntaxKind.ModuleBlock */:
-            case 279 /* SyntaxKind.ExportDeclaration */:
-            case 280 /* SyntaxKind.NamedExports */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 270 /* SyntaxKind.ModuleBlock */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 281 /* SyntaxKind.NamedExports */:
                 return node.forEachChild(this);
         }
         return false;