Switched `esprima` on `espree`. Obfuscation of `export` declarations

CHANGELOG.md

@@ -2,10 +2,13 @@ Change Log
 ===
 v0.15.0
 ---
+* **Internal change:** switched AST parser from `esprima` on `espree`
 * **Breaking change:** dropped `node@4` and `node@5` support.
 * **Breaking change:** renamed `extension` value of `target` option on `browser-no-eval`.
 * **Breaking change:** disabled generation of identifiers, which being matched by `reservedName` option. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/216
 * **New CLI option:** `exclude` allows to exclude specific files or directories from obfuscation.
+* Correct obfuscation of `import` and `export` declarations.
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/231
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/217
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/210
 * Internal: refactoring of many things.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.15.0-dev.5",
+  "version": "0.15.0-dev.6",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -25,7 +25,7 @@
     "class-validator": "0.8.5",
     "commander": "2.15.1",
     "escodegen-wallaby": "1.6.18",
-    "esprima": "4.0.0",
+    "espree": "3.5.4",
     "estraverse": "4.2.0",
     "inversify": "4.11.1",
     "js-string-escape": "1.0.1",
@@ -47,7 +47,6 @@
     "@types/chai": "4.1.2",
     "@types/chance": "1.0.0",
     "@types/escodegen": "0.0.6",
-    "@types/esprima": "4.0.1",
     "@types/estraverse": "0.0.6",
     "@types/estree": "0.0.38",
     "@types/md5": "2.1.32",
@@ -72,7 +71,7 @@
     "ts-node": "5.0.1",
     "tslint": "5.9.1",
     "tslint-eslint-rules": "5.1.0",
-    "tslint-language-service": "0.9.8",
+    "tslint-language-service": "0.9.9",
     "tslint-webpack-plugin": "1.2.2",
     "typescript": "2.8.0-rc",
     "webpack": "4.2.0",

src/EspreeFacade.ts

@@ -0,0 +1,105 @@
+import * as espree from 'espree';
+import * as ESTree from 'estree';
+
+import chalk, { Chalk } from 'chalk';
+
+/**
+ * Facade over `espree`
+ */
+export class EspreeFacade {
+    /**
+     * @type {Chalk}
+     */
+    private static readonly colorError: Chalk = chalk.red;
+
+    /**
+     * @type {number}
+     */
+    private static readonly nearestSymbolsCount: number = 15;
+
+    /**
+     * @type {SourceType[]}
+     */
+    private static readonly sourceTypes: espree.SourceType[] = [
+        'script',
+        'module'
+    ];
+
+    /**
+     * @param {string} input
+     * @param {Options} config
+     * @returns {Program}
+     */
+    public static parse (input: string, config: espree.ParseOptions): ESTree.Program | never {
+        const sourceTypeLength: number = EspreeFacade.sourceTypes.length;
+
+        for (let i: number = 0; i < sourceTypeLength; i++) {
+            try {
+                return EspreeFacade.parseType(input, config, EspreeFacade.sourceTypes[i]);
+            } catch (error) {
+                if (i < sourceTypeLength - 1) {
+                    continue;
+                }
+
+                throw new Error(EspreeFacade.processParsingError(
+                    input,
+                    error.message,
+                    {
+                        line: error.lineNumber,
+                        column: error.column,
+                    }
+                ));
+            }
+        }
+
+        throw new Error(`Espree parsing error`);
+    }
+
+    /**
+     * @param {string} input
+     * @param {ParseOptions} inputConfig
+     * @param {SourceType} sourceType
+     * @returns {Program}
+     */
+    private static parseType (
+        input: string,
+        inputConfig: espree.ParseOptions,
+        sourceType: espree.SourceType
+    ): ESTree.Program {
+        const config: espree.ParseOptions = {
+            ...inputConfig,
+            sourceType,
+        };
+
+        return espree.parse(input, config);
+    }
+
+    /**
+     * @param {string} sourceCode
+     * @param {string} errorMessage
+     * @param {Position} position
+     * @returns {never}
+     */
+    private static processParsingError (sourceCode: string, errorMessage: string, position: ESTree.Position | null): never {
+        if (!position || !position.line || !position.column) {
+            throw new Error(errorMessage);
+        }
+
+        const sourceCodeLines: string[] = sourceCode.split(/\r?\n/);
+        const errorLine: string | undefined = sourceCodeLines[position.line - 1];
+
+        if (!errorLine) {
+            throw new Error(errorMessage);
+        }
+
+        const startErrorIndex: number = Math.max(0, position.column - EspreeFacade.nearestSymbolsCount);
+        const endErrorIndex: number = Math.min(errorLine.length, position.column + EspreeFacade.nearestSymbolsCount);
+
+        const formattedPointer: string = EspreeFacade.colorError('>');
+        const formattedCodeSlice: string = `...${
+            errorLine.substring(startErrorIndex, endErrorIndex).replace(/^\s+/, '')
+        }...`;
+
+        throw new Error(`Line ${position.line}: ${errorMessage}\n${formattedPointer} ${formattedCodeSlice}`);
+    }
+}

