Fixed wrong transform object keys behaviour with function default parameters

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

@@ -17,6 +17,7 @@ import { ObjectExpressionTransformer } from '../../../node-transformers/converti
 import { SplitStringTransformer } from '../../../node-transformers/converting-transformers/SplitStringTransformer';
 import { TemplateLiteralTransformer } from '../../../node-transformers/converting-transformers/TemplateLiteralTransformer';
 import { VariableDeclaratorPropertiesExtractor } from '../../../node-transformers/converting-transformers/properties-extractors/VariableDeclaratorPropertiesExtractor';
+import { AssignmentPatternPropertiesExtractor } from '../../../node-transformers/converting-transformers/properties-extractors/AssignmentPatternPropertiesExtractor';
 
 export const convertingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // converting transformers
@@ -49,6 +50,10 @@ export const convertingTransformersModule: interfaces.ContainerModule = new Cont
         .to(AssignmentExpressionPropertiesExtractor)
         .whenTargetNamed(PropertiesExtractor.AssignmentExpressionPropertiesExtractor);
 
+    bind<IPropertiesExtractor>(ServiceIdentifiers.IPropertiesExtractor)
+        .to(AssignmentPatternPropertiesExtractor)
+        .whenTargetNamed(PropertiesExtractor.AssignmentPatternPropertiesExtractor);
+
     bind<IPropertiesExtractor>(ServiceIdentifiers.IPropertiesExtractor)
         .to(BasePropertiesExtractor)
         .whenTargetNamed(PropertiesExtractor.BasePropertiesExtractor);

src/enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractor.ts

@@ -1,5 +1,6 @@
 export enum PropertiesExtractor {
     AssignmentExpressionPropertiesExtractor = 'AssignmentExpressionPropertiesExtractor',
+    AssignmentPatternPropertiesExtractor = 'AssignmentPatternPropertiesExtractor',
     BasePropertiesExtractor = 'BasePropertiesExtractor',
     VariableDeclaratorPropertiesExtractor = 'VariableDeclaratorPropertiesExtractor'
 }

src/enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult.ts

@@ -0,0 +1,3 @@
+export enum PropertiesExtractorFlag {
+    Skip = 'skip'
+}

src/interfaces/node-transformers/converting-transformers/properties-extractors/IPropertiesExtractor.ts

@@ -1,13 +1,15 @@
 import * as ESTree from 'estree';
 
+import { TPropertiesExtractorResult } from '../../../../types/node-transformers/TPropertiesExtractorResult';
+
 export interface IPropertiesExtractor {
     /**
      * @param {ObjectExpression} objectExpressionNode
      * @param {Node} hostNode
-     * @returns {Node}
+     * @returns {TPropertiesExtractorResult}
      */
     extract (
         objectExpressionNode: ESTree.ObjectExpression,
         hostNode: ESTree.Node
-    ): ESTree.Node;
+    ): TPropertiesExtractorResult;
 }

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

@@ -4,6 +4,7 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 import * as ESTree from 'estree';
 
 import { TPropertiesExtractorFactory } from '../../types/container/node-transformers/TPropertiesExtractorFactory';
+import { TPropertiesExtractorResult } from '../../types/node-transformers/TPropertiesExtractorResult';
 
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IPropertiesExtractor } from '../../interfaces/node-transformers/converting-transformers/properties-extractors/IPropertiesExtractor';
@@ -12,6 +13,7 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { NodeType } from '../../enums/node/NodeType';
 import { PropertiesExtractor } from '../../enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractor';
+import { PropertiesExtractorFlag } from '../../enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult';
 import { TransformationStage } from '../../enums/node-transformers/TransformationStage';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
@@ -19,11 +21,17 @@ import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
 export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
