Merge tag '0.17.1' into 0.17.2

# Conflicts:
#	dist/index.browser.js
#	dist/index.cli.js
#	dist/index.js
#	package.json
#	yarn.lock

CHANGELOG.md

@@ -1,5 +1,11 @@
 Change Log
 ===
+v0.17.1
+---
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/293
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/289
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/288
+
 v0.17.0
 ---
 * **Browser version**: Added browser version dist

src/interfaces/utils/IEscapeSequenceEncoder.d.ts

@@ -1,7 +1,8 @@
 export interface IEscapeSequenceEncoder {
     /**
-     * @param string
-     * @param usingUnicodeEscapeSequence
+     * @param {string} string
+     * @param {boolean} encodeAllSymbols
+     * @returns {string}
      */
-    encode (string: string, usingUnicodeEscapeSequence: boolean): string;
+    encode (string: string, encodeAllSymbols: boolean): string;
 }

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

@@ -12,6 +12,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
+import { IEscapeSequenceEncoder } from '../../interfaces/utils/IEscapeSequenceEncoder';
 
 /**
  * replaces:
@@ -23,14 +24,23 @@ import { NodeGuards } from '../../node/NodeGuards';
 @injectable()
 export class ObjectExpressionTransformer extends AbstractNodeTransformer {
     /**
+     * @type {IEscapeSequenceEncoder}
+     */
+    private readonly escapeSequenceEncoder: IEscapeSequenceEncoder;
+
+    /**
+     * @param {IEscapeSequenceEncoder} escapeSequenceEncoder
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      */
     constructor (
+        @inject(ServiceIdentifiers.IEscapeSequenceEncoder) escapeSequenceEncoder: IEscapeSequenceEncoder,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(randomGenerator, options);
+
+        this.escapeSequenceEncoder = escapeSequenceEncoder;
     }
 
     /**
@@ -61,19 +71,53 @@ export class ObjectExpressionTransformer extends AbstractNodeTransformer {
     public transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
         objectExpressionNode.properties
             .forEach((property: ESTree.Property) => {
-                if (property.computed || !property.key) {
+                if (!property.key) {
                     return;
                 }
 
-                if (property.shorthand) {
-                    property.shorthand = false;
-                }
-
-                if (NodeGuards.isIdentifierNode(property.key)) {
-                    property.key = NodeFactory.literalNode(property.key.name);
+                if (property.computed) {
+                    this.transformComputedProperty(property);
+                } else {
+                    this.transformBaseProperty(property);
                 }
             });
 
         return objectExpressionNode;
     }
+
+    /**
+     * @param {Property} property
+     */
+    private transformComputedProperty (property: ESTree.Property): void {
+        if (!NodeGuards.isLiteralNode(property.key) || !(typeof property.key.value === 'string')) {
+            return;
+        }
+
+        property.key = NodeFactory.literalNode(this.getPropertyKeyValue(property.key.value));
+    }
+
+    /**
+     * @param {Property} property
+     */
+    private transformBaseProperty (property: ESTree.Property): void {
+        if (property.shorthand) {
+            property.shorthand = false;
+        }
+
+        if (!NodeGuards.isIdentifierNode(property.key)) {
+            return;
+        }
+
+        property.key = NodeFactory.literalNode(this.getPropertyKeyValue(property.key.name));
+    }
+
+    /**
+     * @param {string} inputValue
+     * @returns {string}
+     */
+    private getPropertyKeyValue (inputValue: string): string {
+        return this.options.unicodeEscapeSequence
+            ? this.escapeSequenceEncoder.encode(inputValue, true)
+            : inputValue;
+    }
 }

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

@@ -12,6 +12,7 @@ import { TransformationStage } from '../../enums/node-transformers/Transformatio
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
+import { NodeUtils } from '../../node/NodeUtils';
 
 /**
  * Transform ES2015 template literals to ES5
@@ -102,6 +103,8 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
             nodes.unshift(NodeFactory.literalNode(''));
         }
 
+        let transformedNode: ESTree.Node;
+
         if (nodes.length > 1) {
             let root: ESTree.BinaryExpression = NodeFactory.binaryExpressionNode(
                 '+',
@@ -113,9 +116,13 @@ export class TemplateLiteralTransformer extends AbstractNodeTransformer {
                 root = NodeFactory.binaryExpressionNode('+', root, node);
             });
 
-            return root;
+            transformedNode = root;
+        } else {
+            transformedNode = nodes[0];
         }
 
-        return nodes[0];
+        NodeUtils.parentizeAst(transformedNode);
+
+        return transformedNode;
     }
 }

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

@@ -6,6 +6,8 @@ import * as ESTree from 'estree';
 
 import { TIdentifierObfuscatingReplacerFactory } from "../../types/container/node-transformers/TIdentifierObfuscatingReplacerFactory";
 import { TNodeWithBlockScope } from '../../types/node/TNodeWithBlockScope';
+import { TReplaceableIdentifiers } from '../../types/node-transformers/TReplaceableIdentifiers';
+import { TReplaceableIdentifiersNames } from '../../types/node-transformers/TReplaceableIdentifiersNames';
 
 import { IIdentifierObfuscatingReplacer } from '../../interfaces/node-transformers/obfuscating-transformers/obfuscating-replacers/IIdentifierObfuscatingReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
@@ -40,7 +42,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     /**
      * @type {Map<ESTree.Node, ESTree.Identifier[]>}
      */
