Added ExportSpecifierTransformer. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/791

src/JavaScriptObfuscator.ts

@@ -70,6 +70,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.DeadCodeInjectionTransformer,
         NodeTransformer.EscapeSequenceTransformer,
         NodeTransformer.EvalCallExpressionTransformer,
+        NodeTransformer.ExportSpecifierTransformer,
         NodeTransformer.ExpressionStatementsMergeTransformer,
         NodeTransformer.FunctionControlFlowTransformer,
         NodeTransformer.IfStatementSimplifyTransformer,

src/container/modules/node-transformers/ConvertingTransformersModule.ts

@@ -10,6 +10,7 @@ import { ObjectExpressionExtractor } from '../../../enums/node-transformers/conv
 
 import { BasePropertiesExtractor } from '../../../node-transformers/converting-transformers/object-expression-extractors/BasePropertiesExtractor';
 import { BooleanLiteralTransformer } from '../../../node-transformers/converting-transformers/BooleanLiteralTransformer';
+import { ExportSpecifierTransformer } from '../../../node-transformers/converting-transformers/ExportSpecifierTransformer';
 import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
 import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
 import { NumberLiteralTransformer } from '../../../node-transformers/converting-transformers/NumberLiteralTransformer';
@@ -27,6 +28,10 @@ export const convertingTransformersModule: interfaces.ContainerModule = new Cont
         .to(BooleanLiteralTransformer)
         .whenTargetNamed(NodeTransformer.BooleanLiteralTransformer);
 
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ExportSpecifierTransformer)
+        .whenTargetNamed(NodeTransformer.ExportSpecifierTransformer);
+
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(MemberExpressionTransformer)
         .whenTargetNamed(NodeTransformer.MemberExpressionTransformer);

src/enums/node-transformers/NodeTransformer.ts

@@ -7,6 +7,7 @@ export enum NodeTransformer {
     DeadCodeInjectionTransformer = 'DeadCodeInjectionTransformer',
     EscapeSequenceTransformer = 'EscapeSequenceTransformer',
     EvalCallExpressionTransformer = 'EvalCallExpressionTransformer',
+    ExportSpecifierTransformer = 'ExportSpecifierTransformer',
     ExpressionStatementsMergeTransformer = 'ExpressionStatementsMergeTransformer',
     FunctionControlFlowTransformer = 'FunctionControlFlowTransformer',
     IfStatementSimplifyTransformer = 'IfStatementSimplifyTransformer',

src/enums/node/NodeType.ts

@@ -16,6 +16,7 @@ export enum NodeType {
     ContinueStatement = 'ContinueStatement',
     ExportAllDeclaration = 'ExportAllDeclaration',
     ExportNamedDeclaration = 'ExportNamedDeclaration',
+    ExportSpecifier = 'ExportSpecifier',
     ExpressionStatement = 'ExpressionStatement',
     ForStatement = 'ForStatement',
     ForInStatement = 'ForInStatement',

src/node-transformers/converting-transformers/ExportSpecifierTransformer.ts

@@ -0,0 +1,67 @@
+import { inject, injectable, } from 'inversify';
+import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
+
+import * as ESTree from 'estree';
+
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+import { NodeGuards } from '../../node/NodeGuards';
+import { NodeUtils } from '../../node/NodeUtils';
+
+@injectable()
+export class ExportSpecifierTransformer extends AbstractNodeTransformer {
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     */
+    public constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions
+    ) {
+        super(randomGenerator, options);
+    }
+
+    /**
+     * @param {NodeTransformationStage} nodeTransformationStage
+     * @returns {IVisitor | null}
+     */
+    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
+        switch (nodeTransformationStage) {
+            case NodeTransformationStage.Converting:
+                return {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
+                        if (parentNode && NodeGuards.isExportSpecifierNode(node)) {
+                            return this.transformNode(node, parentNode);
+                        }
+                    }
+                };
+
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Replaces:
+     *     export {foo};
+     *
+     * on:
+     *     export {foo as foo};
+     *
+     * @param {ExportSpecifier} exportSpecifierNode
+     * @param {Node} parentNode
+     * @returns {Node}
+     */
+    public transformNode (exportSpecifierNode: ESTree.ExportSpecifier, parentNode: ESTree.Node): ESTree.Node {
+        if (exportSpecifierNode.local.name === exportSpecifierNode.exported.name) {
+            exportSpecifierNode.exported = NodeUtils.clone(exportSpecifierNode.local);
+        }
+
+        return exportSpecifierNode;
+    }
+}

src/node/NodeGuards.ts

@@ -132,6 +132,14 @@ export class NodeGuards {
         return node.type === NodeType.ExportNamedDeclaration;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isExportSpecifierNode (node: ESTree.Node): node is ESTree.ExportSpecifier {
+        return node.type === NodeType.ExportSpecifier;
+    }
+
     /**
      * @param {Node} node
      * @returns {boolean}