+    /**
+     * @type {Set<ESTree.Node>}
+     */
+    private static readonly objectExpressionNodesToSkipSet: Set<ESTree.Node> = new Set();
+
     /**
      * @type {Map<string, PropertiesExtractor>}
      */
     private static readonly propertiesExtractorsMap: Map <string, PropertiesExtractor> = new Map([
         [NodeType.AssignmentExpression, PropertiesExtractor.AssignmentExpressionPropertiesExtractor],
+        [NodeType.AssignmentPattern, PropertiesExtractor.AssignmentPatternPropertiesExtractor],
         [NodeType.VariableDeclarator, PropertiesExtractor.VariableDeclaratorPropertiesExtractor]
     ]);
 
@@ -110,9 +118,7 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
             return objectExpressionNode;
         }
 
-        const propertiesExtractor: IPropertiesExtractor = this.propertiesExtractorFactory(propertiesExtractorName);
-
-        return propertiesExtractor.extract(objectExpressionNode, parentNode);
+        return this.transformNodeWithExtractor(objectExpressionNode, parentNode, propertiesExtractorName);
     }
 
     /**
@@ -137,8 +143,36 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
             return objectExpressionNode;
         }
 
-        const propertiesExtractor: IPropertiesExtractor = this.propertiesExtractorFactory(PropertiesExtractor.BasePropertiesExtractor);
+        if (ObjectExpressionKeysTransformer.objectExpressionNodesToSkipSet.has(objectExpressionNode)) {
+            return objectExpressionNode;
+        }
+
+        return this.transformNodeWithExtractor(objectExpressionNode, parentNode, PropertiesExtractor.BasePropertiesExtractor);
+    }
+
+    /**
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {Node} parentNode
+     * @param {PropertiesExtractor} propertiesExtractorName
+     * @returns {Node}
+     */
+    private transformNodeWithExtractor (
+        objectExpressionNode: ESTree.ObjectExpression,
+        parentNode: ESTree.Node,
+        propertiesExtractorName: PropertiesExtractor
+    ): ESTree.Node {
+        const propertiesExtractor: IPropertiesExtractor = this.propertiesExtractorFactory(propertiesExtractorName);
+        const extractedResult: TPropertiesExtractorResult =
+            propertiesExtractor.extract(objectExpressionNode, parentNode);
+
+        switch (extractedResult) {
+            case PropertiesExtractorFlag.Skip:
+                ObjectExpressionKeysTransformer.objectExpressionNodesToSkipSet.add(objectExpressionNode);
 
-        return propertiesExtractor.extract(objectExpressionNode, parentNode);
+                return objectExpressionNode;
+
+            default:
+                return extractedResult;
+        }
     }
 }

src/node-transformers/converting-transformers/properties-extractors/AbstractPropertiesExtractor.ts

@@ -4,6 +4,7 @@ import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 import * as ESTree from 'estree';
 
 import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