-    private readonly replaceableIdentifiers: Map <ESTree.Node, ESTree.Identifier[]> = new Map();
+    private readonly replaceableIdentifiers: TReplaceableIdentifiers = new Map();
 
     /**
      * @param {TIdentifierObfuscatingReplacerFactory} identifierObfuscatingReplacerFactory
@@ -101,7 +103,7 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
 
         // check for cached identifiers for current scope node. If exist - loop through them.
         if (this.replaceableIdentifiers.has(blockScopeNode)) {
-            this.replaceScopeCachedIdentifiers(blockScopeNode);
+            this.replaceScopeCachedIdentifiers(classDeclarationNode, blockScopeNode);
         } else {
             this.replaceScopeIdentifiers(blockScopeNode);
         }
@@ -127,26 +129,40 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
     }
 
     /**
+     * @param {ClassDeclaration} classDeclarationNode
      * @param {TNodeWithBlockScope} blockScopeNode
      */
-    private replaceScopeCachedIdentifiers (blockScopeNode: TNodeWithBlockScope): void {
-        const cachedReplaceableIdentifiers: ESTree.Identifier[] =
-            <ESTree.Identifier[]>this.replaceableIdentifiers.get(blockScopeNode);
+    private replaceScopeCachedIdentifiers (
+        classDeclarationNode: ESTree.ClassDeclaration,
+        blockScopeNode: TNodeWithBlockScope
+    ): void {
+        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames =
+            <TReplaceableIdentifiersNames>this.replaceableIdentifiers.get(blockScopeNode);
+
+        const cachedReplaceableIdentifiers: ESTree.Identifier[] | undefined = cachedReplaceableIdentifiersNamesMap
+            .get(classDeclarationNode.id.name);
+
+        if (!cachedReplaceableIdentifiers) {
+            return;
+        }
+
+        const cachedReplaceableIdentifierLength: number = cachedReplaceableIdentifiers.length;
 
-        cachedReplaceableIdentifiers.forEach((replaceableIdentifier: ESTree.Identifier) => {
+        for (let i: number = 0; i < cachedReplaceableIdentifierLength; i++) {
+            const replaceableIdentifier: ESTree.Identifier = cachedReplaceableIdentifiers[i];
             const newReplaceableIdentifier: ESTree.Identifier = this.identifierObfuscatingReplacer
                 .replace(replaceableIdentifier.name, blockScopeNode);
 
             replaceableIdentifier.name = newReplaceableIdentifier.name;
             NodeMetadata.set(replaceableIdentifier, { renamedIdentifier: true });
-        });
+        }
     }
 
     /**
      * @param {TNodeWithBlockScope} blockScopeNode
      */
     private replaceScopeIdentifiers (blockScopeNode: TNodeWithBlockScope): void {
-        const storedReplaceableIdentifiers: ESTree.Identifier[] = [];
+        const storedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames = new Map();
 
         estraverse.replace(blockScopeNode, {
             enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
@@ -163,12 +179,16 @@ export class ClassDeclarationTransformer extends AbstractNodeTransformer {
                         node.name = newIdentifierName;
                         NodeMetadata.set(node, { renamedIdentifier: true });
                     } else {
+                        const storedReplaceableIdentifiers: ESTree.Identifier[] =
+                            storedReplaceableIdentifiersNamesMap.get(node.name) || [];
+
                         storedReplaceableIdentifiers.push(node);
+                        storedReplaceableIdentifiersNamesMap.set(node.name, storedReplaceableIdentifiers);
                     }
                 }
             }
         });
 
-        this.replaceableIdentifiers.set(blockScopeNode, storedReplaceableIdentifiers);
+        this.replaceableIdentifiers.set(blockScopeNode, storedReplaceableIdentifiersNamesMap);
     }
 }

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

