tsc-ts 0.0.10 → 0.1.0

package/dist/api/compiler/transformers/class-fields.js

@@ -222,7 +222,7 @@ export class ClassFieldsTransformer extends Transformer {
     /** Whether an auto-accessor, a `#x in` check or a private access needs WeakMaps and WeakSets. */
     requiresBlockScopedVar() {
         const container = this.currentClassContainer;
-        return this.inIterationStatement && container !== undefined && container.kind === 232 /* SyntaxKind.ClassExpression */;
+        return this.inIterationStatement && container !== undefined && container.kind === 233 /* SyntaxKind.ClassExpression */;
     }
     /** Whether a class expression's temporary is block scoped: it's in a loop and has an instance field with a computed name. */
     classExpressionNeedsBlockScopedTemp() {
@@ -272,7 +272,7 @@ export class ClassFieldsTransformer extends Transformer {
         if (node instanceof Identifier)
             return this.visitIdentifier(node);
         if (node instanceof PropertyAccessExpression && node.name instanceof Identifier)
-            return this.visitPropertyAccessExpressionForSubstitution(node);
+            return this.visitPropertyAccessExpressionForSubstitution(node, this.substitutionMode);
         return this.substitutionMode.visitEachChild(node);
     }
     visit(node) {
@@ -291,58 +291,58 @@ export class ClassFieldsTransformer extends Transformer {
             return node;
         }
         switch (node.kind) {
-            case 307 /* SyntaxKind.SourceFile */:
+            case 308 /* SyntaxKind.SourceFile */:
                 return this.visitSourceFile(node);
-            case 264 /* SyntaxKind.ClassDeclaration */:
-            case 232 /* SyntaxKind.ClassExpression */:
+            case 265 /* SyntaxKind.ClassDeclaration */:
+            case 233 /* SyntaxKind.ClassExpression */:
                 return this.visitClassLike(node);
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */:
-            case 173 /* SyntaxKind.PropertyDeclaration */:
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */:
+            case 174 /* SyntaxKind.PropertyDeclaration */:
                 throw new Error('Class elements are visited in class element mode');
-            case 303 /* SyntaxKind.PropertyAssignment */:
-            case 261 /* SyntaxKind.VariableDeclaration */:
-            case 170 /* SyntaxKind.Parameter */:
-            case 209 /* SyntaxKind.BindingElement */:
+            case 304 /* SyntaxKind.PropertyAssignment */:
+            case 262 /* SyntaxKind.VariableDeclaration */:
+            case 171 /* SyntaxKind.Parameter */:
+            case 210 /* SyntaxKind.BindingElement */:
                 return this.visitEachChild(this.transformNamedEvaluationIfNeeded(node, ''));
-            case 244 /* SyntaxKind.VariableStatement */:
+            case 245 /* SyntaxKind.VariableStatement */:
                 return this.visitVariableStatement(node);
-            case 278 /* SyntaxKind.ExportAssignment */:
+            case 279 /* SyntaxKind.ExportAssignment */:
                 return this.visitExportAssignment(node);
             case 80 /* SyntaxKind.PrivateIdentifier */:
                 return this.visitPrivateIdentifier(node);
-            case 212 /* SyntaxKind.PropertyAccessExpression */:
+            case 213 /* SyntaxKind.PropertyAccessExpression */:
                 return this.visitPropertyAccessExpression(node);
-            case 213 /* SyntaxKind.ElementAccessExpression */:
+            case 214 /* SyntaxKind.ElementAccessExpression */:
                 return this.visitElementAccessExpression(node);
-            case 225 /* SyntaxKind.PrefixUnaryExpression */:
-            case 226 /* SyntaxKind.PostfixUnaryExpression */:
+            case 226 /* SyntaxKind.PrefixUnaryExpression */:
+            case 227 /* SyntaxKind.PostfixUnaryExpression */:
                 return this.visitPreOrPostfixUnaryExpression(node, false);
-            case 227 /* SyntaxKind.BinaryExpression */:
+            case 228 /* SyntaxKind.BinaryExpression */:
                 return this.visitBinaryExpression(node, false);
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 return this.factory.updateParenthesizedExpression(node, this.visitNode(node.expression));
-            case 214 /* SyntaxKind.CallExpression */:
+            case 215 /* SyntaxKind.CallExpression */:
                 return this.visitCallExpression(node);
-            case 245 /* SyntaxKind.ExpressionStatement */:
+            case 246 /* SyntaxKind.ExpressionStatement */:
                 return this.visitExpressionStatement(node);
-            case 216 /* SyntaxKind.TaggedTemplateExpression */:
+            case 217 /* SyntaxKind.TaggedTemplateExpression */:
                 return this.visitTaggedTemplateExpression(node);
-            case 249 /* SyntaxKind.ForStatement */:
+            case 250 /* SyntaxKind.ForStatement */:
                 return this.visitForStatement(node);
-            case 250 /* SyntaxKind.ForInStatement */:
-            case 251 /* SyntaxKind.ForOfStatement */:
-            case 247 /* SyntaxKind.DoStatement */:
-            case 248 /* SyntaxKind.WhileStatement */:
+            case 251 /* SyntaxKind.ForInStatement */:
+            case 252 /* SyntaxKind.ForOfStatement */:
+            case 248 /* SyntaxKind.DoStatement */:
+            case 249 /* SyntaxKind.WhileStatement */:
                 return this.visitInIteration(node, true);
             case 109 /* SyntaxKind.ThisKeyword */:
                 return this.visitThisExpression(node);
-            case 263 /* SyntaxKind.FunctionDeclaration */:
-            case 219 /* SyntaxKind.FunctionExpression */:
+            case 264 /* SyntaxKind.FunctionDeclaration */:
+            case 220 /* SyntaxKind.FunctionExpression */:
                 return this.visitFunctionExpressionOrDeclaration(node);
-            case 177 /* SyntaxKind.Constructor */:
-            case 175 /* SyntaxKind.MethodDeclaration */:
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
+            case 178 /* SyntaxKind.Constructor */:
+            case 176 /* SyntaxKind.MethodDeclaration */:
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
                 return this.visitInClassElement(node);
         }
         return this.visitEachChild(node);
@@ -393,12 +393,12 @@ export class ClassFieldsTransformer extends Transformer {
     }
     visitDiscardedValue(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 */:
                 return this.visitBinaryExpression(node, true);
-            case 218 /* SyntaxKind.ParenthesizedExpression */:
+            case 219 /* SyntaxKind.ParenthesizedExpression */:
                 return this.factory.updateParenthesizedExpression(node, this.discarded.visitNode(node.expression));
         }
         return this.visit(node);
@@ -412,7 +412,7 @@ export class ClassFieldsTransformer extends Transformer {
     }
     visitClassElement(node) {
         switch (node.kind) {
-            case 177 /* SyntaxKind.Constructor */: {
+            case 178 /* SyntaxKind.Constructor */: {
                 const saved = this.currentClassElement;
                 this.currentClassElement = node;
                 const container = this.currentClassContainer;
@@ -422,35 +422,35 @@ export class ClassFieldsTransformer extends Transformer {
                 this.currentClassElement = saved;
                 return result;
             }
-            case 178 /* SyntaxKind.GetAccessor */:
-            case 179 /* SyntaxKind.SetAccessor */:
-            case 175 /* SyntaxKind.MethodDeclaration */: {
+            case 179 /* SyntaxKind.GetAccessor */:
+            case 180 /* SyntaxKind.SetAccessor */:
+            case 176 /* SyntaxKind.MethodDeclaration */: {
                 const saved = this.currentClassElement;
                 this.currentClassElement = node;
                 const result = this.visitMethodOrAccessorDeclaration(node);
                 this.currentClassElement = saved;
                 return result;
             }
-            case 173 /* SyntaxKind.PropertyDeclaration */: {
+            case 174 /* SyntaxKind.PropertyDeclaration */: {
                 const saved = this.currentClassElement;
                 this.currentClassElement = node;
                 const result = this.visitPropertyDeclaration(node);
                 this.currentClassElement = saved;
                 return result;
             }
-            case 176 /* SyntaxKind.ClassStaticBlockDeclaration */: {
+            case 177 /* SyntaxKind.ClassStaticBlockDeclaration */: {
                 const saved = this.currentClassElement;
                 this.currentClassElement = node;
                 const result = this.shouldTransformPrivateElementsOrClassStaticBlocks ? undefined : this.visitEachChild(node);
                 this.currentClassElement = saved;
                 return result;
             }
-            case 168 /* SyntaxKind.ComputedPropertyName */:
+            case 169 /* SyntaxKind.ComputedPropertyName */:
                 return this.visitComputedPropertyName(node);
-            case 241 /* SyntaxKind.SemicolonClassElement */:
+            case 242 /* SyntaxKind.SemicolonClassElement */:
                 return node;
         }
-        if (isModifier(node) || node.kind === 171 /* SyntaxKind.Decorator */)
+        if (isModifier(node) || node.kind === 172 /* SyntaxKind.Decorator */)
             return this.visitModifier(node);
         return this.visit(node);
     }
@@ -520,7 +520,7 @@ export class ClassFieldsTransformer extends Transformer {
             return false;
         for (let i = 0; i < statics.length; i++) {
             const member = statics[i];
-            if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+            if (member.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
                 isPrivateIdentifierClassElementDeclaration(member) ||
                 (this.shouldTransformInitializers && isInitializedProperty(member)))
                 return true;
@@ -594,10 +594,11 @@ export class ClassFieldsTransformer extends Transformer {
     visitMethodOrAccessorDeclaration(node) {
         if (!isPrivateIdentifierClassElementDeclaration(node) || !this.shouldTransformClassElementToWeakMap(node))
             return this.classElementMode.visitEachChild(node);
-        const info = this.accessPrivateIdentifier(getName(node));
+        // The member's own class declares it; an untransformed or duplicate name leaves the member as written.
+        const info = this.getPrivateIdentifier(this.getPrivateEnvironment(), getName(node));
         if (info === undefined)
             throw new Error('Undeclared private name for property declaration.');
-        if (!info.isValid)
+        if (info.kind === 3 /* PrivateKind.Untransformed */ || !info.isValid)
             return node;
         const functionName = this.getHoistedFunctionName(node, info);
         if (functionName !== undefined) {
@@ -619,9 +620,9 @@ export class ClassFieldsTransformer extends Transformer {
         if (info.kind === 1 /* PrivateKind.Method */)
             return info.methodName;
         if (info.kind === 2 /* PrivateKind.Accessor */) {
-            if (node.kind === 178 /* SyntaxKind.GetAccessor */)
+            if (node.kind === 179 /* SyntaxKind.GetAccessor */)
                 return info.getterName;
-            if (node.kind === 179 /* SyntaxKind.SetAccessor */)
+            if (node.kind === 180 /* SyntaxKind.SetAccessor */)
                 return info.setterName;
         }
         return undefined;
@@ -692,10 +693,10 @@ export class ClassFieldsTransformer extends Transformer {
         const factory = this.factory;
         if (this.shouldTransformClassElementToWeakMap(node)) {
             // Fields become WeakMaps: the declaration goes.
-            const info = this.accessPrivateIdentifier(node.name);
+            const info = this.getPrivateIdentifier(this.getPrivateEnvironment(), node.name);
             if (info === undefined)
                 throw new Error('Undeclared private name for property declaration.');
-            if (!info.isValid)
+            if (info.kind === 3 /* PrivateKind.Untransformed */ || !info.isValid)
                 return node;
             // A static field of a class whose static blocks stay becomes a static block.
             if (info.isStatic && !this.shouldTransformPrivateElementsOrClassStaticBlocks) {
@@ -810,11 +811,12 @@ export class ClassFieldsTransformer extends Transformer {
         }
         // Property names are not references and are never substituted.
         if (node.name instanceof Identifier)
-            return this.visitPropertyAccessExpressionForSubstitution(node);
+            return this.visitPropertyAccessExpressionForSubstitution(node, this);
         return this.visitEachChild(node);
     }
-    visitPropertyAccessExpressionForSubstitution(node) {
-        const expression = this.visitNode(node.expression);
+    /** Visits only the expression of a property access, with `visitor`, so that its name is never substituted. */
+    visitPropertyAccessExpressionForSubstitution(node, visitor) {
+        const expression = visitor.visitNode(node.expression);
         if (expression === node.expression)
             return node;
         return this.factory.updatePropertyAccessExpression(node, expression, node.questionDotToken, node.name, node.flags);
@@ -1379,12 +1381,11 @@ export class ClassFieldsTransformer extends Transformer {
         }
         const statics = staticPropertiesAndClassStaticBlocks(node);
         // Aliases must be known before visiting members, so predict whether a temporary will wrap the class.
+        const hasTransformableStatics = this.hasTransformableStatics(node, statics);
         let isClassWithConstructorReference = false;
-        let hasTransformableStatics = false;
         let deferTempDeclaration = false;
         if (!isDecoratedClassDeclaration) {
             isClassWithConstructorReference = this.classContainsConstructorReference(node);
-            hasTransformableStatics = this.hasTransformableStatics(node, statics);
             let willHavePrivatePendingExpressions = false;
             if (this.shouldTransformPrivateElementsOrClassStaticBlocks) {
                 const members = node.members.nodes;
@@ -1441,7 +1442,7 @@ export class ClassFieldsTransformer extends Transformer {
             else
                 expressions.push(classExpression);
         }
-        else {
+        else if (hasTransformableStatics || this.pendingExpressions.length > 0) {
             for (let i = 0; i < this.pendingExpressions.length; i++)
                 this.pendingStatements.push(factory.createExpressionStatement(this.pendingExpressions[i]));
             if (statics.length > 0) {
@@ -1455,6 +1456,8 @@ export class ClassFieldsTransformer extends Transformer {
             else
                 expressions.push(classExpression);
         }
+        else
+            expressions.push(classExpression);
         if (expressions.length > 1) {
             context.addEmitFlags(classExpression, 8192 /* EmitFlags.Indented */);
             for (let i = 0; i < expressions.length; i++)
@@ -1527,7 +1530,7 @@ export class ClassFieldsTransformer extends Transformer {
         let syntheticConstructor = undefined;
         let hasConstructor = false;
         for (let i = 0; i < members.nodes.length; i++)
-            if (members.nodes[i].kind === 177 /* SyntaxKind.Constructor */)
+            if (members.nodes[i].kind === 178 /* SyntaxKind.Constructor */)
                 hasConstructor = true;
         if (!hasConstructor)
             syntheticConstructor = this.transformConstructor(undefined, node);
@@ -1948,14 +1951,14 @@ export class ClassFieldsTransformer extends Transformer {
             info.setterName = this.createHoistedVariableForPrivateName(name, '_set');
             this.setPrivateIdentifier(environment, name, info);
         }
-        else if (node.kind === 175 /* SyntaxKind.MethodDeclaration */) {
+        else if (node.kind === 176 /* SyntaxKind.MethodDeclaration */) {
             const methodName = this.createHoistedVariableForPrivateName(name, '');
             const info = new PrivateIdentifierInfo(1 /* PrivateKind.Method */, brandCheck, isStaticMember, isValid);
             info.methodName = methodName;
             this.setPrivateIdentifier(environment, name, info);
         }
         else {
-            const getter = node.kind === 178 /* SyntaxKind.GetAccessor */;
+            const getter = node.kind === 179 /* SyntaxKind.GetAccessor */;
             const accessorName = this.createHoistedVariableForPrivateName(name, getter ? '_get' : '_set');
             // A get and set accessor pair shares one entry.
             if (previous !== undefined &&
@@ -2083,7 +2086,7 @@ export class ClassFieldsTransformer extends Transformer {
                     return this.factory.updateSpreadElement(node, this.visitDestructuringAssignmentTarget(node.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);
@@ -2203,8 +2206,8 @@ function isSuperProperty(node) {
     return false;
 }
 function isStaticPropertyDeclarationOrClassStaticBlock(node) {
-    return (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
-        (node.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(node)));
+    return (node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+        (node.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(node)));
 }
 function isCompoundAssignment(kind) {
     return kind >= 64 /* SyntaxKind.FirstCompoundAssignment */ && kind <= 78 /* SyntaxKind.LastCompoundAssignment */;
@@ -2252,7 +2255,7 @@ function isSimpleCopiableExpression(node) {
         case 79 /* SyntaxKind.Identifier */:
             return true;
     }
-    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 166 /* SyntaxKind.LastKeyword */;
+    return node.kind >= 82 /* SyntaxKind.FirstKeyword */ && node.kind <= 167 /* SyntaxKind.LastKeyword */;
 }
 /** A literal or keyword that can be repeated; identifiers may be reassigned in between. */
 function isSimpleInlineableExpression(node) {
@@ -2271,14 +2274,14 @@ function shouldBeCapturedInTempVariable(node) {
 }
 function isArrayBindingOrAssignmentElement(node) {
     switch (node.kind) {
-        case 209 /* SyntaxKind.BindingElement */:
-        case 233 /* SyntaxKind.OmittedExpression */:
-        case 231 /* SyntaxKind.SpreadElement */:
-        case 210 /* SyntaxKind.ArrayLiteralExpression */:
-        case 211 /* SyntaxKind.ObjectLiteralExpression */:
+        case 210 /* SyntaxKind.BindingElement */:
+        case 234 /* SyntaxKind.OmittedExpression */:
+        case 232 /* SyntaxKind.SpreadElement */:
+        case 211 /* SyntaxKind.ArrayLiteralExpression */:
+        case 212 /* SyntaxKind.ObjectLiteralExpression */:
         case 79 /* SyntaxKind.Identifier */:
-        case 212 /* SyntaxKind.PropertyAccessExpression */:
-        case 213 /* SyntaxKind.ElementAccessExpression */:
+        case 213 /* SyntaxKind.PropertyAccessExpression */:
+        case 214 /* SyntaxKind.ElementAccessExpression */:
             return true;
     }
     return isAssignmentExpression(node, true);
@@ -2288,8 +2291,8 @@ function staticPropertiesAndClassStaticBlocks(node) {
     const members = membersOf(node);
     for (let i = 0; i < members.length; i++) {
         const member = members[i];
-        if (member.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
-            (member.kind === 173 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(member)))
+        if (member.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */ ||
+            (member.kind === 174 /* SyntaxKind.PropertyDeclaration */ && hasStaticModifier(member)))
             result.push(member);
     }
     return result;
@@ -2333,7 +2336,7 @@ function getClassExtendsHeritageElement(node) {
 }
 /** Whether a class or its constructor's parameters have decorators that apply. */
 function classOrConstructorParameterIsDecorated(legacy, node) {
-    if (hasDecorators(node) && (node.kind === 264 /* SyntaxKind.ClassDeclaration */ || !legacy))
+    if (hasDecorators(node) && (node.kind === 265 /* SyntaxKind.ClassDeclaration */ || !legacy))
         return true;
     if (!legacy)
         return false;
@@ -2381,7 +2384,7 @@ function posPastModifiers(node) {
         return node.name.pos;
     if (node instanceof MethodDeclaration)
         return node.name.pos;
-    if (node.kind === 176 /* SyntaxKind.ClassStaticBlockDeclaration */)
+    if (node.kind === 177 /* SyntaxKind.ClassStaticBlockDeclaration */)
         return node.pos;
     const modifiers = getModifiers(node);
     if (modifiers === undefined || modifiers.nodes.length === 0)
@@ -2390,7 +2393,7 @@ function posPastModifiers(node) {
     if (last.end >= 0)
         return last.end;
     for (let i = modifiers.nodes.length - 1; i >= 0; i--)
-        if (modifiers.nodes[i].kind === 171 /* SyntaxKind.Decorator */)
+        if (modifiers.nodes[i].kind === 172 /* SyntaxKind.Decorator */)
             return modifiers.nodes[i].end >= 0 ? modifiers.nodes[i].end : node.pos;
     return node.pos;
 }

package/dist/api/compiler/transformers/commonjs-module.js

@@ -135,8 +135,10 @@ export class CommonJSModuleTransformer extends Transformer {
             const statement = nested.visitStatement(node.statement);
             return factory.updateLabeledStatement(node, node.label, statement !== undefined ? statement : factory.created(new EmptyStatement()));
         }
-        if (node instanceof WithStatement)
-            return factory.updateWithStatement(node, this.visitNode(node.expression), nested.visitStatement(node.statement));
+        if (node instanceof WithStatement) {
+            const statement = nested.visitStatement(node.statement);
+            return factory.updateWithStatement(node, this.visitNode(node.expression), statement !== undefined ? statement : factory.created(new EmptyStatement()));
+        }
         if (node instanceof IfStatement) {
             const thenStatement = nested.visitStatement(node.thenStatement);
             return factory.updateIfStatement(node, this.visitNode(node.expression), thenStatement !== undefined ? thenStatement : factory.createBlock([], false), nested.visitStatement(node.elseStatement));
@@ -160,9 +162,9 @@ export class CommonJSModuleTransformer extends Transformer {
         if (node instanceof SourceFile)
             return this.visitSourceFile(node);
         if (node instanceof ForStatement)
-            return this.factory.updateForStatement(node, this.discarded.visitNode(node.initializer), this.visitNode(node.condition), this.discarded.visitNode(node.incrementor), this.topLevelNested.visitIterationBody(node.statement));
+            return this.factory.updateForStatement(node, this.discarded.visitNode(node.initializer), this.visitNode(node.condition), this.discarded.visitNode(node.incrementor), this.visitIterationBody(node.statement));
         if (node instanceof ForInOrOfStatement)
-            return this.factory.updateForInOrOfStatement(node, node.awaitModifier, this.discarded.visitNode(node.initializer), this.visitNode(node.expression), this.topLevelNested.visitIterationBody(node.statement));
+            return this.factory.updateForInOrOfStatement(node, node.awaitModifier, this.discarded.visitNode(node.initializer), this.visitNode(node.expression), this.visitIterationBody(node.statement));
         if (node instanceof ExpressionStatement || node instanceof VoidExpression)
             return this.discarded.visitEachChild(node);
         if (node instanceof ParenthesizedExpression)
@@ -199,7 +201,7 @@ export class CommonJSModuleTransformer extends Transformer {
     shouldEmitUnderscoreUnderscoreESModule(file) {
         if (fileExtensionIsOneOf(file.fileName, supportedJSExtensions) &&
             file.commonJSModuleIndicator !== undefined &&
-            (file.externalModuleIndicator === undefined || file.externalModuleIndicator.kind === 307 /* SyntaxKind.SourceFile */))
+            (file.externalModuleIndicator === undefined || file.externalModuleIndicator.kind === 308 /* SyntaxKind.SourceFile */))
             return false;
         return this.moduleInfo().exportEquals === undefined && isExternalModule(file);
     }
@@ -312,9 +314,9 @@ export class CommonJSModuleTransformer extends Transformer {
         if (clause.name !== undefined)
             this.appendExportsOfDeclaration(statements, clause, seen, false);
         const bindings = clause.namedBindings;
-        if (bindings !== undefined && bindings.kind === 275 /* SyntaxKind.NamespaceImport */)
+        if (bindings !== undefined && bindings.kind === 276 /* SyntaxKind.NamespaceImport */)
             this.appendExportsOfDeclaration(statements, bindings, seen, false);
-        else if (bindings !== undefined && bindings.kind === 276 /* SyntaxKind.NamedImports */) {
+        else if (bindings !== undefined && bindings.kind === 277 /* SyntaxKind.NamedImports */) {
             const elements = bindingElementsOf(bindings);
             for (let i = 0; i < elements.length; i++)
                 this.appendExportsOfDeclaration(statements, elements[i], seen, true);
@@ -338,7 +340,7 @@ export class CommonJSModuleTransformer extends Transformer {
         if (name instanceof BindingPattern) {
             const elements = name.elements.nodes;
             for (let i = 0; i < elements.length; i++)
-                if (elements[i].kind !== 233 /* SyntaxKind.OmittedExpression */)
+                if (elements[i].kind !== 234 /* SyntaxKind.OmittedExpression */)
                     this.appendExportsOfBindingElement(statements, elements[i], isForInOrOfInitializer);
             return true;
         }
@@ -737,9 +739,9 @@ export class CommonJSModuleTransformer extends Transformer {
                     if (this.destructuringNeedsFlattening(element.expression))
                         return true;
                 }
-                else if (element.kind === 175 /* SyntaxKind.MethodDeclaration */ ||
-                    element.kind === 178 /* SyntaxKind.GetAccessor */ ||
-                    element.kind === 179 /* SyntaxKind.SetAccessor */)
+                else if (element.kind === 176 /* SyntaxKind.MethodDeclaration */ ||
+                    element.kind === 179 /* SyntaxKind.GetAccessor */ ||
+                    element.kind === 180 /* SyntaxKind.SetAccessor */)
                     return false;
             }
             return false;
@@ -862,7 +864,8 @@ export class CommonJSModuleTransformer extends Transformer {
     visitCallExpression(node) {
         const rewrite = this.options.rewriteRelativeImportExtensions === true &&
             ((isImportCall(node) && node.arguments.nodes.length > 0) || (isInJSFile(node) && isRequireCall(node, false)));
-        if (isImportCall(node) && this.shouldTransformImportCall())
+        // `import.source()` and the other phase imports stay as written.
+        if (node.expression.kind === 101 /* SyntaxKind.ImportKeyword */ && this.shouldTransformImportCall())
             return this.visitImportCallExpression(node, rewrite);
         if (rewrite)
             return this.rewriteImportOrRequireCall(node);
@@ -929,13 +932,13 @@ export class CommonJSModuleTransformer extends Transformer {
         let args = node.arguments;
         const nodes = args.nodes;
         if (nodes.length > 0) {
-            const first = nodes[0];
+            const first = this.visitNode(nodes[0]);
             const rewritten = first instanceof StringLiteral || first.kind === 14 /* SyntaxKind.NoSubstitutionTemplateLiteral */
                 ? rewriteModuleSpecifier(this.context, first, this.options)
                 : factory.createRewriteRelativeImportExtensionsHelper(first, this.options.jsx === JsxEmit.Preserve);
             const rest = nodes.slice(1);
             const visitedRest = this.visitArray(rest);
-            if (rewritten !== first || visitedRest !== rest)
+            if (rewritten !== nodes[0] || visitedRest !== rest)
                 args = new NodeList(args.pos, args.end, [rewritten].concat(visitedRest));
         }
         return factory.updateCallExpression(node, expression, callQuestionDotToken(node), undefined, args, node.flags);
@@ -1157,7 +1160,7 @@ function isDeclarationNameOfEnumOrNamespace(original) {
     const parent = original.parent;
     if (parent === undefined)
         return false;
-    if (parent.kind !== 267 /* SyntaxKind.EnumDeclaration */ && parent.kind !== 268 /* SyntaxKind.ModuleDeclaration */)
+    if (parent.kind !== 268 /* SyntaxKind.EnumDeclaration */ && parent.kind !== 269 /* SyntaxKind.ModuleDeclaration */)
         return false;
     return getName(parent) === original;
 }

package/dist/api/compiler/transformers/const-enum-inliner.js

@@ -11,7 +11,7 @@ export class ConstEnumInliner extends Transformer {
         this.resolver = resolver;
     }
     visit(node) {
-        if (node.kind !== 212 /* SyntaxKind.PropertyAccessExpression */ && node.kind !== 213 /* SyntaxKind.ElementAccessExpression */)
+        if (node.kind !== 213 /* SyntaxKind.PropertyAccessExpression */ && node.kind !== 214 /* SyntaxKind.ElementAccessExpression */)
             return this.visitEachChild(node);
         const parseNode = this.context.parseNode(node);
         if (parseNode === undefined)