fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/29

CHANGELOG.md

@@ -1,5 +1,9 @@
 Change Log
 ===
+v0.8.5
+---
+* fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/29
+
 v0.8.4
 ---
 * fixed https://github.com/javascript-obfuscator/webpack-obfuscator/issues/13

dist/index.js

@@ -3023,11 +3023,9 @@ function _possibleConstructorReturn(self, call) { if (!self) { throw new Referen
 function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
 
 var estraverse = __webpack_require__(4);
-var NodeType_1 = __webpack_require__(6);
 var AbstractNodeObfuscator_1 = __webpack_require__(8);
 var IdentifierReplacer_1 = __webpack_require__(12);
 var Node_1 = __webpack_require__(2);
-var NodeUtils_1 = __webpack_require__(1);
 
 var FunctionObfuscator = function (_AbstractNodeObfuscat) {
     _inherits(FunctionObfuscator, _AbstractNodeObfuscat);
@@ -3053,11 +3051,9 @@ var FunctionObfuscator = function (_AbstractNodeObfuscat) {
             var _this2 = this;
 
             functionNode.params.forEach(function (paramsNode) {
-                NodeUtils_1.NodeUtils.typedReplace(paramsNode, NodeType_1.NodeType.Identifier, {
-                    enter: function enter(node) {
-                        return _this2.identifierReplacer.storeNames(node.name);
-                    }
-                });
+                if (Node_1.Node.isIdentifierNode(paramsNode)) {
+                    _this2.identifierReplacer.storeNames(paramsNode.name);
+                }
             });
         }
     }, {
@@ -3505,11 +3501,9 @@ var VariableDeclarationObfuscator = function (_AbstractNodeObfuscat) {
             var _this2 = this;
 
             variableDeclarationNode.declarations.forEach(function (declarationNode) {
-                NodeUtils_1.NodeUtils.typedReplace(declarationNode.id, NodeType_1.NodeType.Identifier, {
-                    enter: function enter(node) {
-                        return _this2.identifierReplacer.storeNames(node.name);
-                    }
-                });
+                if (Node_1.Node.isIdentifierNode(declarationNode.id)) {
+                    _this2.identifierReplacer.storeNames(declarationNode.id.name);
+                }
             });
         }
     }, {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",

src/node-obfuscators/FunctionObfuscator.ts

@@ -4,12 +4,9 @@ import * as ESTree from 'estree';
 import { ICustomNode } from '../interfaces/custom-nodes/ICustomNode';
 import { IOptions } from '../interfaces/IOptions';
 
-import { NodeType } from '../enums/NodeType';
-
 import { AbstractNodeObfuscator } from './AbstractNodeObfuscator';
 import { IdentifierReplacer } from './replacers/IdentifierReplacer';
 import { Node } from '../node/Node';
-import { NodeUtils } from '../node/NodeUtils';
 
 /**
  * replaces:
@@ -49,9 +46,9 @@ export class FunctionObfuscator extends AbstractNodeObfuscator {
     private storeFunctionParams (functionNode: ESTree.Function): void {
         functionNode.params
             .forEach((paramsNode: ESTree.Node) => {
-                NodeUtils.typedReplace(paramsNode, NodeType.Identifier, {
-                    enter: (node: ESTree.Identifier) => this.identifierReplacer.storeNames(node.name)
-                });
+                if (Node.isIdentifierNode(paramsNode)) {
+                    this.identifierReplacer.storeNames(paramsNode.name);
+                }
             });
     }
 

src/node-obfuscators/VariableDeclarationObfuscator.ts

@@ -65,9 +65,9 @@ export class VariableDeclarationObfuscator extends AbstractNodeObfuscator {
     private storeVariableNames (variableDeclarationNode: ESTree.VariableDeclaration): void {
         variableDeclarationNode.declarations
             .forEach((declarationNode: ESTree.VariableDeclarator) => {
-                NodeUtils.typedReplace(declarationNode.id, NodeType.Identifier, {
-                    enter: (node: ESTree.Identifier) => this.identifierReplacer.storeNames(node.name)
-                });
+                if (Node.isIdentifierNode(declarationNode.id)) {
+                    this.identifierReplacer.storeNames(declarationNode.id.name);
+                }
             });
     }
 

test/functional-tests/node-obfuscators/FunctionObfuscator.spec.ts

@@ -39,4 +39,26 @@ describe('FunctionObfuscator', () => {
             assert.equal(functionParamIdentifierName, functionBodyIdentifierName);
         });
     });
+
+    describe('object pattern as argument', () => {
+        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            `
+                (function () {
+                    var test = function ({ bar }) {
+                        return bar;
+                    }
+                })();
+            `,
+            NO_CUSTOM_NODES_PRESET
+        );
+        const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+
+        it('shouldn\'t transform function parameter object pattern identifier', () => {
+            const functionParameterMatch: RegExp = /function *\(\{ *bar *\}\) *\{/;
+            const functionBodyMatch: RegExp = /return *bar;/;
+
+            assert.match(obfuscatedCode, functionParameterMatch);
+            assert.match(obfuscatedCode, functionBodyMatch);
+        });
+    });
 });

test/functional-tests/node-obfuscators/VariableDeclarationObfuscator.spec.ts

@@ -202,4 +202,25 @@ describe('VariableDeclarationObfuscator', () => {
             assert.match(obfuscationResult.getObfuscatedCode(),  /_0x([a-z0-9]){4,6}\['\\x74\\x65\\x73\\x74'\]/);
         });
     });
+
+    describe('object pattern as argument', () => {
+        const obfuscationResult: IObfuscationResult = JavaScriptObfuscator.obfuscate(
+            `
+                (function () {
+                    var { bar } = { bar: 'foo' };
+                    console.log(bar);
+                })();
+            `,
+            NO_CUSTOM_NODES_PRESET
+        );
+        const obfuscatedCode: string = obfuscationResult.getObfuscatedCode();
+
+        it('shouldn\'t transform object pattern variable declarator', () => {
+            const objectPatternVariableDeclarator: RegExp = /var *\{ *bar *\} *= *\{ *'\\x62\\x61\\x72' *: *'\\x66\\x6f\\x6f' *\};/;
+            const variableUsageMatch: RegExp = /console\['\\x6c\\x6f\\x67'\]\(bar\);/;
+
+            assert.match(obfuscatedCode, objectPatternVariableDeclarator);
+            assert.match(obfuscatedCode, variableUsageMatch);
+        });
+    });
 });