@@ -136,12 +136,8 @@ export class FunctionDeclarationTransformer extends AbstractNodeTransformer {
         functionDeclarationNode: ESTree.FunctionDeclaration,
         blockScopeNode: TNodeWithBlockScope
     ): void {
-        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames | undefined =
-            this.replaceableIdentifiers.get(blockScopeNode);
-
-        if (!cachedReplaceableIdentifiersNamesMap) {
-            return;
-        }
+        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames =
+            <TReplaceableIdentifiersNames>this.replaceableIdentifiers.get(blockScopeNode);
 
         const cachedReplaceableIdentifiers: ESTree.Identifier[] | undefined = cachedReplaceableIdentifiersNamesMap
             .get(functionDeclarationNode.id.name);

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

@@ -145,12 +145,8 @@ export class VariableDeclarationTransformer extends AbstractNodeTransformer {
         blockScopeNode: TNodeWithBlockScope,
         scopeNode: ESTree.Node
     ): void {
-        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames | undefined =
-            this.replaceableIdentifiers.get(scopeNode);
-
-        if (!cachedReplaceableIdentifiersNamesMap) {
-            return;
-        }
+        const cachedReplaceableIdentifiersNamesMap: TReplaceableIdentifiersNames =
+            <TReplaceableIdentifiersNames>this.replaceableIdentifiers.get(scopeNode);
 
         const identifierNames: string[] = [];
 

test/functional-tests/node-transformers/converting-transformers/object-expression-transformer/ObjectExpressionTransformer.spec.ts

@@ -10,24 +10,50 @@ import { JavaScriptObfuscator } from '../../../../../src/JavaScriptObfuscatorFac
 
 describe('ObjectExpressionTransformer', () => {
     describe('default behaviour', () => {
-        const regExp: RegExp = /var *test *= *\{'foo':0x0\};/;
+        describe('Variant #1: `unicodeEscapeSequence` option is disabled\'', () => {
+            const regExp: RegExp = /var *test *= *\{'foo':0x0\};/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/property-with-identifier-value.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        unicodeEscapeSequence: false
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('should replace object expression node `key` property with identifier value by property with literal value', () => {
+                assert.match(obfuscatedCode, regExp);
+            });
+        });
 
-        let obfuscatedCode: string;
+        describe('Variant #2: `unicodeEscapeSequence` option is enabled', () => {
+            const regExp: RegExp = /var *test *= *\{'\\x66\\x6f\\x6f':0x0\};/;
 
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/property-with-identifier-value.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET
-                }
-            );
+            let obfuscatedCode: string;
 
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
-       });
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/property-with-identifier-value.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        unicodeEscapeSequence: true
+                    }
+                );
 
-        it('should replace object expression node `key` property with identifier value by property with literal value', () => {
-            assert.match(obfuscatedCode, regExp);
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('should replace object expression node `key` property with identifier value by property with encoded literal value', () => {
+                assert.match(obfuscatedCode, regExp);
+            });
         });
     });
 
@@ -54,24 +80,74 @@ describe('ObjectExpressionTransformer', () => {
     });
 
     describe('computed property name', () => {
-        const regExp: RegExp = /var *_0x[a-f0-9]{4,6} *= *\{\[_0x[a-f0-9]{4,6}\]: *0x1\};/;
-
-        let obfuscatedCode: string;
-
-        before(() => {
-            const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name.js');
-            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                code,
-                {
-                    ...NO_ADDITIONAL_NODES_PRESET
-                }
-            );
-
-            obfuscatedCode = obfuscationResult.getObfuscatedCode();
+        describe('Variant #1: computed property name with identifier', () => {
+            const regExp: RegExp = /var *_0x[a-f0-9]{4,6} *= *\{\[_0x[a-f0-9]{4,6}\]: *0x1\};/;
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-identifier.js');
+                const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET
+                    }
+                );
+
+                obfuscatedCode = obfuscationResult.getObfuscatedCode();
+            });
+
+            it('should ignore computed property identifier', () => {
+                assert.match(obfuscatedCode, regExp);
+            });
         });
 
-        it('should ignore computed property identifier', () => {
-            assert.match(obfuscatedCode, regExp);
+        describe('Variant #2: computed property name with literal', () => {
+            describe('Variant #1: `unicodeEscapeSequence` option is disabled', () => {
+                const regExp: RegExp = /var *_0x[a-f0-9]{4,6} *= *\{\['foo'\]: *0x1\};/;
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-literal.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            unicodeEscapeSequence: false
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should ignore computed property literal value', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
+
+            describe('Variant #2: `unicodeEscapeSequence` option is enabled', () => {
+                const regExp: RegExp = /var *_0x[a-f0-9]{4,6} *= *\{\['\\x66\\x6f\\x6f'\]: *0x1\};/;
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/computed-property-name-literal.js');
+                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            unicodeEscapeSequence: true
+                        }
+                    );
+
+                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                });
+
+                it('should encode computed property literal value', () => {
+                    assert.match(obfuscatedCode, regExp);
+                });
+            });
         });
     });
 

