tsc-ts 0.0.9 → 0.1.0

package/dist/api/compiler/transformers/es-decorators.js

@@ -227,8 +227,8 @@ export class ESDecorators extends Transformer {
     enterClassElement(node) {
         const entry = new LexicalEntry(1 /* LexicalEntryKind.ClassElement */, this.top, undefined, undefined);
         this.top = entry;
-        if (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
-            (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(node))) {
+        if (node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+            (node.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(node))) {
             const info = entry.next.classInfo;
             if (info !== undefined) {
                 entry.classThis = info.classThis;
@@ -284,90 +284,90 @@ export class ESDecorators extends Transformer {
         if (!this.shouldVisitNode(node))
             return node;
         switch (node.kind) {
-            case 171 /* SyntaxKind.Decorator */:
+            case 172 /* SyntaxKind.Decorator */:
                 return undefined;
-            case 264 /* SyntaxKind.ClassDeclaration */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
                 if (node instanceof ClassDeclaration)
                     return this.visitClassDeclaration(node);
                 break;
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 if (node instanceof ClassExpression)
                     return this.visitClassExpression(node);
                 break;
-            case 177 /* SyntaxKind.Constructor */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 throw new Error('Class elements are visited with visitClassElement');
-            case 170 /* SyntaxKind.Parameter */:
+            case 171 /* SyntaxKind.Parameter */:
                 if (node instanceof ParameterDeclaration)
                     return this.visitParameterDeclaration(node);
                 break;
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 if (node instanceof BinaryExpression)
                     return this.visitBinaryExpression(node, false);
                 break;
-            case 303 /* SyntaxKind.PropertyAssignment */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
                 if (node instanceof PropertyAssignment)
                     return this.visitNamedEvaluationSite(node, node.initializer);
                 break;
-            case 261 /* SyntaxKind.VariableDeclaration */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
                 if (node instanceof VariableDeclaration)
                     return this.visitNamedEvaluationSite(node, node.initializer);
                 break;
-            case 209 /* SyntaxKind.BindingElement */:
+            case 210 /* SyntaxKind.BindingElement */:
                 if (node instanceof BindingElement)
                     return this.visitNamedEvaluationSite(node, node.initializer);
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment)
                     return this.visitNamedEvaluationSite(node, node.expression);
                 break;
             case 109 /* SyntaxKind.ThisKeyword */:
                 return this.classThis !== undefined ? this.classThis : node;
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 if (node instanceof ForStatement)
                     return this.visitForStatement(node);
                 break;
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 if (node instanceof ExpressionStatement)
                     return this.factory.updateExpressionStatement(node, this.visitDiscardedNode(node.expression));
                 break;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 if (node instanceof ParenthesizedExpression)
                     return this.visitParenthesizedExpression(node, false);
                 break;
-            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            case 349 /* SyntaxKind.PartiallyEmittedExpression */:
                 if (node instanceof PartiallyEmittedExpression)
                     return this.visitPartiallyEmittedExpression(node, false);
                 break;
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 if (node instanceof CallExpression)
                     return this.visitCallExpression(node);
                 break;
-            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */:
                 if (node instanceof TaggedTemplateExpression)
                     return this.visitTaggedTemplateExpression(node);
                 break;
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 return this.visitPreOrPostfixUnaryExpression(node, false);
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 if (node instanceof PropertyAccessExpression)
                     return this.visitPropertyAccessExpression(node);
                 break;
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 if (node instanceof ElementAccessExpression)
                     return this.visitElementAccessExpression(node);
                 break;
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 if (node instanceof ComputedPropertyName)
                     return this.visitComputedPropertyName(node);
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */: {
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */: {
                 this.enterOther();
                 const result = this.visitEachChild(node);
                 this.exitOther();
@@ -402,27 +402,27 @@ export class ESDecorators extends Transformer {
     }
     visitClassElement(node) {
         switch (node.kind) {
-            case 177 /* SyntaxKind.Constructor */:
+            case 178 /* SyntaxKind.Constructor */:
                 if (node instanceof ConstructorDeclaration)
                     return this.visitConstructorDeclaration(node);
                 break;
-            case 175 /* SyntaxKind.MethodDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
                 if (node instanceof MethodDeclaration)
                     return this.visitMethodDeclaration(node);
                 break;
-            case 178 /* SyntaxKind.GetAccessor */:
+            case 179 /* SyntaxKind.GetAccessor */:
                 if (node instanceof GetAccessorDeclaration)
                     return this.visitGetAccessorDeclaration(node);
                 break;
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 if (node instanceof SetAccessorDeclaration)
                     return this.visitSetAccessorDeclaration(node);
                 break;
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 if (node instanceof PropertyDeclaration)
                     return this.visitPropertyDeclaration(node);
                 break;
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
                 if (node instanceof ClassStaticBlockDeclaration)
                     return this.visitClassStaticBlockDeclaration(node);
                 break;
@@ -432,18 +432,18 @@ export class ESDecorators extends Transformer {
     /** Visits a node whose value is discarded, such as an expression statement's expression. */
     visitDiscarded(node) {
         switch (node.kind) {
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 return this.visitPreOrPostfixUnaryExpression(node, true);
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 if (node instanceof BinaryExpression)
                     return this.visitBinaryExpression(node, true);
                 break;
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 if (node instanceof ParenthesizedExpression)
                     return this.visitParenthesizedExpression(node, true);
                 break;
-            case 348 /* SyntaxKind.PartiallyEmittedExpression */:
+            case 349 /* SyntaxKind.PartiallyEmittedExpression */:
                 if (node instanceof PartiallyEmittedExpression)
                     return this.visitPartiallyEmittedExpression(node, true);
                 break;
@@ -458,9 +458,9 @@ export class ESDecorators extends Transformer {
             case 0 /* ListVisit.ClassElements */:
                 return this.visitClassElement(node);
             case 1 /* ListVisit.NonConstructorClassElements */:
-                return node.kind === 177 /* SyntaxKind.Constructor */ ? node : this.visitClassElement(node);
+                return node.kind === 178 /* SyntaxKind.Constructor */ ? node : this.visitClassElement(node);
             case 2 /* ListVisit.ConstructorClassElements */:
-                return node.kind === 177 /* SyntaxKind.Constructor */ ? this.visitClassElement(node) : node;
+                return node.kind === 178 /* SyntaxKind.Constructor */ ? this.visitClassElement(node) : node;
             case 3 /* ListVisit.ArrayAssignmentElements */:
                 return this.visitArrayAssignmentElement(node);
             case 4 /* ListVisit.ObjectAssignmentElements */:
@@ -633,7 +633,7 @@ export class ESDecorators extends Transformer {
             const unwrapped = skipOuterExpressions(extendsExpression, 63 /* OuterExpressionKinds.All */);
             const anonymous = (unwrapped instanceof ClassExpression && unwrapped.name === undefined) ||
                 (unwrapped instanceof FunctionExpression && unwrapped.name === undefined) ||
-                unwrapped.kind === 220 /* SyntaxKind.ArrowFunction */;
+                unwrapped.kind === 221 /* SyntaxKind.ArrowFunction */;
             const safeExtendsExpression = anonymous
                 ? factory.createCommaExpression(factory.createNumericLiteral('0'), extendsExpression)
                 : extendsExpression;
@@ -1002,11 +1002,11 @@ export class ESDecorators extends Transformer {
             const memberInfo = new MemberInfo(memberDecoratorsName);
             info.setMemberInfo(member, memberInfo);
             this.pendingExpressions.push(factory.createAssignment(memberDecoratorsName, factory.created(new ArrayLiteralExpression(factory.createNodeList(memberDecorators), false))));
-            const kind = member.kind === 178 /* SyntaxKind.GetAccessor */
+            const kind = member.kind === 179 /* SyntaxKind.GetAccessor */
                 ? 'getter'
-                : member.kind === 179 /* SyntaxKind.SetAccessor */
+                : member.kind === 180 /* SyntaxKind.SetAccessor */
                     ? 'setter'
-                    : member.kind === 175 /* SyntaxKind.MethodDeclaration */
+                    : member.kind === 176 /* SyntaxKind.MethodDeclaration */
                         ? 'method'
                         : isAutoAccessorPropertyDeclaration(member)
                             ? 'accessor'
@@ -1031,8 +1031,8 @@ export class ESDecorators extends Transformer {
                     nameExpression = result.referencedName;
                 }
             }
-            const isField = member.kind === 173 /* SyntaxKind.PropertyDeclaration */;
-            const contextObject = this.createClassElementContextObject(kind, nameComputed, nameExpression, isStatic(member), memberName instanceof PrivateIdentifier, isField || member.kind === 178 /* SyntaxKind.GetAccessor */ || member.kind === 175 /* SyntaxKind.MethodDeclaration */, isField || member.kind === 179 /* SyntaxKind.SetAccessor */, info.metadataReference);
+            const isField = member.kind === 174 /* SyntaxKind.PropertyDeclaration */;
+            const contextObject = this.createClassElementContextObject(kind, nameComputed, nameExpression, isStatic(member), memberName instanceof PrivateIdentifier, isField || member.kind === 179 /* SyntaxKind.GetAccessor */ || member.kind === 176 /* SyntaxKind.MethodDeclaration */, isField || member.kind === 180 /* SyntaxKind.SetAccessor */, info.metadataReference);
             if (isMethodOrAccessor(member)) {
                 //   __esDecorate(this, null | _member_descriptor = { value() { ... } }, _member_decorators, { kind: "method", ... }, null, _instanceExtraInitializers);
                 const extraInitializersName = isStatic(member)
@@ -1086,7 +1086,7 @@ export class ESDecorators extends Transformer {
         }
         // Comments of methods and properties without modifiers would print twice on the name.
         if ((modifiers === undefined || modifiers.nodes.length === 0) &&
-            (member.kind === 175 /* SyntaxKind.MethodDeclaration */ || member.kind === 173 /* SyntaxKind.PropertyDeclaration */))
+            (member.kind === 176 /* SyntaxKind.MethodDeclaration */ || member.kind === 174 /* SyntaxKind.PropertyDeclaration */))
             context.setEmitFlags(result.name, 128 /* EmitFlags.NoLeadingComments */);
         return result;
     }
@@ -1551,7 +1551,7 @@ export class ESDecorators extends Transformer {
                 return this.factory.updateSpreadElement(spread, this.visitDestructuringAssignmentTarget(spread.expression));
             return this.visitEachChild(node);
         }
-        if (node.kind !== 233 /* SyntaxKind.OmittedExpression */)
+        if (node.kind !== 234 /* SyntaxKind.OmittedExpression */)
             return this.visitAssignmentElement(node);
         return this.visitEachChild(node);
     }
@@ -1858,9 +1858,9 @@ function getHelperVariableName(context, node) {
         declarationName = 'class';
     else
         declarationName = 'member';
-    if (node.kind === 178 /* SyntaxKind.GetAccessor */)
+    if (node.kind === 179 /* SyntaxKind.GetAccessor */)
         declarationName = 'get_' + declarationName;
-    if (node.kind === 179 /* SyntaxKind.SetAccessor */)
+    if (node.kind === 180 /* SyntaxKind.SetAccessor */)
         declarationName = 'set_' + declarationName;
     if (name instanceof PrivateIdentifier)
         declarationName = 'private_' + declarationName;
@@ -1875,9 +1875,9 @@ function isStaticPrivateOrAutoAccessor(member) {
 function keepsModifier(filter, kind) {
     switch (filter) {
         case 0 /* ModifierFilter.NoDecorators */:
-            return kind !== 171 /* SyntaxKind.Decorator */;
+            return kind !== 172 /* SyntaxKind.Decorator */;
         case 1 /* ModifierFilter.NoExport */:
-            return kind !== 171 /* SyntaxKind.Decorator */ && kind !== 94 /* SyntaxKind.ExportKeyword */;
+            return kind !== 172 /* SyntaxKind.Decorator */ && kind !== 94 /* SyntaxKind.ExportKeyword */;
         case 2 /* ModifierFilter.StaticOnly */:
             return kind === 125 /* SyntaxKind.StaticKeyword */;
         case 3 /* ModifierFilter.AsyncOnly */:

package/dist/api/compiler/transformers/external-module-info.js

@@ -62,7 +62,7 @@ class ExternalModuleInfoCollector {
             if (node instanceof ImportDeclaration)
                 output.externalImports.push(node);
             else if (node instanceof ImportEqualsDeclaration) {
-                if (node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */)
+                if (node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */)
                     output.externalImports.push(node);
             }
             else if (node instanceof ExportDeclaration)
@@ -319,12 +319,12 @@ export function createExternalHelpersImportDeclarationIfNeeded(context, file, op
     for (let i = 0; i < names.length; i++) {
         const name = names[i];
         // Aliased when the name is used in the file.
-        specifiers.push(isFileLevelUniqueName(file, name)
+        specifiers.push(isFileLevelUniqueName(context.mostOriginal(file), name)
             ? factory.created(new ImportSpecifier(false, undefined, factory.createIdentifier(name)))
             : factory.created(new ImportSpecifier(false, factory.createIdentifier(name), factory.createUnscopedHelperName(name))));
     }
     context.addEmitFlags(context.mostOriginal(file), 262144 /* EmitFlags.ExternalHelpers */);
-    const declaration = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList(specifiers))))), factory.createStringLiteral(externalHelpersModuleNameText, 0 /* TokenFlags.None */), undefined));
+    const declaration = factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, factory.created(new ImportClause(undefined, undefined, factory.created(new NamedImports(factory.createNodeList(specifiers))))), factory.createStringLiteral(externalHelpersModuleNameText, 0 /* TokenFlags.None */), undefined));
     context.addEmitFlags(declaration, 65536 /* EmitFlags.CustomPrologue */);
     return declaration;
 }

package/dist/api/compiler/transformers/for-await.js

@@ -34,12 +34,12 @@ export class AsyncIteration extends Transformer {
         if (this.superAccess.capturedSuperProperties === undefined)
             return node;
         switch (node.kind) {
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 177 /* SyntaxKind.Constructor */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
                 return node;
         }
         this.superAccess.track(node);
@@ -53,45 +53,45 @@ export class AsyncIteration extends Transformer {
             return this.fallback(node);
         this.superAccess.track(node);
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile)
                     return this.visitSourceFile(node);
                 break;
-            case 224 /* SyntaxKind.AwaitExpression */:
+            case 225 /* SyntaxKind.AwaitExpression */:
                 if (node instanceof AwaitExpression)
                     return this.visitAwaitExpression(node);
                 break;
-            case 230 /* SyntaxKind.YieldExpression */:
+            case 231 /* SyntaxKind.YieldExpression */:
                 if (node instanceof YieldExpression)
                     return this.visitYieldExpression(node);
                 break;
-            case 254 /* SyntaxKind.ReturnStatement */:
+            case 255 /* SyntaxKind.ReturnStatement */:
                 if (node instanceof ReturnStatement)
                     return this.visitReturnStatement(node);
                 break;
-            case 257 /* SyntaxKind.LabeledStatement */:
+            case 258 /* SyntaxKind.LabeledStatement */:
                 if (node instanceof LabeledStatement)
                     return this.visitLabeledStatement(node);
                 break;
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 249 /* SyntaxKind.ForStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 return this.visitWithFacts(node, 0 /* HierarchyFacts.None */, 2 /* HierarchyFacts.IterationContainer */);
-            case 251 /* SyntaxKind.ForOfStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
                 if (node instanceof ForInOrOfStatement)
                     return this.visitForOfStatement(node, undefined);
                 break;
-            case 220 /* SyntaxKind.ArrowFunction */:
+            case 221 /* SyntaxKind.ArrowFunction */:
                 return this.visitWithFacts(node, 2 /* HierarchyFacts.IterationContainer */, 0 /* HierarchyFacts.None */);
-            case 177 /* SyntaxKind.Constructor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 return this.visitWithFacts(node, 2 /* HierarchyFacts.IterationContainer */, 1 /* HierarchyFacts.HasLexicalThis */);
         }
         return this.visitEachChild(node);

package/dist/api/compiler/transformers/import-elision.js

@@ -15,7 +15,7 @@ export class ImportElision extends Transformer {
     visit(node) {
         const factory = this.factory;
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 if (node instanceof SourceFile) {
                     const original = this.context.mostOriginal(node);
                     if (original instanceof SourceFile)
@@ -27,9 +27,9 @@ export class ImportElision extends Transformer {
                     return result;
                 }
                 break;
-            case 272 /* SyntaxKind.ImportEqualsDeclaration */:
+            case 273 /* SyntaxKind.ImportEqualsDeclaration */:
                 if (node instanceof ImportEqualsDeclaration) {
-                    const keep = node.moduleReference.kind === 284 /* SyntaxKind.ExternalModuleReference */
+                    const keep = node.moduleReference.kind === 285 /* SyntaxKind.ExternalModuleReference */
                         ? this.shouldEmitAliasDeclaration(node)
                         : this.shouldEmitAliasDeclaration(node) ||
                             (this.currentSourceFile !== undefined &&
@@ -38,7 +38,7 @@ export class ImportElision extends Transformer {
                     return keep ? this.visitEachChild(node) : undefined;
                 }
                 break;
-            case 273 /* SyntaxKind.ImportDeclaration */:
+            case 274 /* SyntaxKind.ImportDeclaration */:
                 if (node instanceof ImportDeclaration) {
                     if (node.importClause === undefined)
                         return this.visitEachChild(node);
@@ -49,7 +49,7 @@ export class ImportElision extends Transformer {
                     return factory.updateImportDeclaration(node, node.modifiers, importClause, node.moduleSpecifier, this.importAttributes(node.attributes));
                 }
                 break;
-            case 274 /* SyntaxKind.ImportClause */:
+            case 275 /* SyntaxKind.ImportClause */:
                 if (node instanceof ImportClause) {
                     const name = this.shouldEmitAliasDeclaration(node) ? node.name : undefined;
                     const bindings = this.visitNode(node.namedBindings);
@@ -58,23 +58,23 @@ export class ImportElision extends Transformer {
                     return factory.updateImportClause(node, node.phaseModifier, name, bindings);
                 }
                 break;
-            case 275 /* SyntaxKind.NamespaceImport */:
-            case 277 /* SyntaxKind.ImportSpecifier */:
+            case 276 /* SyntaxKind.NamespaceImport */:
+            case 278 /* SyntaxKind.ImportSpecifier */:
                 return this.shouldEmitAliasDeclaration(node) ? node : undefined;
-            case 276 /* SyntaxKind.NamedImports */:
+            case 277 /* SyntaxKind.NamedImports */:
                 if (node instanceof NamedImports) {
                     const elements = this.visitNodes(node.elements);
                     return elements.nodes.length === 0 ? undefined : factory.updateNamedImports(node, elements);
                 }
                 break;
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 if (node instanceof ExportAssignment) {
                     if (this.options.verbatimModuleSyntax !== true && !this.isValueAliasDeclaration(node))
                         return undefined;
                     return this.visitEachChild(node);
                 }
                 break;
-            case 279 /* SyntaxKind.ExportDeclaration */:
+            case 280 /* SyntaxKind.ExportDeclaration */:
                 if (node instanceof ExportDeclaration) {
                     let clause = undefined;
                     if (node.exportClause !== undefined) {
@@ -85,16 +85,16 @@ export class ImportElision extends Transformer {
                     return factory.updateExportDeclaration(node, undefined, false, clause, this.visitNode(node.moduleSpecifier), this.importAttributes(node.attributes));
                 }
                 break;
-            case 280 /* SyntaxKind.NamedExports */:
+            case 281 /* SyntaxKind.NamedExports */:
                 if (node instanceof NamedExports) {
                     const elements = this.visitNodes(node.elements);
                     return elements.nodes.length === 0 ? undefined : factory.updateNamedExports(node, elements);
                 }
                 break;
-            case 282 /* SyntaxKind.ExportSpecifier */:
+            case 283 /* SyntaxKind.ExportSpecifier */:
                 return this.isValueAliasDeclaration(node) ? node : undefined;
-            case 268 /* SyntaxKind.ModuleDeclaration */:
-            case 269 /* SyntaxKind.ModuleBlock */:
+            case 269 /* SyntaxKind.ModuleDeclaration */:
+            case 270 /* SyntaxKind.ModuleBlock */:
                 return this.visitEachChild(node);
         }
         return node;

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

@@ -1,6 +1,6 @@
 // Transforms JSX into calls of the JSX factory (`jsx: react`) or of the automatic runtime
 // (`react-jsx`, `react-jsxdev`), importing the runtime's functions.
-import { BindingElement, BindingPattern, Identifier, ImportClause, ImportDeclaration, ImportSpecifier, JsxAttribute, JsxExpression, JsxNamespacedName, JsxSpreadAttribute, JsxText, ModuleDeclaration, NamedImports, ObjectLiteralExpression, PropertyAssignment, QualifiedName, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, ArrayLiteralExpression, getTagName, } from '../ast.js';
+import { BindingElement, BindingPattern, Identifier, ImportClause, ImportDeclaration, ImportSpecifier, JsxAttribute, JsxExpression, JsxNamespacedName, JsxSpreadAttribute, JsxText, ModuleDeclaration, NamedImports, ObjectLiteralExpression, PropertyAssignment, QualifiedName, SourceFile, SpreadAssignment, SpreadElement, StringLiteral, ArrayLiteralExpression, getTagName, getText, } from '../ast.js';
 import { isExternalOrCommonJSModule } from '../binder-utilities.js';
 import { isLineBreak, isWhiteSpaceSingleLine } from '../character-codes.js';
 import { JsxEmit, ScriptTarget, getEmitScriptTarget } from '../options.js';
@@ -53,19 +53,19 @@ export class JsxTransformer extends Transformer {
         if (!this.facts.has(node, 2 /* SubtreeFacts.ContainsJsx */))
             return node;
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 this.inChild = false;
                 return this.visitSourceFile(node);
-            case 285 /* SyntaxKind.JsxElement */:
+            case 286 /* SyntaxKind.JsxElement */:
                 return this.visitJsxElement(node);
-            case 286 /* SyntaxKind.JsxSelfClosingElement */:
+            case 287 /* SyntaxKind.JsxSelfClosingElement */:
                 return this.visitJsxSelfClosingElement(node);
-            case 289 /* SyntaxKind.JsxFragment */:
+            case 290 /* SyntaxKind.JsxFragment */:
                 return this.visitJsxFragment(node);
             case 11 /* SyntaxKind.JsxText */:
                 this.inChild = false;
                 return this.visitJsxText(node);
-            case 295 /* SyntaxKind.JsxExpression */:
+            case 296 /* SyntaxKind.JsxExpression */:
                 this.inChild = false;
                 return this.visitJsxExpression(node);
         }
@@ -119,7 +119,7 @@ export class JsxTransformer extends Transformer {
             specifiers[i].parent = named;
         const clause = factory.created(new ImportClause(undefined, undefined, named));
         named.parent = clause;
-        const declaration = factory.created(new ImportDeclaration(273 /* SyntaxKind.ImportDeclaration */, undefined, clause, factory.createStringLiteral(imports.source, 0 /* TokenFlags.None */), undefined));
+        const declaration = factory.created(new ImportDeclaration(274 /* SyntaxKind.ImportDeclaration */, undefined, clause, factory.createStringLiteral(imports.source, 0 /* TokenFlags.None */), undefined));
         clause.parent = declaration;
         return declaration;
     }
@@ -130,7 +130,7 @@ export class JsxTransformer extends Transformer {
         const elements = [];
         for (let i = 0; i < specifiers.length; i++)
             elements.push(factory.created(new BindingElement(undefined, specifiers[i].propertyName, specifiers[i].name, undefined)));
-        const pattern = factory.created(new BindingPattern(207 /* SyntaxKind.ObjectBindingPattern */, factory.createNodeList(elements)));
+        const pattern = factory.created(new BindingPattern(208 /* SyntaxKind.ObjectBindingPattern */, factory.createNodeList(elements)));
         const require = factory.createCallExpression(factory.createIdentifier('require'), [
             factory.createStringLiteral(imports.source, 0 /* TokenFlags.None */),
         ]);
@@ -412,9 +412,9 @@ export class JsxTransformer extends Transformer {
                 return factory.createTrue();
             return this.visit(node.expression);
         }
-        if (node.kind === 285 /* SyntaxKind.JsxElement */ ||
-            node.kind === 286 /* SyntaxKind.JsxSelfClosingElement */ ||
-            node.kind === 289 /* SyntaxKind.JsxFragment */) {
+        if (node.kind === 286 /* SyntaxKind.JsxElement */ ||
+            node.kind === 287 /* SyntaxKind.JsxSelfClosingElement */ ||
+            node.kind === 290 /* SyntaxKind.JsxFragment */) {
             this.inChild = false;
             return this.visit(node);
         }
@@ -436,7 +436,7 @@ export class JsxTransformer extends Transformer {
     expressionFromEntityName(entity, parent) {
         if (entity instanceof QualifiedName) {
             const left = this.expressionFromEntityName(entity.left, parent);
-            return this.factory.createPropertyAccessExpression(left, this.factory.createIdentifier(entity.right.text));
+            return this.factory.createPropertyAccessExpression(left, this.factory.createIdentifier(getText(entity.right)));
         }
         return this.createReactNamespace(entity.text, parent);
     }