tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/type-eraser.js

@@ -42,13 +42,13 @@ export class TypeEraser extends Transformer {
             case 86 /* SyntaxKind.ConstKeyword */:
             case 137 /* SyntaxKind.DeclareKeyword */:
             case 148 /* SyntaxKind.ReadonlyKeyword */:
-            case 189 /* SyntaxKind.ArrayType */:
-            case 190 /* SyntaxKind.TupleType */:
-            case 191 /* SyntaxKind.OptionalType */:
-            case 192 /* SyntaxKind.RestType */:
-            case 188 /* SyntaxKind.TypeLiteral */:
-            case 183 /* SyntaxKind.TypePredicate */:
-            case 169 /* SyntaxKind.TypeParameter */:
+            case 190 /* SyntaxKind.ArrayType */:
+            case 191 /* SyntaxKind.TupleType */:
+            case 192 /* SyntaxKind.OptionalType */:
+            case 193 /* SyntaxKind.RestType */:
+            case 189 /* SyntaxKind.TypeLiteral */:
+            case 184 /* SyntaxKind.TypePredicate */:
+            case 170 /* SyntaxKind.TypeParameter */:
             case 132 /* SyntaxKind.AnyKeyword */:
             case 159 /* SyntaxKind.UnknownKeyword */:
             case 135 /* SyntaxKind.BooleanKeyword */:
@@ -57,33 +57,33 @@ export class TypeEraser extends Transformer {
             case 146 /* SyntaxKind.NeverKeyword */:
             case 115 /* SyntaxKind.VoidKeyword */:
             case 155 /* SyntaxKind.SymbolKeyword */:
-            case 186 /* SyntaxKind.ConstructorType */:
-            case 185 /* SyntaxKind.FunctionType */:
-            case 187 /* SyntaxKind.TypeQuery */:
-            case 184 /* SyntaxKind.TypeReference */:
-            case 193 /* SyntaxKind.UnionType */:
-            case 194 /* SyntaxKind.IntersectionType */:
-            case 195 /* SyntaxKind.ConditionalType */:
-            case 197 /* SyntaxKind.ParenthesizedType */:
-            case 198 /* SyntaxKind.ThisType */:
-            case 199 /* SyntaxKind.TypeOperator */:
-            case 200 /* SyntaxKind.IndexedAccessType */:
-            case 201 /* SyntaxKind.MappedType */:
-            case 202 /* SyntaxKind.LiteralType */:
-            case 182 /* SyntaxKind.IndexSignature */:
-            case 346 /* SyntaxKind.JSImportDeclaration */:
-            case 271 /* SyntaxKind.NamespaceExportDeclaration */:
+            case 187 /* SyntaxKind.ConstructorType */:
+            case 186 /* SyntaxKind.FunctionType */:
+            case 188 /* SyntaxKind.TypeQuery */:
+            case 185 /* SyntaxKind.TypeReference */:
+            case 194 /* SyntaxKind.UnionType */:
+            case 195 /* SyntaxKind.IntersectionType */:
+            case 196 /* SyntaxKind.ConditionalType */:
+            case 198 /* SyntaxKind.ParenthesizedType */:
+            case 199 /* SyntaxKind.ThisType */:
+            case 200 /* SyntaxKind.TypeOperator */:
+            case 201 /* SyntaxKind.IndexedAccessType */:
+            case 202 /* SyntaxKind.MappedType */:
+            case 203 /* SyntaxKind.LiteralType */:
+            case 183 /* SyntaxKind.IndexSignature */:
+            case 347 /* SyntaxKind.JSImportDeclaration */:
+            case 272 /* SyntaxKind.NamespaceExportDeclaration */:
                 return undefined;
             case 102 /* SyntaxKind.InKeyword */:
             case 147 /* SyntaxKind.OutKeyword */:
-                if (this.parentNode === undefined || this.parentNode.kind !== 227 /* SyntaxKind.BinaryExpression */)
+                if (this.parentNode === undefined || this.parentNode.kind !== 228 /* SyntaxKind.BinaryExpression */)
                     return undefined;
                 return this.visitEachChild(node);
-            case 266 /* SyntaxKind.TypeAliasDeclaration */:
-            case 345 /* SyntaxKind.JSTypeAliasDeclaration */:
-            case 265 /* SyntaxKind.InterfaceDeclaration */:
+            case 267 /* SyntaxKind.TypeAliasDeclaration */:
+            case 346 /* SyntaxKind.JSTypeAliasDeclaration */:
+            case 266 /* SyntaxKind.InterfaceDeclaration */:
                 return this.notEmitted(node);
-            case 268 /* SyntaxKind.ModuleDeclaration */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
                 if (node instanceof ModuleDeclaration) {
                     if (!(node.name instanceof Identifier) ||
                         !isInstantiatedModule(node, shouldPreserveConstEnums(this.options)) ||
@@ -92,11 +92,11 @@ export class TypeEraser extends Transformer {
                     return this.visitEachChild(node);
                 }
                 break;
-            case 234 /* SyntaxKind.ExpressionWithTypeArguments */:
+            case 235 /* SyntaxKind.ExpressionWithTypeArguments */:
                 if (node instanceof ExpressionWithTypeArguments)
                     return factory.updateExpressionWithTypeArguments(node, this.required(node.expression), undefined);
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration) {
                     const ambientOrAbstract = hasSyntacticModifier(node, 128 /* ModifierFlags.Ambient */ | 64 /* ModifierFlags.Abstract */);
                     if (ambientOrAbstract && !(this.options.experimentalDecorators === true && hasDecorators(node)))
@@ -104,35 +104,35 @@ export class TypeEraser extends Transformer {
                     return factory.updatePropertyDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, undefined, this.visitNode(node.initializer));
                 }
                 break;
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration) {
                     if (nodeIsMissing(node.body))
                         return undefined;
                     return factory.updateConstructorDeclaration(node, undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
                 }
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration) {
                     if (nodeIsMissing(node.body))
                         return undefined;
                     return factory.updateMethodDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.required(node.name), undefined, undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
                 }
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration) {
                     if (nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
                         return undefined;
                     return factory.updateGetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.accessorBody(node.body));
                 }
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration) {
                     if (nodeIsMissing(node.body) && hasSyntacticModifier(node, 64 /* ModifierFlags.Abstract */))
                         return undefined;
                     return factory.updateSetAccessorDeclaration(node, this.visitModifiers(node.modifiers), this.required(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.accessorBody(node.body));
                 }
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (node instanceof VariableDeclaration) {
                     const updated = factory.updateVariableDeclaration(node, this.required(node.name), undefined, undefined, this.visitNode(node.initializer));
                     if (node.type !== undefined)
@@ -140,79 +140,79 @@ export class TypeEraser extends Transformer {
                     return updated;
                 }
                 break;
-            case 299 /* SyntaxKind.HeritageClause */:
+            case 300 /* SyntaxKind.HeritageClause */:
                 if (node instanceof HeritageClause) {
                     if (node.token === 118 /* SyntaxKind.ImplementsKeyword */)
                         return undefined;
                     return factory.updateHeritageClause(node, node.token, this.visitNodes(node.types));
                 }
                 break;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 if (node instanceof ClassDeclaration)
                     return factory.updateClassDeclaration(node, this.visitModifiers(node.modifiers), this.optionalIdentifier(node.name), undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 if (node instanceof ClassExpression)
                     return factory.updateClassExpression(node, this.visitModifiers(node.modifiers), this.optionalIdentifier(node.name), undefined, this.visitNodes(node.heritageClauses), this.visitNodes(node.members));
                 break;
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 if (node instanceof FunctionDeclaration) {
                     if (nodeIsMissing(node.body))
                         return this.notEmitted(node);
                     return factory.updateFunctionDeclaration(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.optionalIdentifier(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.visitNode(node.body));
                 }
                 break;
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 if (node instanceof FunctionExpression)
                     return factory.updateFunctionExpression(node, this.visitModifiers(node.modifiers), node.asteriskToken, this.optionalIdentifier(node.name), undefined, this.visitNodes(node.parameters), undefined, undefined, this.required(node.body));
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 if (node instanceof ArrowFunction)
                     return factory.updateArrowFunction(node, this.visitModifiers(node.modifiers), undefined, this.visitNodes(node.parameters), undefined, undefined, node.equalsGreaterThanToken, this.required(node.body));
                 break;
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration)
                     return this.visitParameter(node);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression)
                     return factory.updateCallExpression(node, this.required(node.expression), callQuestionDotToken(node), undefined, this.visitNodes(node.arguments), node.flags);
                 break;
-            case 215 /* SyntaxKind.NewExpression */:
+            case 216 /* SyntaxKind.NewExpression */:
                 if (node instanceof NewExpression)
                     return factory.updateNewExpression(node, this.required(node.expression), undefined, this.visitNodes(node.arguments));
                 break;
-            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */:
                 if (node instanceof TaggedTemplateExpression)
                     return factory.updateTaggedTemplateExpression(node, this.required(node.tag), node.questionDotToken, undefined, this.required(node.template), node.flags);
                 break;
-            case 236 /* SyntaxKind.NonNullExpression */:
-            case 217 /* SyntaxKind.TypeAssertionExpression */:
-            case 235 /* SyntaxKind.AsExpression */:
-            case 239 /* SyntaxKind.SatisfiesExpression */:
+            case 237 /* SyntaxKind.NonNullExpression */:
+            case 218 /* SyntaxKind.TypeAssertionExpression */:
+            case 236 /* SyntaxKind.AsExpression */:
+            case 240 /* SyntaxKind.SatisfiesExpression */:
                 return this.partiallyEmitted(node, getExpression(node));
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 if (node instanceof ParenthesizedExpression && !isJSDocTypeAssertion(node)) {
                     const inner = skipParenthesesAndPartiallyEmitted(node.expression);
-                    if (inner.kind === 217 /* SyntaxKind.TypeAssertionExpression */ ||
-                        inner.kind === 235 /* SyntaxKind.AsExpression */ ||
-                        inner.kind === 239 /* SyntaxKind.SatisfiesExpression */)
+                    if (inner.kind === 218 /* SyntaxKind.TypeAssertionExpression */ ||
+                        inner.kind === 236 /* SyntaxKind.AsExpression */ ||
+                        inner.kind === 240 /* SyntaxKind.SatisfiesExpression */)
                         return this.partiallyEmitted(node, node.expression);
                 }
                 return this.visitEachChild(node);
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
                 if (node instanceof JsxSelfClosingElement)
                     return factory.updateJsxSelfClosingElement(node, this.required(node.tagName), undefined, this.jsxAttributes(node.attributes));
                 break;
-            case 287 /* SyntaxKind.JsxOpeningElement */:
+            case 288 /* SyntaxKind.JsxOpeningElement */:
                 if (node instanceof JsxOpeningElement)
                     return factory.updateJsxOpeningElement(node, this.required(node.tagName), undefined, this.jsxAttributes(node.attributes));
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration && node.isTypeOnly)
                     return undefined;
                 return this.visitEachChild(node);
-            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
                 if (node instanceof ImportDeclaration) {
                     if (node.importClause === undefined)
                         return node;
@@ -222,17 +222,24 @@ export class TypeEraser extends Transformer {
                     return factory.updateImportDeclaration(node, node.modifiers, clause, node.moduleSpecifier, node.attributes);
                 }
                 break;
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node instanceof ImportClause) {
                     if (node.phaseModifier === 156 /* SyntaxKind.TypeKeyword */)
                         return undefined;
-                    const bindings = this.visitNode(node.namedBindings);
+                    let bindings = this.visitNode(node.namedBindings);
+                    // With a default import, `{}` left by erasing type-only specifiers goes; a `{}` written in the source stays.
+                    if (node.name !== undefined &&
+                        bindings instanceof NamedImports &&
+                        bindings.elements.nodes.length === 0 &&
+                        node.namedBindings instanceof NamedImports &&
+                        node.namedBindings.elements.nodes.length !== 0)
+                        bindings = undefined;
                     if (node.name === undefined && bindings === undefined)
                         return undefined;
                     return factory.updateImportClause(node, node.phaseModifier, node.name, bindings);
                 }
                 break;
-            case 276 /* SyntaxKind.NamedImports */:
+            case 277 /* SyntaxKind.NamedImports */:
                 if (node instanceof NamedImports) {
                     if (node.elements.nodes.length === 0)
                         return node;
@@ -242,9 +249,9 @@ export class TypeEraser extends Transformer {
                     return factory.updateNamedImports(node, elements);
                 }
                 break;
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 return node instanceof ImportSpecifier && node.isTypeOnly ? undefined : node;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration) {
                     if (node.isTypeOnly)
                         return undefined;
@@ -257,7 +264,7 @@ export class TypeEraser extends Transformer {
                     return factory.updateExportDeclaration(node, undefined, false, clause, this.visitNode(node.moduleSpecifier), node.attributes === undefined ? undefined : this.importAttributes(node.attributes));
                 }
                 break;
-            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamedExports */:
                 if (node instanceof NamedExports) {
                     if (node.elements.nodes.length === 0)
                         return node;
@@ -267,9 +274,9 @@ export class TypeEraser extends Transformer {
                     return factory.updateNamedExports(node, elements);
                 }
                 break;
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 return node instanceof ExportSpecifier && node.isTypeOnly ? undefined : node;
-            case 267 /* SyntaxKind.EnumDeclaration */:
+            case 268 /* SyntaxKind.EnumDeclaration */:
                 if (hasSyntacticModifier(node, 4096 /* ModifierFlags.Const */))
                     return node;
                 return this.visitEachChild(node);
@@ -325,7 +332,7 @@ export class TypeEraser extends Transformer {
             const decorators = [];
             const nodes = node.modifiers.nodes;
             for (let i = 0; i < nodes.length; i++)
-                if (nodes[i].kind === 171 /* SyntaxKind.Decorator */)
+                if (nodes[i].kind === 172 /* SyntaxKind.Decorator */)
                     decorators.push(nodes[i]);
             const visited = this.visitArray(decorators);
             modifiers = this.factory.createModifierList(modifiers === undefined ? visited : modifiers.nodes.concat(visited));

package/dist/api/compiler/transformers/type-serialization.js

@@ -3,7 +3,7 @@
 // what syntax shows: classes, enums, interfaces, type aliases and type parameters, through
 // imports. Types only the checker can compute (conditional, mapped and indexed access types,
 // inherited members) serialize as `Object`.
-import { ArrayTypeNode, EnumDeclaration, Identifier, ImportClause, InterfaceDeclaration, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, QualifiedName, TypeAliasDeclaration, TypeLiteralNode, TypeOperatorNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getIsTypeOnly, } from '../ast.js';
+import { ArrayTypeNode, EnumDeclaration, Identifier, ImportClause, InterfaceDeclaration, LiteralTypeNode, ParenthesizedTypeNode, PrefixUnaryExpression, QualifiedName, TypeAliasDeclaration, TypeLiteralNode, TypeOperatorNode, TypeParameterDeclaration, TypeReferenceNode, UnionTypeNode, VariableDeclaration, getIsTypeOnly, getText, } from '../ast.js';
 import { getStrictOptionValue } from '../options.js';
 import { declarationAt, declarationCount, getDeclarations, Symbol } from '../symbol.js';
 /** What an unresolvable alias resolves to, as the checker's unknown symbol. */
@@ -72,11 +72,11 @@ function resolveEntityName(resolver, name, meaning, dontResolveAlias, location)
             return undefined;
         if (namespace === unknownSymbol)
             return namespace;
-        let member = resolver.getExportOfSymbol(namespace, name.right.text);
+        let member = resolver.getExportOfSymbol(namespace, getText(name.right));
         if (member === undefined && (namespace.flags & 2097152 /* SymbolFlags.Alias */) !== 0) {
             const target = resolver.resolveAlias(namespace);
             if (target !== undefined)
-                member = resolver.getExportOfSymbol(target, name.right.text);
+                member = resolver.getExportOfSymbol(target, getText(name.right));
         }
         if (member === undefined || (member.flags & (meaning | 2097152 /* SymbolFlags.Alias */)) === 0)
             return undefined;
@@ -112,10 +112,10 @@ function hasConstructSignature(resolver, type, location, depth) {
         return false;
     while (type instanceof ParenthesizedTypeNode)
         type = type.type;
-    if (type.kind === 186 /* SyntaxKind.ConstructorType */)
+    if (type.kind === 187 /* SyntaxKind.ConstructorType */)
         return true;
     if (type instanceof TypeLiteralNode)
-        return hasMember(type.members.nodes, 181 /* SyntaxKind.ConstructSignature */);
+        return hasMember(type.members.nodes, 182 /* SyntaxKind.ConstructSignature */);
     if (type instanceof TypeReferenceNode) {
         const symbol = resolveEntityName(resolver, type.typeName, 788968 /* SymbolFlags.Type */, false, location);
         if (symbol === undefined || symbol === unknownSymbol)
@@ -123,7 +123,7 @@ function hasConstructSignature(resolver, type, location, depth) {
         for (let i = 0; i < declarationCount(symbol); i++) {
             const declaration = declarationAt(symbol, i);
             if (declaration instanceof InterfaceDeclaration &&
-                hasMember(declaration.members.nodes, 181 /* SyntaxKind.ConstructSignature */))
+                hasMember(declaration.members.nodes, 182 /* SyntaxKind.ConstructSignature */))
                 return true;
             if (declaration instanceof TypeAliasDeclaration)
                 return hasConstructSignature(resolver, declaration.type, declaration, depth + 1);
@@ -177,7 +177,7 @@ class TypeClassifier {
             for (let i = 0; i < declarationCount(symbol); i++) {
                 const declaration = declarationAt(symbol, i);
                 if (declaration instanceof InterfaceDeclaration &&
-                    hasMember(declaration.members.nodes, 180 /* SyntaxKind.CallSignature */))
+                    hasMember(declaration.members.nodes, 181 /* SyntaxKind.CallSignature */))
                     return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
             }
         }
@@ -223,35 +223,35 @@ class TypeClassifier {
             case 163 /* SyntaxKind.BigIntKeyword */:
                 return 4 /* TypeReferenceSerializationKind.BigIntLikeType */;
             case 154 /* SyntaxKind.StringKeyword */:
-            case 204 /* SyntaxKind.TemplateLiteralType */:
+            case 205 /* SyntaxKind.TemplateLiteralType */:
                 return 5 /* TypeReferenceSerializationKind.StringLikeType */;
-            case 190 /* SyntaxKind.TupleType */:
+            case 191 /* SyntaxKind.TupleType */:
                 return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
             case 155 /* SyntaxKind.SymbolKeyword */:
                 return 8 /* TypeReferenceSerializationKind.ESSymbolType */;
-            case 185 /* SyntaxKind.FunctionType */:
+            case 186 /* SyntaxKind.FunctionType */:
                 return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
-            case 189 /* SyntaxKind.ArrayType */:
+            case 190 /* SyntaxKind.ArrayType */:
                 return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
-            case 202 /* SyntaxKind.LiteralType */:
+            case 203 /* SyntaxKind.LiteralType */:
                 if (node instanceof LiteralTypeNode)
                     return ofLiteral(node.literal);
                 break;
-            case 199 /* SyntaxKind.TypeOperator */:
+            case 200 /* SyntaxKind.TypeOperator */:
                 if (node instanceof TypeOperatorNode) {
                     if (node.operator === 158 /* SyntaxKind.UniqueKeyword */)
                         return 8 /* TypeReferenceSerializationKind.ESSymbolType */;
                     if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ && node.type instanceof ArrayTypeNode)
                         return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
-                    if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ && node.type.kind === 190 /* SyntaxKind.TupleType */)
+                    if (node.operator === 148 /* SyntaxKind.ReadonlyKeyword */ && node.type.kind === 191 /* SyntaxKind.TupleType */)
                         return 7 /* TypeReferenceSerializationKind.ArrayLikeType */;
                 }
                 break;
-            case 188 /* SyntaxKind.TypeLiteral */:
-                if (node instanceof TypeLiteralNode && hasMember(node.members.nodes, 180 /* SyntaxKind.CallSignature */))
+            case 189 /* SyntaxKind.TypeLiteral */:
+                if (node instanceof TypeLiteralNode && hasMember(node.members.nodes, 181 /* SyntaxKind.CallSignature */))
                     return 10 /* TypeReferenceSerializationKind.TypeWithCallSignature */;
                 break;
-            case 184 /* SyntaxKind.TypeReference */:
+            case 185 /* SyntaxKind.TypeReference */:
                 if (node instanceof TypeReferenceNode) {
                     const symbol = resolveEntityName(this.resolver, node.typeName, 788968 /* SymbolFlags.Type */, false, location);
                     if (symbol === undefined || symbol === unknownSymbol)
@@ -259,7 +259,7 @@ class TypeClassifier {
                     return this.ofSymbol(symbol, depth + 1);
                 }
                 break;
-            case 193 /* SyntaxKind.UnionType */:
+            case 194 /* SyntaxKind.UnionType */:
                 if (node instanceof UnionTypeNode)
                     return this.ofUnion(node.types.nodes, location, depth);
                 break;
@@ -311,7 +311,7 @@ function ofLiteral(literal) {
             return 6 /* TypeReferenceSerializationKind.BooleanType */;
         case 105 /* SyntaxKind.NullKeyword */:
             return 2 /* TypeReferenceSerializationKind.VoidNullableOrNeverType */;
-        case 225 /* SyntaxKind.PrefixUnaryExpression */:
+        case 226 /* SyntaxKind.PrefixUnaryExpression */:
             if (literal instanceof PrefixUnaryExpression)
                 return ofLiteral(literal.operand);
             break;
@@ -326,18 +326,18 @@ function getFirstIdentifier(node) {
 /** Whether an alias declaration is type-only, itself or through its import clause. */
 function isTypeOnlyImportOrExportDeclaration(node) {
     switch (node.kind) {
-        case 277 /* SyntaxKind.ImportSpecifier */:
-        case 282 /* SyntaxKind.ExportSpecifier */: {
+        case 278 /* SyntaxKind.ImportSpecifier */:
+        case 283 /* SyntaxKind.ExportSpecifier */: {
             if (getIsTypeOnly(node))
                 return true;
             const clause = node.parent === undefined ? undefined : node.parent.parent;
             return clause !== undefined && isTypeOnlyImportClause(clause);
         }
-        case 275 /* SyntaxKind.NamespaceImport */:
+        case 276 /* SyntaxKind.NamespaceImport */:
             return node.parent !== undefined && isTypeOnlyImportClause(node.parent);
-        case 274 /* SyntaxKind.ImportClause */:
+        case 275 /* SyntaxKind.ImportClause */:
             return isTypeOnlyImportClause(node);
-        case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+        case 273 /* SyntaxKind.ImportEqualsDeclaration */:
             return getIsTypeOnly(node);
     }
     return false;

package/dist/api/compiler/transformers/using.js

@@ -26,13 +26,13 @@ export class UsingTransformer extends Transformer {
         if (!this.facts.has(node, 4 /* SubtreeFacts.ContainsUsing */))
             return node;
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return this.visitSourceFile(node);
-            case 242 /* SyntaxKind.Block */:
+            case 243 /* SyntaxKind.Block */:
                 return this.visitBlock(node);
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 return this.visitForStatement(node);
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 return this.visitForOfStatement(node);
         }
         return this.visitEachChild(node);
@@ -218,17 +218,17 @@ export class UsingTransformer extends Transformer {
         if (topLevel === undefined)
             return node;
         switch (node.kind) {
-            case 273 /* SyntaxKind.ImportDeclaration */:
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
-            case 279 /* SyntaxKind.ExportDeclaration */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
                 topLevel.push(node);
                 return undefined;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 return this.hoistExportAssignment(node);
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 return this.hoistClassDeclaration(node);
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 return this.hoistVariableStatement(node);
         }
         return node;
@@ -447,7 +447,7 @@ function getUsingKindOfStatements(statements) {
 function getBindingName(node) {
     if (node instanceof VariableDeclaration)
         return node.name;
-    if (node.kind === 209 /* SyntaxKind.BindingElement */)
+    if (node.kind === 210 /* SyntaxKind.BindingElement */)
         return node.name;
     return undefined;
 }