To increase performance and prevent possible runtime errors `transformObjectKeys` option now completely ignores objects with `NewExpression` nodes

CHANGELOG.md

@@ -2,7 +2,7 @@ Change Log
 
 v2.15.6
 ---
-* To increase performance and prevent possible runtime errors `transformObjectKeys` option now completely ignores objects with `CallExpression` nodes. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/948
+* To increase performance and prevent possible runtime errors `transformObjectKeys` option now completely ignores objects with `CallExpression` or `NewExpression` nodes. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/948
 
 v2.15.5
 ---

src/enums/node/NodeType.ts

@@ -35,6 +35,7 @@ export enum NodeType {
     LogicalExpression = 'LogicalExpression',
     MemberExpression = 'MemberExpression',
     MethodDefinition = 'MethodDefinition',
+    NewExpression = 'NewExpression',
     ObjectExpression = 'ObjectExpression',
     ObjectPattern = 'ObjectPattern',
     Program = 'Program',

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

@@ -162,21 +162,24 @@ export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
      * @returns {boolean}
      */
     private static isObjectExpressionWithCallExpression (objectExpressionNode: ESTree.ObjectExpression): boolean {
-        let isObjectExpressionWithCallExpressionValue: boolean = false;
+        let isCallExpressionLikeNodeFound: boolean = false;
 
         estraverse.traverse(objectExpressionNode, {
             enter: (node: ESTree.Node): void | estraverse.VisitorOption => {
-                if (!NodeGuards.isCallExpressionNode(node)) {
+                const isCallExpressionLikeNode = NodeGuards.isCallExpressionNode(node)
+                    || NodeGuards.isNewExpressionNode(node);
+
+                if (!isCallExpressionLikeNode) {
                     return;
                 }
 
-                isObjectExpressionWithCallExpressionValue = true;
+                isCallExpressionLikeNodeFound = true;
 
                 return estraverse.VisitorOption.Break;
             }
         });
 
-        return isObjectExpressionWithCallExpressionValue;
+        return isCallExpressionLikeNodeFound;
     }
 
     /**

src/node/NodeGuards.ts

@@ -317,6 +317,14 @@ export class NodeGuards {
         return node.type === NodeType.MethodDefinition;
     }
 
+    /**
+     * @param {Node} node
+     * @returns {boolean}
+     */
+    public static isNewExpressionNode (node: ESTree.Node): node is ESTree.NewExpression {
+        return node.type === NodeType.NewExpression;
+    }
+
     /**
      * @param {Object} object
      * @returns {boolean}

test/dev/dev.ts

@@ -7,17 +7,23 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscationResult = JavaScriptObfuscator.obfuscate(
         `
-            console.log('foo');
-            console.log('bar');
-            console.log('bar');
+            const isTrue = something => !!(something?.bob || something?.sally);
+            const throwsError = () => {
+              throw new Error("Should not be here!");
+            };
+           
+            const myFunction2 = () => {
+              return isTrue() ? { my: "object", nested: { anotherParam: new throwsError() } } : "The only place we should be";
+            };
+           
+            
+            console.log(myFunction2());
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
             compact: false,
             simplify: false,
-            stringArray: true,
-            stringArrayThreshold: 1,
-            stringArrayEncoding: ['base64'],
+            transformObjectKeys: true,
             identifierNamesGenerator: 'mangled'
         }
     );

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

@@ -2427,5 +2427,122 @@ describe('ObjectExpressionKeysTransformer', () => {
                 });
             });
         });
+
+        describe('Variant #19: new expression as property value', () => {
+            describe('Variant #1: new expression as a direct property value', () => {
+                const match: string = `` +
+                    `var ${variableMatch} *= *{` +
+                        `'foo': *'bar',` +
+                        `'baz': *new ${variableMatch}\\(\\)` +
+                    `}` +
+                ``;
+                const regExp: RegExp = new RegExp(match);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/new-expression-1.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            transformObjectKeys: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('shouldn ignore object expression if it contains a new expression as a direct property value', () => {
+                    assert.match(obfuscatedCode,  regExp);
+                });
+            });
+
+            describe('Variant #2: new expression as an indirect property value', () => {
+                const match: string = `` +
+                    `var ${variableMatch} *= *{` +
+                        `'foo': *'bar',` +
+                        `'baz': *'call' *\\+ *new ${variableMatch}\\(\\)` +
+                    `}` +
+                ``;
+                const regExp: RegExp = new RegExp(match);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/new-expression-2.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            transformObjectKeys: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('shouldn ignore object expression if it contains a new expression as an indirect property value', () => {
+                    assert.match(obfuscatedCode,  regExp);
+                });
+            });
+
+            describe('Variant #3: new expression as a nested object expression as property value', () => {
+                const match: string = `` +
+                    `var ${variableMatch} *= *{` +
+                        `'foo': *'bar',` +
+                        `'baz': *{` +
+                            `'bark': *new ${variableMatch}\\(\\)` +
+                        `}` +
+                    `}` +
+                ``;
+                const regExp: RegExp = new RegExp(match);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/new-expression-3.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            transformObjectKeys: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('shouldn ignore object expression if it contains a new expression as a nested object expression as property value', () => {
+                    assert.match(obfuscatedCode,  regExp);
+                });
+            });
+
+            describe('Variant #4: new expression as a a property value after object expression property', () => {
+                const match: string = `` +
+                    `var ${variableMatch} *= *{` +
+                        `'foo': *'bar',` +
+                        `'baz': *${variableMatch},` +
+                        `'eagle': *new ${variableMatch}\\(\\)` +
+                    `}` +
+                ``;
+                const regExp: RegExp = new RegExp(match);
+
+                let obfuscatedCode: string;
+
+                before(() => {
+                    const code: string = readFileAsString(__dirname + '/fixtures/new-expression-4.js');
+
+                    obfuscatedCode = JavaScriptObfuscator.obfuscate(
+                        code,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            transformObjectKeys: true
+                        }
+                    ).getObfuscatedCode();
+                });
+
+                it('shouldn ignore object expression if it contains a new expression and the previous property value is object expression', () => {
+                    assert.match(obfuscatedCode,  regExp);
+                });
+            });
+        });
     });
 });

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/new-expression-1.js

@@ -0,0 +1,7 @@
+(function(){
+    var func = () => {};
+    var object = {
+        foo: 'bar',
+        baz: new func()
+    };
+})();

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/new-expression-2.js

@@ -0,0 +1,7 @@
+(function(){
+    var func = () => {};
+    var object = {
+        foo: 'bar',
+        baz: `call${new func()}`
+    };
+})();

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/new-expression-3.js

@@ -0,0 +1,9 @@
+(function(){
+    var func = () => {};
+    var object = {
+        foo: 'bar',
+        baz: {
+            bark: new func()
+        }
+    };
+})();

test/functional-tests/node-transformers/converting-transformers/object-expression-keys-transformer/fixtures/new-expression-4.js

@@ -0,0 +1,10 @@
+(function(){
+    var func = () => {};
+    var object = {
+        foo: 'bar',
+        baz: {
+            bark: 'hawk'
+        },
+        eagle: new func()
+    };
+})();