src/EsprimaFacade.ts

@@ -1,74 +0,0 @@
-import * as esprima from 'esprima';
-import * as ESTree from 'estree';
-
-import chalk, { Chalk } from 'chalk';
-
-/**
- * Facade over `esprima` to handle parsing errors and provide more detailed error messages
- */
-export class EsprimaFacade {
-    /**
-     * @type {Chalk}
-     */
-    private static readonly colorError: Chalk = chalk.red;
-
-    /**
-     * @type {number}
-     */
-    private static readonly nearestSymbolsCount: number = 10;
-
-    /**
-     * @param {string} input
-     * @param {ParseOptions} config
-     * @returns {Program}
-     */
-    public static parse (input: string, config: esprima.ParseOptions): ESTree.Program {
-        let lastMeta: esprima.NodeMeta | null = null;
-
-        try {
-            return esprima.parseScript(input, config, (node: ESTree.Node, meta: esprima.NodeMeta) => lastMeta = meta);
-        } catch {}
-
-        try {
-            return esprima.parseModule(input, config, (node: ESTree.Node, meta: esprima.NodeMeta) => lastMeta = meta);
-        } catch (error) {
-            return EsprimaFacade.processParsingError(input, error.message, lastMeta);
-        }
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @param {string} errorMessage
-     * @param {"esprima".NodeMeta | null} meta
-     * @returns {never}
-     */
-    private static processParsingError (sourceCode: string, errorMessage: string, meta: esprima.NodeMeta | null): never {
-        if (!meta || !meta.start || !meta.end || !meta.start.column || !meta.end.column) {
-            throw new Error(errorMessage);
-        }
-
-        const lineNumberMatch: RegExpMatchArray | null = errorMessage.match(/Line *(\d*)/);
-
-        if (!lineNumberMatch) {
-            throw new Error(errorMessage);
-        }
-
-        const lineNumber: number = parseInt(lineNumberMatch[1], 10);
-        const sourceCodeLines: string[] = sourceCode.split(/\r?\n/);
-        const errorLine: string | undefined = sourceCodeLines[lineNumber - 1];
-
-        if (!errorLine) {
-            throw new Error(errorMessage);
-        }
-
-        const startErrorIndex: number = Math.max(0, meta.start.column - EsprimaFacade.nearestSymbolsCount);
-        const endErrorIndex: number = Math.min(errorLine.length, meta.end.column + EsprimaFacade.nearestSymbolsCount);
-
-        const formattedPointer: string = EsprimaFacade.colorError('>');
-        const formattedCodeSlice: string = `...${
-            errorLine.substring(startErrorIndex, endErrorIndex).replace(/^\s+/, '')
-        }...`;
-
-        throw new Error(`${errorMessage}\n${formattedPointer} ${formattedCodeSlice}`);
-    }
-}

src/JavaScriptObfuscator.ts

@@ -2,6 +2,7 @@ import { inject, injectable, } from 'inversify';
 import { ServiceIdentifiers } from './container/ServiceIdentifiers';
 
 import * as escodegen from 'escodegen-wallaby';
+import * as espree from 'espree';
 import * as ESTree from 'estree';
 import * as packageJson from 'pjson';
 
@@ -18,11 +19,25 @@ import { LoggingMessage } from './enums/logger/LoggingMessage';
 import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
 import { TransformationStage } from './enums/node-transformers/TransformationStage';
 
-import { EsprimaFacade } from './EsprimaFacade';
+import { EspreeFacade } from './EspreeFacade';
 import { NodeGuards } from './node/NodeGuards';
 
 @injectable()
 export class JavaScriptObfuscator implements IJavaScriptObfuscator {
+    /**
+     * @type {Options}
+     */
+    private static readonly espreeParseOptions: espree.ParseOptions = {
+        attachComment: true,
+        comment: true,
+        ecmaFeatures: {
+            experimentalObjectRestSpread: true
+        },
+        ecmaVersion: 8,
+        loc: true,
+        range: true
+    };
+
     /**
      * @type {GenerateOptions}
      */
@@ -135,10 +150,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
      * @returns {Program}
      */
     private parseCode (sourceCode: string): ESTree.Program {
-        return EsprimaFacade.parse(sourceCode, {
-            attachComment: true,
-            loc: this.options.sourceMap
-        });
+        return EspreeFacade.parse(sourceCode, JavaScriptObfuscator.espreeParseOptions);
     }
 
     /**
@@ -148,7 +160,8 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
     private transformAstTree (astTree: ESTree.Program): ESTree.Program {
         const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
             && !astTree.body.length
-            && !astTree.leadingComments;
+            && !astTree.leadingComments
+            && !astTree.trailingComments;
 
         if (isEmptyAstTree) {
             this.logger.warn(LoggingMessage.EmptySourceCode);

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

@@ -8,6 +8,7 @@ import { NodeTransformer } from '../../../enums/node-transformers/NodeTransforme
 import { MemberExpressionTransformer } from '../../../node-transformers/converting-transformers/MemberExpressionTransformer';
 import { MethodDefinitionTransformer } from '../../../node-transformers/converting-transformers/MethodDefinitionTransformer';
 import { ObjectExpressionKeysTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionKeysTransformer';
+import { ObjectExpressionTransformer } from '../../../node-transformers/converting-transformers/ObjectExpressionTransformer';
 import { TemplateLiteralTransformer } from '../../../node-transformers/converting-transformers/TemplateLiteralTransformer';
 
 export const convertingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
@@ -24,6 +25,10 @@ export const convertingTransformersModule: interfaces.ContainerModule = new Cont
         .to(ObjectExpressionKeysTransformer)
         .whenTargetNamed(NodeTransformer.ObjectExpressionKeysTransformer);
 
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(ObjectExpressionTransformer)
+        .whenTargetNamed(NodeTransformer.ObjectExpressionTransformer);
+
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(TemplateLiteralTransformer)
         .whenTargetNamed(NodeTransformer.TemplateLiteralTransformer);

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

@@ -19,7 +19,6 @@ import { FunctionTransformer } from '../../../node-transformers/obfuscating-tran
 import { LabeledStatementTransformer } from '../../../node-transformers/obfuscating-transformers/LabeledStatementTransformer';
 import { LiteralTransformer } from '../../../node-transformers/obfuscating-transformers/LiteralTransformer';
 import { NumberLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/NumberLiteralObfuscatingReplacer';
-import { ObjectExpressionTransformer } from '../../../node-transformers/obfuscating-transformers/ObjectExpressionTransformer';
 import { StringLiteralObfuscatingReplacer } from '../../../node-transformers/obfuscating-transformers/obfuscating-replacers/literal-obfuscating-replacers/StringLiteralObfuscatingReplacer';
 import { VariableDeclarationTransformer } from '../../../node-transformers/obfuscating-transformers/VariableDeclarationTransformer';
 
@@ -49,10 +48,6 @@ export const obfuscatingTransformersModule: interfaces.ContainerModule = new Con
         .to(LiteralTransformer)
         .whenTargetNamed(NodeTransformer.LiteralTransformer);
 
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ObjectExpressionTransformer)
-        .whenTargetNamed(NodeTransformer.ObjectExpressionTransformer);
-
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(VariableDeclarationTransformer)
         .whenTargetNamed(NodeTransformer.VariableDeclarationTransformer);

src/declarations/espree.d.ts

@@ -0,0 +1,28 @@
+/* tslint:disable:interface-name */
+
+declare module 'espree' {
+    import * as ESTree from 'estree';
+
+    export interface Comment {
+        value: string;
+    }
+
+    export type SourceType = 'script' | 'module';
+
+    export interface ParseOptions {
+        attachComment?: boolean;
+        comment?: boolean;
+        ecmaFeatures?: {
+            experimentalObjectRestSpread?: boolean;
+            globalReturn?: boolean;
+            impliedStrict?: boolean;
+            jsx?: boolean;
+        };
+        ecmaVersion?: 3 | 5 | 6 | 7 | 8 | 9 | 2015 | 2016 | 2017 | 2018;
+        loc?: boolean;
+        range?: boolean;
+        sourceType?: SourceType;
+    }
+
+    export function parse (code: string | Buffer, options: ParseOptions): ESTree.Program;
+}

src/declarations/esprima.d.ts

@@ -1,20 +0,0 @@
-/* tslint:disable:interface-name */
-
-import * as esprima from 'esprima';
-
-declare module 'esprima' {
-    export interface LineMeta {
-        line?: number;
-        column?: number;
-        offset?: number;
-    }
-
-    export interface NodeMeta {
-        start?: LineMeta;
-        end?: LineMeta;
-    }
-
-    export interface ParseOptions {
-        attachComment?: boolean;
-    }
-}

src/enums/node/NodeType.ts

@@ -12,11 +12,13 @@ export enum NodeType {
     CatchClause = 'CatchClause',
     ClassDeclaration = 'ClassDeclaration',
     ContinueStatement = 'ContinueStatement',
+    ExportNamedDeclaration = 'ExportNamedDeclaration',
     ExpressionStatement = 'ExpressionStatement',
     FunctionDeclaration = 'FunctionDeclaration',
     FunctionExpression = 'FunctionExpression',
     Identifier = 'Identifier',
     IfStatement = 'IfStatement',
+    ImportDeclaration = 'ImportDeclaration',
     LabeledStatement = 'LabeledStatement',
     Literal = 'Literal',
     LogicalExpression = 'LogicalExpression',

src/node-transformers/obfuscating-transformers/ObjectExpressionTransformer.ts → src/node-transformers/converting-transformers/ObjectExpressionTransformer.ts

@@ -39,7 +39,7 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (transformationStage: TransformationStage): IVisitor | null {
         switch (transformationStage) {
-            case TransformationStage.Obfuscating:
+            case TransformationStage.Converting:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
                         if (parentNode && NodeGuards.isObjectExpressionNode(node)) {

src/node-transformers/obfuscating-transformers/ClassDeclarationTransformer.ts

@@ -69,7 +69,11 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
             case TransformationStage.Obfuscating:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
-                        if (parentNode && NodeGuards.isClassDeclarationNode(node)) {
+                        if (
+                            parentNode
+                            && NodeGuards.isClassDeclarationNode(node)
+                            && !NodeGuards.isExportNamedDeclarationNode(parentNode)
+                        ) {
                             return this.transformNode(node, parentNode);
                         }
                     }

src/node-transformers/obfuscating-transformers/FunctionDeclarationTransformer.ts

@@ -71,7 +71,11 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
             case TransformationStage.Obfuscating:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
-                        if (parentNode && NodeGuards.isFunctionDeclarationNode(node)) {
+                        if (
+                            parentNode
+                            && NodeGuards.isFunctionDeclarationNode(node)
+                            && !NodeGuards.isExportNamedDeclarationNode(parentNode)
+                        ) {
                             return this.transformNode(node, parentNode);
                         }
                     }

src/node-transformers/obfuscating-transformers/LiteralTransformer.ts

@@ -65,7 +65,7 @@ export class LiteralTransformer extends AbstractNodeTransformer {
      * @returns {NodeGuards}
      */
     public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (parentNode && NodeGuards.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+        if (this.isProhibitedNode(literalNode, parentNode)) {
             return literalNode;
         }
 
@@ -86,4 +86,21 @@ export class LiteralTransformer extends AbstractNodeTransformer {
                 return literalNode;
         }
     }
+
+    /**
+     * @param {Literal} literalNode
+     * @param {Node} parentNode
+     * @returns {boolean}
+     */
+    private isProhibitedNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): boolean {
+        if (NodeGuards.isPropertyNode(parentNode) && parentNode.key === literalNode) {
+            return true;
+        }
+
+        if (NodeGuards.isImportDeclarationNode(parentNode)) {
+            return true;
+        }
+
+        return false;
+    }
 }

src/node-transformers/obfuscating-transformers/VariableDeclarationTransformer.ts

@@ -72,7 +72,11 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
             case TransformationStage.Obfuscating:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
-                        if (parentNode && NodeGuards.isVariableDeclarationNode(node)) {
+                        if (
+                            parentNode
+                            && NodeGuards.isVariableDeclarationNode(node)
+                            && !NodeGuards.isExportNamedDeclarationNode(parentNode)
+                        ) {
                             return this.transformNode(node, parentNode);
                         }
                     }

src/node-transformers/preparing-transformers/CommentsTransformer.ts

@@ -17,7 +17,10 @@ export class CommentsTransformer extends AbstractNodeTransformer {
     /**
      * @type {string[]}
      */
-    private static readonly preservedWords: string[] = ['@license', '@preserve'];
+    private static readonly preservedWords: string[] = [
+        '@license',
+        '@preserve'
+    ];
 
     /**
      * @param {IRandomGenerator} randomGenerator
@@ -77,7 +80,7 @@ export class CommentsTransformer extends AbstractNodeTransformer {
     private transformComments (comments: ESTree.Comment[]): ESTree.Comment[] {
         return comments.filter((comment: ESTree.Comment) =>
             CommentsTransformer.preservedWords
-                .some((availableWord: string) => comment.value.includes(availableWord))
+                .some((preservedWord: string) => comment.value.includes(preservedWord))
         );
     }
 }

src/node/NodeGuards.ts

@@ -96,6 +96,14 @@ export class NodeGuards {
         return node.type === NodeType.ContinueStatement;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isExportNamedDeclarationNode (node: ESTree.Node): node is ESTree.ExportNamedDeclaration {
+        return node.type === NodeType.ExportNamedDeclaration;
+    }
+
     /**
      * @param {Node} node
      * @returns {boolean}
@@ -136,6 +144,14 @@ export class NodeGuards {
         return node.type === NodeType.IfStatement;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isImportDeclarationNode (node: ESTree.Node): node is ESTree.ImportDeclaration {
+        return node.type === NodeType.ImportDeclaration;
+    }
+
     /**
      * @param {Node} node
      * @param {Node} parentNode

src/node/NodeUtils.ts

@@ -1,5 +1,5 @@
 import * as escodegen from 'escodegen-wallaby';
-import * as esprima from 'esprima';
+import * as espree from 'espree';
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
@@ -44,7 +44,7 @@ export class NodeUtils {
      * @returns {Statement[]}
      */
     public static convertCodeToStructure (code: string): ESTree.Statement[] {
-        let structure: ESTree.Program = esprima.parseScript(code);
+        let structure: ESTree.Program = espree.parse(code, { sourceType: 'script' });
 
         structure = NodeUtils.addXVerbatimPropertyToLiterals(structure);
         structure = NodeUtils.parentize(structure);

test/declarations/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference path="../../src/declarations/escodegen.d.ts" />
 /// <reference path="../../src/declarations/escodegen-wallaby.d.ts" />
-/// <reference path="../../src/declarations/esprima.d.ts" />
+/// <reference path="../../src/declarations/espree.d.ts" />
 /// <reference path="../../src/declarations/ESTree.d.ts" />
 /// <reference path="../../src/declarations/js-string-escape.d.ts" />
 /// <reference path="../../src/declarations/threads.d.ts" />

test/dev/dev.ts

@@ -6,21 +6,15 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-        (function() {
-            function test() {
-                var variable = 1;
-                function g () {}
-        
-                var func = function () {
-                    var e;
-                }
-            }
+        (function () {
+            let a = 0;
+            let b = 0;
+            var test = {a, b};
         })();
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
-            identifierNamesGenerator: 'mangled'
         }
     ).getObfuscatedCode();
 

test/functional-tests/javascript-obfuscator/JavaScriptObfuscator.spec.ts

@@ -594,19 +594,43 @@ describe('JavaScriptObfuscator', () => {
         });
 
         describe('parse module', () => {
-            const regExp: RegExp = /var *test *= *0x1/;
+            describe('Variant #1: import', () => {
+                const importRegExp: RegExp = /import *{foo} *from *'.\/foo';/;
+                const variableDeclarationRegExp: RegExp = /var *test *= *0x1/;
 
-            let obfuscatedCode: string;
+                let obfuscatedCode: string;
 
-            beforeEach(() => {
-                const code: string = readFileAsString(__dirname + '/fixtures/parse-module.js');
-                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(code);
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/parse-module-1.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(code);
 
-                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('Match #!: should correctly obfuscate a import', () => {
+                    assert.match(obfuscatedCode, importRegExp);
+                });
+
+                it('Match #2: should correctly obfuscate a module', () => {
+                    assert.match(obfuscatedCode, variableDeclarationRegExp);
+                });
             });
 
-            it('should correctly obfuscate a module', () => {
-                assert.match(obfuscatedCode, regExp);
+            describe('Variant #2: export', () => {
+                const regExp: RegExp = /export *const *foo *= *0x1;/;
+
+                let obfuscatedCode: string;
+
+                beforeEach(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/parse-module-2.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(code);
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should correctly obfuscate a module', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
             });
         });
 

test/functional-tests/javascript-obfuscator/fixtures/parse-module-1.js

@@ -0,0 +1,3 @@
+import {foo} from './foo';
+
+var test = 1;

test/functional-tests/javascript-obfuscator/fixtures/parse-module-2.js

@@ -0,0 +1 @@
+export const foo = 1;

test/functional-tests/javascript-obfuscator/fixtures/parse-module.js

@@ -1,3 +0,0 @@
-import {foo} from "./foo";
-
-var test = 1;

test/functional-tests/node-transformers/converting-transformers/method-definition-transformer/MethodDefinitionTransformer.spec.ts

@@ -81,4 +81,31 @@ describe('MethodDefinitionTransformer', () => {
             assert.match(obfuscatedCode, regExp);
         });
     });
+
+    describe('Variant #4: async `get()` method', () => {
+        const classDeclarationRegExp: RegExp = /class *(_0x[a-f0-9]{4,6}) *{/;
+        const asyncMethodRegExp: RegExp = /static *async *\['get'] *\(\) *{}/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/async-get-method.js');
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                }
+            );
+
+            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        });
+
+        it('Match #1: should rename class declaration name', () => {
+            assert.match(obfuscatedCode, classDeclarationRegExp);
+        });
+
+        it('Match #2: should correctly rename async method name', () => {
+            assert.match(obfuscatedCode, asyncMethodRegExp);
+        });
+    });
 });

test/functional-tests/node-transformers/converting-transformers/method-definition-transformer/fixtures/async-get-method.js

@@ -0,0 +1,5 @@
+(function () {
+    class Foo {
+        static async get() {}
+    }
+})();

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/ClassDeclarationTransformer.spec.ts

@@ -123,5 +123,56 @@ describe('ClassDeclarationTransformer', () => {
                 assert.match(obfuscatedCode, variableDeclarationsRegExp);
             });
         });
+
+        describe('Variant #5: named export', () => {
+            const namedExportRegExp: RegExp = /export class Foo *{}/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('shouldn\'t transform identifiers in named export', () => {
+                assert.match(obfuscatedCode, namedExportRegExp);
+            });
+        });
+
+        describe('Variant #6: default export', () => {
+            const classDeclarationRegExp: RegExp = /class _0x[a-f0-9]{4,6} *{}/;
+            const defaultExportRegExp: RegExp = /export default _0x[a-f0-9]{4,6};/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('Match #1: should transform identifiers in variable declaration', () => {
+                assert.match(obfuscatedCode, classDeclarationRegExp);
+            });
+
+            it('Match #2: should transform identifiers in default export', () => {
+                assert.match(obfuscatedCode, defaultExportRegExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/fixtures/default-export.js

@@ -0,0 +1,3 @@
+class Foo {}
+
+export default Foo;

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/fixtures/named-export.js

@@ -0,0 +1 @@
+export class Foo {}

test/functional-tests/node-transformers/obfuscating-transformers/function-declaration-transformer/FunctionDeclarationTransformer.spec.ts

@@ -179,5 +179,56 @@ describe('FunctionDeclarationTransformer', () => {
                 });
             });
         });
+
+        describe('Variant #6: named export', () => {
+            const namedExportRegExp: RegExp = /export function foo *\(\) *{}/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('shouldn\'t transform identifiers in named export', () => {
+                assert.match(obfuscatedCode, namedExportRegExp);
+            });
+        });
+
+        describe('Variant #7: default export', () => {
+            const functionDeclarationRegExp: RegExp = /function _0x[a-f0-9]{4,6} *\(\) *{}/;
+            const defaultExportRegExp: RegExp = /export default _0x[a-f0-9]{4,6};/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        renameGlobals: true
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('Match #1: should transform identifiers in variable declaration', () => {
+                assert.match(obfuscatedCode, functionDeclarationRegExp);
+            });
+
+            it('Match #2: should transform identifiers in default export', () => {
+                assert.match(obfuscatedCode, defaultExportRegExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/obfuscating-transformers/function-declaration-transformer/fixtures/default-export.js

@@ -0,0 +1,3 @@
+function foo () {}
+
+export default foo;

test/functional-tests/node-transformers/obfuscating-transformers/function-declaration-transformer/fixtures/named-export.js

@@ -0,0 +1 @@
+export function foo () {}

test/functional-tests/node-transformers/obfuscating-transformers/labeled-statement-transformer/LabeledStatementTransformer.spec.ts

@@ -11,7 +11,7 @@ import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFac
 
 describe('LabeledStatementTransformer', () => {
     describe('changeControlFlow (labeledStatementNode: ESTree.LabeledStatement): void', () => {
-        const labeledStatementRegExp: RegExp = /(_0x([a-f0-9]){4,6}): *\{/;
+        const labeledStatementRegExp: RegExp = /(_0x([a-f0-9]){4,6}): *for/;
         const continueStatementRegExp: RegExp = /continue *(_0x([a-f0-9]){4,6});/;
         const breakStatementRegExp: RegExp = /break *(_0x([a-f0-9]){4,6});/;
 

test/functional-tests/node-transformers/obfuscating-transformers/labeled-statement-transformer/fixtures/input.js

@@ -1,8 +1,7 @@
 function foo (label) {
-    label: {
+    label:
         for (var i = 0; i < 1000; i++) {
             break label;
             continue label;
         }
-    }
 }

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/VariableDeclarationTransformer.spec.ts

@@ -520,4 +520,55 @@ describe('VariableDeclarationTransformer', () => {
             });
         });
     });
+
+    describe('Variant #14: named export', () => {
+        const namedExportRegExp: RegExp = /export const foo *= *0x1;/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/named-export.js');
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    renameGlobals: true
+                }
+            );
+
+            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        });
+
+        it('shouldn\'t transform identifiers in named export', () => {
+            assert.match(obfuscatedCode, namedExportRegExp);
+        });
+    });
+
+    describe('Variant #15: default export', () => {
+        const variableDeclarationRegExp: RegExp = /var _0x[a-f0-9]{4,6} *= *0x1;/;
+        const defaultExportRegExp: RegExp = /export default _0x[a-f0-9]{4,6};/;
+
+        let obfuscatedCode: string;
+
+        before(() => {
+            const code: string = readFileAsString(__dirname + '/fixtures/default-export.js');
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    renameGlobals: true
+                }
+            );
+
+            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        });
+
+        it('Match #1: should transform identifiers in variable declaration', () => {
+            assert.match(obfuscatedCode, variableDeclarationRegExp);
+        });
+
+        it('Match #2: should transform identifiers in default export', () => {
+            assert.match(obfuscatedCode, defaultExportRegExp);
+        });
+    });
 });

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/fixtures/default-export.js

@@ -0,0 +1,3 @@
+var foo = 1;
+
+export default foo;

test/functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/fixtures/named-export.js

@@ -0,0 +1 @@
+export const foo = 1;

test/functional-tests/templates/GlobalVariableNoEvalTemplate.spec.ts

@@ -68,6 +68,9 @@ describe('GlobalVariableNoEvalTemplate (): string', () => {
                 
                 return that;
             `)();
+
+            // for some reason it couldn't correctly compare global objects without JSON.stringify/JSON.parse
+            globalObject = JSON.parse(JSON.stringify(globalObject));
         });
 
         it('should correctly return `window` object', () => {

test/helpers/removeRangesFromStructure.ts

@@ -0,0 +1,28 @@
+import * as estraverse from 'estraverse';
+import * as ESTree from 'estree';
+
+import { TStatement } from '../../src/types/node/TStatement';
+
+/**
+ * @param {TStatement[]} structure
+ * @returns {TStatement[]}
+ */
+export function removeRangesFromStructure (structure: TStatement[]): TStatement[] {
+    for (const statement of structure) {
+        estraverse.replace(statement, {
+            enter: (node: ESTree.Node): ESTree.Node => {
+                delete (<any>node).start;
+                delete (<any>node).end;
+
+                if (node.parentNode) {
+                    delete (<any>node.parentNode).start;
+                    delete (<any>node.parentNode).end;
+                }
+
+                return node;
+            }
+        });
+    }
+
+    return structure;
+}

test/index.spec.ts

@@ -17,7 +17,7 @@ import './unit-tests/cli/utils/SourceCodeReader.spec';
 import './unit-tests/decorators/initializable/Initializable.spec';
 import './unit-tests/generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator.spec';
 import './unit-tests/generators/identifier-names-generators/MangledlIdentifierNamesGenerator.spec';
-import './unit-tests/javascript-obfuscator/EsprimaFacade.spec';
+import './unit-tests/javascript-obfuscator/EspreeFacade.spec';
 import './unit-tests/javascript-obfuscator/JavaScriptObfuscator.spec';
 import './unit-tests/logger/Logger.spec';
 import './unit-tests/node/node-appender/NodeAppender.spec';
@@ -55,6 +55,7 @@ import './functional-tests/node-transformers/control-flow-transformers/control-f
 import './functional-tests/node-transformers/converting-transformers/member-expression-transformer/MemberExpressionTransformer.spec';
 import './functional-tests/node-transformers/converting-transformers/method-definition-transformer/MethodDefinitionTransformer.spec';
 import './functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/ObjectExpressionKeysTransformer.spec';
+import './functional-tests/node-transformers/converting-transformers/object-expression-transformer/ObjectExpressionTransformer.spec';
 import './functional-tests/node-transformers/converting-transformers/template-literal-transformer/TemplateLiteralTransformer.spec';
 import './functional-tests/node-transformers/dead-code-injection-transformers/DeadCodeInjectionTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/catch-clause-transformer/CatchClauseTransformer.spec';
@@ -63,7 +64,6 @@ import './functional-tests/node-transformers/obfuscating-transformers/function-d
 import './functional-tests/node-transformers/obfuscating-transformers/function-transformer/FunctionTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/labeled-statement-transformer/LabeledStatementTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/literal-transformer/LiteralTransformer.spec';
-import './functional-tests/node-transformers/obfuscating-transformers/object-expression-transformer/ObjectExpressionTransformer.spec';
 import './functional-tests/node-transformers/obfuscating-transformers/variable-declaration-transformer/VariableDeclarationTransformer.spec';
 import './functional-tests/node-transformers/preparing-transformers/eval-call-expression-transformer/EvalCallExpressionTransformer.spec';
 import './functional-tests/node-transformers/preparing-transformers/comments-transformer/CommentsTransformer.spec';

test/unit-tests/javascript-obfuscator/EsprimaFacade.spec.ts → test/unit-tests/javascript-obfuscator/EspreeFacade.spec.ts

@@ -1,9 +1,9 @@
 import { assert } from 'chai';
-import { EsprimaFacade } from '../../../src/EsprimaFacade';
+import { EspreeFacade } from '../../../src/EspreeFacade';
 
 
-describe('EsprimaFacade', () => {
-    describe(`parseScript (input: string, config: esprima.ParseOptions): ESTree.Program`, () => {
+describe('EspreeFacade', () => {
+    describe(`parse (input: string, config: espree.ParseOptions): ESTree.Program`, () => {
         describe(`\`Unexpected token\` error code preview`, () => {
             describe('Variant #1: 5 lines of code', () => {
                 const sourceCode: string = `` +
@@ -16,10 +16,10 @@ describe('EsprimaFacade', () => {
                 let testFunc: () => void;
 
                 before(() => {
-                    testFunc = () => EsprimaFacade.parse(sourceCode, {});
+                    testFunc = () => EspreeFacade.parse(sourceCode, {});
                 });
 
-                it('should output code preview when `esprima` throws a parse error', () => {
+                it('should output code preview when `espree` throws a parse error', () => {
                     assert.throws(testFunc, /Line 3: Unexpected token ,\n.*\.\.\.var baz = 3;,\.\.\./);
                 });
             });
@@ -45,16 +45,16 @@ describe('EsprimaFacade', () => {
                 let testFunc: () => void;
 
                 before(() => {
-                    testFunc = () => EsprimaFacade.parse(sourceCode, {});
+                    testFunc = () => EspreeFacade.parse(sourceCode, {});
                 });
 
-                it('should output code preview when `esprima` throws a parse error', () => {
+                it('should output code preview when `espree` throws a parse error', () => {
                     assert.throws(testFunc, /Line 13: Unexpected token ,\n.*\.\.\.var baz = 3;,\.\.\./);
                 });
             });
         });
 
-        describe(`\`Unexpected identifier\` error code preview`, () => {
+        describe(`\`Unexpected token\` error code preview`, () => {
             const sourceCode: string = `` +
                 `function bar () {
                     var a = 1;
@@ -69,11 +69,11 @@ describe('EsprimaFacade', () => {
             let testFunc: () => void;
 
             before(() => {
-                testFunc = () => EsprimaFacade.parse(sourceCode, {});
+                testFunc = () => EspreeFacade.parse(sourceCode, {});
             });
 
-            it('should output code preview when `esprima` throws a parse error', () => {
-                assert.throws(testFunc, /Line 4: Unexpected identifier\n.*\.\.\.functin baz \(\) {\.\.\./);
+            it('should output code preview when `espree` throws a parse error', () => {
+                assert.throws(testFunc, /Line 4: Unexpected token baz\n.*\.\.\.functin baz \(\) {\.\.\./);
             });
         });
     });

test/unit-tests/node/node-appender/NodeAppender.spec.ts

@@ -18,14 +18,17 @@ import { InversifyContainerFacade } from '../../../../src/container/InversifyCon
 import { NodeAppender } from '../../../../src/node/NodeAppender';
 import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
+import { removeRangesFromStructure } from '../../../helpers/removeRangesFromStructure';
 
 /**
  * @param fixturePath
  * @return {TStatement[]}
  */
 const convertCodeToStructure: (fixturePath: string) => TStatement[] = (fixturePath) => {
-    return NodeUtils.convertCodeToStructure(
-        readFileAsString(`${__dirname}${fixturePath}`)
+    return removeRangesFromStructure(
+        NodeUtils.convertCodeToStructure(
+            readFileAsString(`${__dirname}${fixturePath}`)
+        )
     );
 };
 

test/unit-tests/node/node-utils/NodeUtils.spec.ts

@@ -4,6 +4,8 @@ import { assert } from 'chai';
 
 import { TStatement } from '../../../../src/types/node/TStatement';
 
+import { removeRangesFromStructure } from '../../../helpers/removeRangesFromStructure';
+
 import { NodeFactory } from '../../../../src/node/NodeFactory';
 import { NodeUtils } from '../../../../src/node/NodeUtils';
 
@@ -145,7 +147,9 @@ describe('NodeUtils', () => {
             identifierNode.parentNode = variableDeclaratorNode;
             literalNode.parentNode = variableDeclaratorNode;
 
-            structure = NodeUtils.convertCodeToStructure(code);
+            structure = removeRangesFromStructure(
+                NodeUtils.convertCodeToStructure(code)
+            );
             expectedStructure = [variableDeclarationNode];
         });