+import { TPropertiesExtractorResult } from '../../../types/node-transformers/TPropertiesExtractorResult';
 
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IPropertiesExtractor } from '../../../interfaces/node-transformers/converting-transformers/properties-extractors/IPropertiesExtractor';
@@ -91,12 +92,12 @@ export abstract class AbstractPropertiesExtractor implements IPropertiesExtracto
     /**
      * @param {ObjectExpression} objectExpressionNode
      * @param {Node} hostNode
-     * @returns {Node}
+     * @returns {TPropertiesExtractorResult}
      */
     public abstract extract (
         objectExpressionNode: ESTree.ObjectExpression,
         hostNode: ESTree.Node
-    ): ESTree.Node;
+    ): TPropertiesExtractorResult;
 
     /**
      * @param {Property[]} properties

src/node-transformers/converting-transformers/properties-extractors/AssignmentExpressionPropertiesExtractor.ts

@@ -3,6 +3,8 @@ import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
+import { TPropertiesExtractorResult } from '../../../types/node-transformers/TPropertiesExtractorResult';
+
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 
@@ -54,12 +56,12 @@ export class AssignmentExpressionPropertiesExtractor extends AbstractPropertiesE
     /**
      * @param {ObjectExpression} objectExpressionNode
      * @param {AssignmentExpression} hostNode
-     * @returns {Node}
+     * @returns {TPropertiesExtractorResult}
      */
     public extract (
         objectExpressionNode: ESTree.ObjectExpression,
         hostNode: ESTree.AssignmentExpression
-    ): ESTree.Node {
+    ): TPropertiesExtractorResult {
         const hostParentNode: ESTree.Node | undefined = hostNode.parentNode;
         const leftNode: ESTree.MemberExpression | ESTree.Pattern = hostNode.left;
 

src/node-transformers/converting-transformers/properties-extractors/AssignmentPatternPropertiesExtractor.ts

@@ -0,0 +1,123 @@
+import { inject, injectable } from 'inversify';
+import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
+
+import * as estraverse from 'estraverse';
+import * as ESTree from 'estree';
+
+import { TObjectExpressionKeysTransformerCustomNodeFactory } from '../../../types/container/custom-nodes/TObjectExpressionKeysTransformerCustomNodeFactory';
+import { TPropertiesExtractorResult } from '../../../types/node-transformers/TPropertiesExtractorResult';
+
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+
+import { PropertiesExtractorFlag } from '../../../enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult';
+
+import { AbstractPropertiesExtractor } from './AbstractPropertiesExtractor';
+import { BasePropertiesExtractor } from './BasePropertiesExtractor';
+import { NodeGuards } from '../../../node/NodeGuards';
+
+@injectable()
+export class AssignmentPatternPropertiesExtractor extends BasePropertiesExtractor {
+    /**
+     * @param {IRandomGenerator} randomGenerator
+     * @param {IOptions} options
+     * @param {TObjectExpressionKeysTransformerCustomNodeFactory} objectExpressionKeysTransformerCustomNodeFactory
+     */
+    constructor (
+        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
+        @inject(ServiceIdentifiers.IOptions) options: IOptions,
+        @inject(ServiceIdentifiers.Factory__IObjectExpressionKeysTransformerCustomNode)
+            objectExpressionKeysTransformerCustomNodeFactory: TObjectExpressionKeysTransformerCustomNodeFactory,
+    ) {
+        super(randomGenerator, options, objectExpressionKeysTransformerCustomNodeFactory);
+    }
+
+    /**
+     * @param {AssignmentPattern} hostNode
+     * @returns {boolean}
+     */
+    private static isProhibitedHostParent (hostNode: ESTree.AssignmentPattern): boolean {
+        const hostParentNode: ESTree.Node | undefined = hostNode.parentNode;
+
+        if (!hostParentNode) {
+            return true;
+        }
+
+        if (NodeGuards.isFunctionNode(hostParentNode)) {
+            return AssignmentPatternPropertiesExtractor.isProhibitedHostParentFunction(hostNode, hostParentNode);
+        }
+
+        return false;
+    }
+
+    /**
+     * @param {AssignmentExpression} hostNode
+     * @param {Function} hostParentNode
+     * @returns {boolean}
+     */
+    private static isProhibitedHostParentFunction (
+        hostNode: ESTree.AssignmentPattern,
+        hostParentNode: ESTree.Function
+    ): boolean {
+        const { params } = hostParentNode;
+        const indexOfParameter: number = params.indexOf(hostNode);
+        const isFirstParameter: boolean = indexOfParameter === 0;
+
+        const parametersBeforeCurrentParameter: ESTree.Pattern[] = params.slice(0, indexOfParameter + 1);
+        const parametersIdentifierNamesSet: Set<string> = new Set();
+
+        let isProhibitedNode: boolean = false;
+
+        // should mark node as prohibited if identifier of node using inside previous function parameters
+        for (const parameter of parametersBeforeCurrentParameter) {
+            estraverse.traverse(parameter, {
+                enter: (node: ESTree.Node): void | estraverse.VisitorOption => {
+                    if (!NodeGuards.isIdentifierNode(node)) {
+                        return;
+                    }
+
+                    if (!isFirstParameter && parametersIdentifierNamesSet.has(node.name)) {
+                        isProhibitedNode = true;
+
+                        return estraverse.VisitorOption.Break;
+                    }
+
+                    parametersIdentifierNamesSet.add(node.name);
+                }
+            });
+
+            if (isProhibitedNode) {
+                break;
+            }
+        }
+
+        return isProhibitedNode;
+    }
+
+    /**
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {AssignmentPattern} hostNode
+     * @returns {TPropertiesExtractorResult}
+     */
+    public extract (
+        objectExpressionNode: ESTree.ObjectExpression,
+        hostNode: ESTree.AssignmentPattern
+    ): TPropertiesExtractorResult {
+        const leftNode: ESTree.Pattern = hostNode.left;
+
+        // left node shouldn't be as Pattern node
+        if (AbstractPropertiesExtractor.isProhibitedPattern(leftNode)) {
+            return objectExpressionNode;
+        }
+
+        // left node shouldn't be as prohibited node
+        if (AssignmentPatternPropertiesExtractor.isProhibitedHostParent(hostNode)) {
+            return PropertiesExtractorFlag.Skip;
+        }
+
+        return this.transformObjectExpressionNode(
+            objectExpressionNode,
+            leftNode
+        );
+    }
+}

src/node-transformers/converting-transformers/properties-extractors/BasePropertiesExtractor.ts

@@ -5,6 +5,7 @@ import * as ESTree from 'estree';
 
 import { TNodeWithStatements } from '../../../types/node/TNodeWithStatements';
 import { TObjectExpressionKeysTransformerCustomNodeFactory } from '../../../types/container/custom-nodes/TObjectExpressionKeysTransformerCustomNodeFactory';
+import { TPropertiesExtractorResult } from '../../../types/node-transformers/TPropertiesExtractorResult';
 import { TStatement } from '../../../types/node/TStatement';
 
 import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
@@ -45,12 +46,12 @@ export class BasePropertiesExtractor extends AbstractPropertiesExtractor {
     /**
      * @param {ObjectExpression} objectExpressionNode
      * @param {Node} parentNode
-     * @returns {Node}
+     * @returns {TPropertiesExtractorResult}
      */
     public extract (
         objectExpressionNode: ESTree.ObjectExpression,
         parentNode: ESTree.Node
-    ): ESTree.Node {
+    ): TPropertiesExtractorResult {
         return this.transformObjectExpressionNode(
             objectExpressionNode,
             parentNode

src/node-transformers/converting-transformers/properties-extractors/VariableDeclaratorPropertiesExtractor.ts

@@ -4,6 +4,8 @@ import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
 import * as estraverse from 'estraverse';
 import * as ESTree from 'estree';
 
+import { TPropertiesExtractorResult } from '../../../types/node-transformers/TPropertiesExtractorResult';
+
 import { IOptions } from '../../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
 
@@ -26,12 +28,12 @@ export class VariableDeclaratorPropertiesExtractor extends AbstractPropertiesExt
     /**
      * @param {ObjectExpression} objectExpressionNode
      * @param {VariableDeclarator} hostNode
-     * @returns {Node}
+     * @returns {TPropertiesExtractorResult}
      */
     public extract (
         objectExpressionNode: ESTree.ObjectExpression,
         hostNode: ESTree.VariableDeclarator
-    ): ESTree.Node {
+    ): TPropertiesExtractorResult {
         if (
             !NodeGuards.isIdentifierNode(hostNode.id)
             || this.isProhibitedObjectExpressionNode(objectExpressionNode, hostNode.id)

src/types/node-transformers/TPropertiesExtractorResult.ts

@@ -0,0 +1,5 @@
+import * as ESTree from 'estree';
+
+import { PropertiesExtractorFlag } from '../../enums/node-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult';
+
+export type TPropertiesExtractorResult = ESTree.Node | PropertiesExtractorFlag;

test/dev/dev.ts

@@ -15,7 +15,8 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
-            transformObjectKeys: true
+            transformObjectKeys: true,
+            compact: false
         }
     ).getObfuscatedCode();
 

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

@@ -367,6 +367,32 @@ describe('ObjectExpressionKeysTransformer', () => {
                     assert.match(obfuscatedCode,  regExp);
                 });
             });
+
+            describe('Variant #3', () => {
+                const match: string = `` +
+                    `var *${variableMatch} *= *0x1, *${variableMatch} *= *{};` +
+                    `${variableMatch}\\['foo'] *= *${variableMatch};` +
+                ``;
+                const regExp: RegExp = new RegExp(match);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/variable-declarator-with-object-call-6.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            transformObjectKeys: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('should transform object keys', () => {
+                    assert.match(obfuscatedCode,  regExp);
+                });
+            });
         });
 
         describe('Variant #12: assignment expression and member expression', () => {
@@ -452,6 +478,33 @@ describe('ObjectExpressionKeysTransformer', () => {
                 assert.match(obfuscatedCode,  regExp);
             });
         });
