sanex3339 · Jan 22, 2020 · Jan 24, 2020
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,7 @@ v0.24.0
 * Dynamic import and `import.meta` support. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/505
 * Now usage of some browser-related options with `target: 'node'` will cause a validation error
 * **CLI:** a file path will be displayed on obfuscation error. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/513
+* Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/516
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/512
 * Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/496
 * **Internal:** switched from `awesome-typescript-loader` on `ts-loader`

diff --git a/dist/index.browser.js b/dist/index.browser.js
diff --git a/dist/index.cli.js b/dist/index.cli.js
diff --git a/dist/index.js b/dist/index.js
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.24.0-rc.0",
+  "version": "0.24.0-rc.1",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

diff --git a/src/container/modules/node-transformers/ConvertingTransformersModule.ts b/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);

diff --git a/...ms/node-transformers/converting-transformers/properties-extractors/PropertiesExtractor.ts b/...ms/node-transformers/converting-transformers/properties-extractors/PropertiesExtractor.ts
@@ -1,5 +1,6 @@
 export enum PropertiesExtractor {
     AssignmentExpressionPropertiesExtractor = 'AssignmentExpressionPropertiesExtractor',
+    AssignmentPatternPropertiesExtractor = 'AssignmentPatternPropertiesExtractor',
     BasePropertiesExtractor = 'BasePropertiesExtractor',
     VariableDeclaratorPropertiesExtractor = 'VariableDeclaratorPropertiesExtractor'
 }
diff --git a/...e-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult.ts b/...e-transformers/converting-transformers/properties-extractors/PropertiesExtractorResult.ts
@@ -0,0 +1,3 @@
+export enum PropertiesExtractorFlag {
+    Skip = 'skip'
+}
diff --git a/...s/node-transformers/converting-transformers/properties-extractors/IPropertiesExtractor.ts b/...s/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;
 }
diff --git a/src/node-transformers/converting-transformers/ObjectExpressionKeysTransformer.ts b/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,18 +13,25 @@ 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';
 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;
+        }
     }
 }
diff --git a/...transformers/converting-transformers/properties-extractors/AbstractPropertiesExtractor.ts b/...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';
@@ -88,15 +89,59 @@ export abstract class AbstractPropertiesExtractor implements IPropertiesExtracto
             || NodeGuards.isRestElementNode(node);
     }
 
+    /**
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {Statement} hostStatement
+     * @returns {boolean}
+     */
+    protected static isProhibitedHostStatement (
+        objectExpressionNode: ESTree.ObjectExpression,
+        hostStatement: ESTree.Statement
+    ): boolean {
+        if (AbstractPropertiesExtractor.isProhibitedVariableDeclarationHostStatement(objectExpressionNode, hostStatement)) {
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Fix of https://github.com/javascript-obfuscator/javascript-obfuscator/issues/516
+     * If object expression is placed inside any expression inside variable declaration with 2+ declarators
+     * - should mark host node as prohibited
+     *
+     * @param {ObjectExpression} objectExpressionNode
+     * @param {Statement} hostStatement
+     * @returns {boolean}
+     */
+    protected static isProhibitedVariableDeclarationHostStatement (
+        objectExpressionNode: ESTree.ObjectExpression,
+        hostStatement: ESTree.Statement
+    ): boolean {
+        if (!NodeGuards.isVariableDeclarationNode(hostStatement)) {
+            return false;
+        }
+
+        if (objectExpressionNode.parentNode && NodeGuards.isVariableDeclaratorNode(objectExpressionNode.parentNode)) {
+            return false;
+        }
+
+        if (hostStatement.declarations.length <= 1) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * @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
@@ -181,11 +226,16 @@ export abstract class AbstractPropertiesExtractor implements IPropertiesExtracto
         objectExpressionNode: ESTree.ObjectExpression,
         memberExpressionHostNode: ESTree.Expression
     ): ESTree.Node {
+        const hostStatement: ESTree.Statement = this.getHostStatement(objectExpressionNode);
+
+        if (AbstractPropertiesExtractor.isProhibitedHostStatement(objectExpressionNode, hostStatement)) {
+            return objectExpressionNode;
+        }
+
         const properties: ESTree.Property[] = objectExpressionNode.properties;
         const [expressionStatements, removablePropertyIds]: [ESTree.ExpressionStatement[], number[]] = this
             .extractPropertiesToExpressionStatements(properties, memberExpressionHostNode);
 
-        const hostStatement: ESTree.Statement = this.getHostStatement(objectExpressionNode);
         const hostNodeWithStatements: TNodeWithStatements = this.getHostNodeWithStatements(
             objectExpressionNode,
             hostStatement

diff --git a/.../converting-transformers/properties-extractors/AssignmentExpressionPropertiesExtractor.ts b/.../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;
 

diff --git a/...ers/converting-transformers/properties-extractors/AssignmentPatternPropertiesExtractor.ts b/...ers/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
+        );
+    }
+}