test/functional-tests/node-transformers/converting-transformers/object-expression-transformer/fixtures/computed-property-name-literal.js

@@ -0,0 +1,5 @@
+(function () {
+    var test = {
+        ['foo']: 1
+    };
+})();

test/functional-tests/node-transformers/converting-transformers/template-literal-transformer/TemplateLiteralTransformer.spec.ts

@@ -156,4 +156,19 @@ describe('TemplateLiteralTransformer', () => {
             );
         });
     });
+
+    describe('Variant #7: template literal parentize', () => {
+        it('should parentize transformed template literal node', () => {
+            const code: string = readFileAsString(__dirname + '/fixtures/template-literal-parentize.js');
+            const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                code,
+                {
+                    ...NO_ADDITIONAL_NODES_PRESET,
+                    unicodeEscapeSequence: false
+                }
+            );
+
+            assert.match(obfuscationResult.getObfuscatedCode(),  /^\[]\['map']\(\(\) *=> *'foo'\);$/);
+        });
+    });
 });

test/functional-tests/node-transformers/converting-transformers/template-literal-transformer/fixtures/template-literal-parentize.js

@@ -0,0 +1 @@
+[].map(() => `foo`);

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

@@ -68,30 +68,60 @@ describe('ClassDeclarationTransformer', () => {
             });
 
             describe('Variant #2: `renameGlobals` option is enabled', () => {
-                const classNameIdentifierRegExp: RegExp = /class *(_0x[a-f0-9]{4,6}) *\{/;
-                const classCallIdentifierRegExp: RegExp = /new *(_0x[a-f0-9]{4,6}) *\( *\);/;
+                describe('Variant #1: Base', () => {
+                    const classNameIdentifierRegExp: RegExp = /class *(_0x[a-f0-9]{4,6}) *\{/;
+                    const classCallIdentifierRegExp: RegExp = /new *(_0x[a-f0-9]{4,6}) *\( *\);/;
+
+                    let obfuscatedCode: string;
+
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
+                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                renameGlobals: true
+                            }
+                        );
+
+                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    });
+
+                    it('match #1: should transform class name', () => {
+                        assert.match(obfuscatedCode, classNameIdentifierRegExp);
+                    });
+
+                    it('match #2: should transform class name', () => {
+                        assert.match(obfuscatedCode, classCallIdentifierRegExp);
+                    });
+                });
 
-                let obfuscatedCode: string;
+                describe('Variant #2: Two classes. Transformation of identifier inside class method', () => {
+                    const identifierRegExp1: RegExp = /const (?:_0x[a-f0-9]{4,6}) *= *0x1;/;
+                    const identifierRegExp2: RegExp = /const (?:_0x[a-f0-9]{4,6}) *= *0x2;/;
 
-                before(() => {
-                    const code: string = readFileAsString(__dirname + '/fixtures/parent-block-scope-is-program-node.js');
-                    const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
-                        code,
-                        {
-                            ...NO_ADDITIONAL_NODES_PRESET,
-                            renameGlobals: true
-                        }
-                    );
+                    let obfuscatedCode: string;
 
-                    obfuscatedCode = obfuscationResult.getObfuscatedCode();
-                });
+                    before(() => {
+                        const code: string = readFileAsString(__dirname + '/fixtures/rename-globals-identifier-transformation.js');
+                        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+                            code,
+                            {
+                                ...NO_ADDITIONAL_NODES_PRESET,
+                                renameGlobals: true
+                            }
+                        );
 
-                it('match #1: should transform class name', () => {
-                    assert.match(obfuscatedCode, classNameIdentifierRegExp);
-                });
+                        obfuscatedCode = obfuscationResult.getObfuscatedCode();
+                    });
 
-                it('match #2: should transform class name', () => {
-                    assert.match(obfuscatedCode, classCallIdentifierRegExp);
+                    it('match #1: should transform identifier name inside class method', () => {
+                        assert.match(obfuscatedCode, identifierRegExp1);
+                    });
+
+                    it('match #2: should transform identifier name inside class method', () => {
+                        assert.match(obfuscatedCode, identifierRegExp2);
+                    });
                 });
             });
         });

test/functional-tests/node-transformers/obfuscating-transformers/class-declaration-transformer/fixtures/rename-globals-identifier-transformation.js

@@ -0,0 +1,11 @@
+class Foo {
+    foo() {
+        const foo = 1;
+    }
+}
+
+class Bar {
+    bar() {
+        const bar = 2;
+    }
+}