+
+        describe('Variant #15: function default values', () => {
+            const match: string = `` +
+                `var *${variableMatch} *= *{};` +
+                `${variableMatch}\\['value'] *= *0x1;` +
+                `function test *\\(${variableMatch} *= *0x1, *${variableMatch} *= *${variableMatch}\\) *{ *}` +
+            ``;
+            const regExp: RegExp = new RegExp(match);
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/function-default-values.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        transformObjectKeys: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('shouldn ignore default parameter object if it references other parameter', () => {
+                assert.match(obfuscatedCode,  regExp);
+            });
+        });
     });
 
     describe('member expression as host of object expression', () => {
@@ -460,7 +513,7 @@ describe('ObjectExpressionKeysTransformer', () => {
                 `this\\['state'] *= *{};` +
                 `this\\['state']\\['foo'] *= *'bar';` +
                 `this\\['state']\\['baz'] *= *'bark';` +
-                ``;
+            ``;
             const regExp: RegExp = new RegExp(match);
 
             let obfuscatedCode: string;
@@ -487,7 +540,7 @@ describe('ObjectExpressionKeysTransformer', () => {
                 `this\\['state']\\['foo'] *= *{};` +
                 `this\\['state']\\['foo']\\['foo'] *= *'bar';` +
                 `this\\['state']\\['foo']\\['baz'] *= *'bark';` +
-                ``;
+            ``;
             const regExp: RegExp = new RegExp(match);
 
             let obfuscatedCode: string;
@@ -518,7 +571,7 @@ describe('ObjectExpressionKeysTransformer', () => {
                     `var *${variableMatch} *= *{};` +
                     `${variableMatch}\\['foo'] *= *'bar';` +
                     `}` +
-                    ``;
+                ``;
                 const regExp: RegExp = new RegExp(match);
 
                 let obfuscatedCode: string;
@@ -1176,5 +1229,30 @@ describe('ObjectExpressionKeysTransformer', () => {
                 assert.match(obfuscatedCode,  regExp);
             });
         });
+
+        describe('Variant #3: function default value reference', () => {
+            const match: string = `` +
+                `function test *\\(${variableMatch} *= *0x1, *${variableMatch} *= *{'value' *: *${variableMatch}}\\) *{ *}` +
+            ``;
+            const regExp: RegExp = new RegExp(match);
+
+            let obfuscatedCode: string;
+
+            before(() => {
+                const code: string = readFileAsString(__dirname + '/fixtures/function-default-value-reference.js');
+
+                obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                    code,
+                    {
+                        ...NO_ADDITIONAL_NODES_PRESET,
+                        transformObjectKeys: true
+                    }
+                ).getObfuscatedCode();
+            });
+
+            it('shouldn ignore default parameter object if it references other parameter', () => {
+                assert.match(obfuscatedCode,  regExp);
+            });
+        });
     });
 });

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/function-default-value-reference.js

@@ -0,0 +1 @@
+function test (param1 = 1, param2 = {value: param1}) {}

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/function-default-values.js

@@ -0,0 +1 @@
+function test (param1 = 1, param2 = {value: 1}) {}

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/variable-declarator-with-object-call-6.js

@@ -0,0 +1,4 @@
+(function () {
+    var object = 1,
+        variable = {foo: object};
+})();