js-confuser 1.7.0 → 1.7.1

package/CHANGELOG.md

@@ -1,3 +1,22 @@
+# `1.7.1`
+Updates
+
+- Fixed [#107](https://github.com/MichaelXF/js-confuser/issues/107)
+- - RGF and Integrity clash issue fixed
+
+- Fixed [#106](https://github.com/MichaelXF/js-confuser/issues/106)
+- - Object Extraction to properly handle `const` objects
+
+- Fixed [#105](https://github.com/MichaelXF/js-confuser/issues/105)
+- - Duplicate Literals Removal updated to not cause this error
+
+- Fixed [#103](https://github.com/MichaelXF/js-confuser/issues/103)
+- - Dispatcher will no longer apply to these types of functions to prevent this error
+
+- Added documentation page for [ES5](https://github.com/MichaelXF/js-confuser/blob/master/docs/ES5.md)
+
+- Rollup Plugin created: https://github.com/ayecue/rollup-js-confuser (Thanks @ayecue !)
+
 # `1.7.0`
 Updates
 

package/README.md

@@ -737,7 +737,6 @@ function iVQoGQD(...iVQoGQD){
   stringSplitting: 0.75,
 
   // Use at own risk
-  eval: false,
   rgf: false
 }
 ```
@@ -828,7 +827,6 @@ These features are experimental or a security concern.
 ```js
 {
   target: "node",
-  eval: true, // (security concern)
   rgf: true, // (security concern)
 
   // set to false for web-related scripts

package/dist/transforms/dispatcher.js

@@ -123,6 +123,12 @@ class Dispatcher extends _transform.default {
                     illegalFnNames.add(name);
                     return "EXIT";
                   }
+                } // Avoid functions with function expressions as they have a different scope
+
+
+                if ((oo.type === "FunctionExpression" || oo.type === "ArrowFunctionExpression") && pp.find(x => x == o.params)) {
+                  illegalFnNames.add(name);
+                  return "EXIT";
                 }
               });
               functionDeclarations[name] = [o, p];

package/dist/transforms/extraction/duplicateLiteralsRemoval.js

@@ -25,6 +25,8 @@ var _random = require("../../util/random");
 
 var _traverse = require("../../traverse");
 
+var _identifiers = require("../../util/identifiers");
+
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
@@ -163,7 +165,10 @@ class DuplicateLiteralsRemoval extends _transform.default {
 
   transform(object, parents) {
     return () => {
-      var value = object.value;
+      if (object.type === "Identifier") {
+        var info = (0, _identifiers.getIdentifierInfo)(object, parents);
+        if (info.isLabel || info.spec.isDefined) return;
+      }
 
       if (object.regex) {
         return;

package/dist/transforms/extraction/objectExtraction.js

@@ -236,7 +236,12 @@ class ObjectExtraction extends _transform.default {
             var v = property.value;
             variableDeclarators.push((0, _gen.VariableDeclarator)(nn, this.addComment(v, "".concat(name, ".").concat(keyName))));
           });
-          declaration.declarations.splice(declaration.declarations.indexOf(declarator), 1, ...variableDeclarators); // update all identifiers that pointed to the old object
+          declaration.declarations.splice(declaration.declarations.indexOf(declarator), 1, ...variableDeclarators);
+
+          if (declaration.kind === "const") {
+            declaration.kind = "var";
+          } // update all identifiers that pointed to the old object
+
 
           objectDefChanges[name] && objectDefChanges[name].forEach(change => {
             if (!change.key) {

package/dist/transforms/rgf.js

@@ -23,6 +23,8 @@ var _identifiers = require("../util/identifiers");
 
 var _insert = require("../util/insert");
 
+var _integrity = _interopRequireDefault(require("./lock/integrity"));
+
 var _transform = _interopRequireDefault(require("./transform"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
@@ -170,7 +172,13 @@ class RGF extends _transform.default {
       });
 
       if (obfuscator.options.lock) {
-        delete obfuscator.options.lock.countermeasures;
+        delete obfuscator.options.lock.countermeasures; // Integrity will not recursively apply to RGF'd functions. This is intended.
+
+        var lockTransform = obfuscator.transforms["Lock"];
+
+        if (lockTransform) {
+          lockTransform.before = lockTransform.before.filter(beforeTransform => !(beforeTransform instanceof _integrity.default));
+        }
       }
 
       var transforms = obfuscator.array.filter(x => x.priority > this.priority);

package/dist/util/identifiers.js

@@ -86,10 +86,11 @@ function getIdentifierInfo(object, parents) {
   }
 
   var varIndex = parents.findIndex(x => x.type == "VariableDeclarator");
-  var isVariableDeclaration = varIndex != -1 && parents[varIndex].id == (parents[varIndex - 1] || object) && parents.find(x => x.type == "VariableDeclaration") && objectPatternCheck(object, parents); // Assignment pattern check!
+  var isVariableDeclaration = varIndex != -1 && parents[varIndex].id == (parents[varIndex - 1] || object) && parents.find(x => x.type == "VariableDeclaration") && objectPatternCheck(object, parents);
+  var functionIndex = parents.findIndex(x => (0, _insert.isFunction)(x)); // Assignment pattern check!
 
   if (isVariableDeclaration) {
-    var slicedParents = parents.slice(0, varIndex - 1);
+    var slicedParents = parents.slice(0, functionIndex != -1 ? Math.min(varIndex, functionIndex) : varIndex);
     var i = 0;
 
     for (var parent of slicedParents) {
@@ -106,7 +107,6 @@ function getIdentifierInfo(object, parents) {
 
   var forIndex = parents.findIndex(x => x.type == "ForStatement");
   var isForInitializer = forIndex != -1 && parents[forIndex].init == (parents[forIndex - 1] || object);
-  var functionIndex = parents.findIndex(x => (0, _insert.isFunction)(x));
   var isFunctionDeclaration = functionIndex != -1 && parents[functionIndex].type == "FunctionDeclaration" && parents[functionIndex].id == object;
   var isNamedFunctionExpression = functionIndex != -1 && parents[functionIndex].type === "FunctionExpression" && parents[functionIndex].id === object;
   var isAFunctionParameter = isFunctionParameter(object, parents);

package/docs/ControlFlowFlattening.md

@@ -137,7 +137,7 @@ while (mJMdMhJ + A1Nyvv + xDwpOk6 != 83) {
 }
 ```
 
-As seen in the example, your code will bee wrapped in a large, complicated switch statement. The makes the behavior of your program very hard to understand and is resistent to deobfuscators. This comes with a large performance reduction.
+As seen in the example, your code will be wrapped in a large, complicated switch statement. The makes the behavior of your program very hard to understand and is resistent to deobfuscators. This comes with a large performance reduction.
 
 ## Flattening Control Structures
 

package/docs/ES5.md

@@ -0,0 +1,197 @@
+## `ES5`
+
+The ES5 option converts most ES6+ features into ES5 compatible code.
+
+Option name: `es5`
+
+Option values: `true/false`
+
+Note: Does not cover all cases such as Promises or Generator functions. Use [Babel](https://babel.dev/).
+
+The ES5 option is intended to undo any ES6 feature the obfuscator adds to your code. If you input ES5 code, and enable the `es5` option, you can be guaranteed to have ES5 compatible output.
+
+## Example
+
+```js
+// Input
+function print(...messages){
+  console.log(...messages); // The spread operator (...) 
+                            // was introduced in ES6!
+}
+
+print("Hello", "World"); // "Hello World"
+
+// Output
+var __p_2580918143;
+function print() {
+    var __p_7607361496;
+    var messages, __p_2591841272 = (__p_7607361496 = Array.prototype.slice.call(arguments), messages = __p_7607361496.slice(0));
+    (__p_2580918143 = console).log.apply(__p_2580918143, [].concat(Array.prototype.slice.call(messages)));
+}
+print('Hello', 'World'); // "Hello World"
+```
+
+## Polyfill Array Methods
+
+When the ES5 option is enabled, array method polyfills will be injected to the top of your script.
+
+```js
+if (!Array.prototype.forEach) {
+    Array.prototype.forEach = function forEach(callback, thisArg) {
+        if (typeof callback !== 'function') {
+            throw new TypeError(callback + ' is not a function');
+        }
+        var array = this;
+        thisArg = thisArg || this;
+        for (var i = 0, l = array.length; i !== l; ++i) {
+            callback.call(thisArg, array[i], i, array);
+        }
+    };
+}
+```
+
+## Destructuring
+
+The ES5 option supports transpiling the destructuring patterns.
+
+```js
+// Input
+var {userName, email} = { userName: "John", email: "email@exampe.com" };
+
+// Output
+var __p_7467473759;
+var userName, email, __p_4755992742 = (__p_7467473759 = {
+        userName: 'John',
+        email: 'email@exampe.com'
+    }, userName = __p_7467473759.userName, email = __p_7467473759.email);
+```
+
+## Spread Operator
+
+The ES5 option supports transpiling the spread operator.
+
+```js
+// Input
+array.push(...objects);
+
+// Output
+var __p_6344935930;
+(__p_6344935930 = array).push.apply(__p_6344935930, [].concat(Array.prototype.slice.call(objects)));
+```
+
+## Template String
+
+The ES5 option supports transpiling template strings.
+
+```js
+// Input
+var myString = `Hello ${userName}`;
+
+// Output
+var myString = 'Hello ' + (userName + '');
+```
+
+## Object getters/setters
+
+The ES5 option supports transpiling getter and setter methods.
+
+```js
+// Input
+var _name;
+var myObject = {
+  get name(){
+    return _name;
+  },
+  set name(newName){
+    _name = newName;
+  }
+};
+
+// Output
+function __p_6886881506(base, computedProps, getters, setters) {
+    for (var i = 0; i < computedProps.length; i++) {
+        base[computedProps[i][0]] = computedProps[i][1];
+    }
+    var keys = Object.create(null);
+    Object.keys(getters).forEach(function (key) {
+        return keys[key] = 1;
+    });
+    Object.keys(setters).forEach(function (key) {
+        return keys[key] = 1;
+    });
+    Object.keys(keys).forEach(function (key) {
+        Object.defineProperty(base, key, {
+            set: setters[key],
+            get: getters[key],
+            configurable: true
+        });
+    });
+    return base;
+}
+var _name;
+var myObject = __p_6886881506({}, [], {
+    'name': function () {
+        return _name;
+    }
+}, {
+    'name': function (newName) {
+        _name = newName;
+    }
+});
+```
+
+## Arrow Functions
+
+The ES5 option converts arrow functions into regular functions.
+
+```js
+// Input
+var print = message => console.log(message);
+
+// Output
+var print = function (message) {
+    return console.log(message);
+};
+```
+
+## Const/Let
+
+The ES5 option converts `const` and `let` to a regular `var` keyword.
+
+```js
+// Input
+let myVar1 = true;
+const myVar2 = "String";
+
+// Output
+var myVar1 = true;
+var myVar2 = 'String';
+```
+
+## Classes
+
+The ES5 option partially supports transpiling classes.
+
+## Reserved Identifiers
+
+The ES5 option will change any illegal uses of reserved identifiers.
+
+```js
+// Input
+var myObject = {true: 1};
+myObject.for = true;
+
+// Output
+var myObject = {"true": 1};
+myObject["for"] = true;
+```
+
+## Features not supported
+
+- Promises
+- Async / Await
+- Generator functions
+- Nullish coalescing
+- Optional chaining
+
+Use [Babel](https://babel.dev/) to transpile these features. JS-Confuser will only support features the obfuscator may potentially add to your code.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser",
-  "version": "1.7.0",
+  "version": "1.7.1",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
@@ -22,7 +22,7 @@
   "author": "MichaelXF",
   "license": "MIT",
   "dependencies": {
-    "acorn": "^8.8.2",
+    "acorn": "^8.10.0",
     "escodegen": "^2.0.0"
   },
   "devDependencies": {

package/src/transforms/dispatcher.ts

@@ -157,6 +157,16 @@ export default class Dispatcher extends Transform {
                     return "EXIT";
                   }
                 }
+
+                // Avoid functions with function expressions as they have a different scope
+                if (
+                  (oo.type === "FunctionExpression" ||
+                    oo.type === "ArrowFunctionExpression") &&
+                  pp.find((x) => x == o.params)
+                ) {
+                  illegalFnNames.add(name);
+                  return "EXIT";
+                }
               });
 
               functionDeclarations[name] = [o, p];

package/src/transforms/extraction/duplicateLiteralsRemoval.ts

@@ -24,6 +24,7 @@ import { ComputeProbabilityMap } from "../../probability";
 import { ok } from "assert";
 import { chance, choice, getRandomInteger } from "../../util/random";
 import { getBlock } from "../../traverse";
+import { getIdentifierInfo } from "../../util/identifiers";
 
 /**
  * [Duplicate Literals Removal](https://docs.jscrambler.com/code-integrity/documentation/transformations/duplicate-literals-removal) replaces duplicate literals with a variable name.
@@ -221,7 +222,10 @@ export default class DuplicateLiteralsRemoval extends Transform {
 
   transform(object: Node, parents: Node[]) {
     return () => {
-      var value = object.value;
+      if (object.type === "Identifier") {
+        var info = getIdentifierInfo(object, parents);
+        if (info.isLabel || info.spec.isDefined) return;
+      }
       if (object.regex) {
         return;
       }

package/src/transforms/extraction/objectExtraction.ts

@@ -316,6 +316,10 @@ export default class ObjectExtraction extends Transform {
             ...variableDeclarators
           );
 
+          if (declaration.kind === "const") {
+            declaration.kind = "var";
+          }
+
           // update all identifiers that pointed to the old object
           objectDefChanges[name] &&
             objectDefChanges[name].forEach((change) => {

package/src/transforms/rgf.ts

@@ -20,6 +20,7 @@ import {
 } from "../util/gen";
 import { getIdentifierInfo } from "../util/identifiers";
 import { prepend, getDefiningContext } from "../util/insert";
+import Integrity from "./lock/integrity";
 import Transform from "./transform";
 
 /**
@@ -200,6 +201,14 @@ export default class RGF extends Transform {
 
       if (obfuscator.options.lock) {
         delete obfuscator.options.lock.countermeasures;
+
+        // Integrity will not recursively apply to RGF'd functions. This is intended.
+        var lockTransform = obfuscator.transforms["Lock"];
+        if (lockTransform) {
+          lockTransform.before = lockTransform.before.filter(
+            (beforeTransform) => !(beforeTransform instanceof Integrity)
+          );
+        }
       }
 
       var transforms = obfuscator.array.filter(

package/src/util/identifiers.ts

@@ -94,9 +94,14 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     parents.find((x) => x.type == "VariableDeclaration") &&
     objectPatternCheck(object, parents);
 
+  var functionIndex = parents.findIndex((x) => isFunction(x));
+
   // Assignment pattern check!
   if (isVariableDeclaration) {
-    var slicedParents = parents.slice(0, varIndex - 1);
+    var slicedParents = parents.slice(
+      0,
+      functionIndex != -1 ? Math.min(varIndex, functionIndex) : varIndex
+    );
     var i = 0;
     for (var parent of slicedParents) {
       var childNode = slicedParents[i - 1] || object;
@@ -113,8 +118,6 @@ export function getIdentifierInfo(object: Node, parents: Node[]) {
     forIndex != -1 &&
     parents[forIndex].init == (parents[forIndex - 1] || object);
 
-  var functionIndex = parents.findIndex((x) => isFunction(x));
-
   var isFunctionDeclaration =
     functionIndex != -1 &&
     parents[functionIndex].type == "FunctionDeclaration" &&

package/test/transforms/dispatcher.test.ts

@@ -373,3 +373,30 @@ test("Variant #16: Don't change functions that use 'eval'", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual(2);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/103
+test("Variant #17: Don't break default parameter, function expression", async () => {
+  var output = await JsConfuser(
+    `
+  var X = "Correct Value";
+
+function printX(
+  getX = function () {
+    return X;
+  }
+) {
+  var X = "Incorrect Value";
+
+  TEST_OUTPUT = getX();
+}
+
+printX();
+  `,
+    { target: "node", dispatcher: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Correct Value");
+});

package/test/transforms/extraction/duplicateLiteralsRemoval.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should remove duplicate literals", async () => {
+test("Variant #1: Remove duplicate literals", async () => {
   var code = `
   
   var TEST_ARRAY = [5,5];
@@ -15,7 +15,7 @@ it("should remove duplicate literals", async () => {
   expect(output).toContain("5");
 });
 
-it("should remove duplicate literals and execute correctly", async () => {
+test("Variant #2: Remove duplicate literals and execute correctly", async () => {
   var code = `
   
   TEST_ARRAY = [5,5];
@@ -36,7 +36,7 @@ it("should remove duplicate literals and execute correctly", async () => {
   expect(TEST_ARRAY).toEqual([5, 5]);
 });
 
-it("should remove 'undefined' and 'null' values", async () => {
+test("Variant #3: Remove 'undefined' and 'null' values", async () => {
   var code = `
   
   TEST_ARRAY = [undefined,undefined,null,null];
@@ -60,7 +60,7 @@ it("should remove 'undefined' and 'null' values", async () => {
   expect(TEST_ARRAY).toEqual([undefined, undefined, null, null]);
 });
 
-it("should not remove empty strings", async () => {
+test("Variant #4: Do not remove empty strings", async () => {
   var code = `
   
   TEST_ARRAY = ['','','',''];
@@ -80,7 +80,7 @@ it("should not remove empty strings", async () => {
   expect(TEST_ARRAY).toEqual(["", "", "", ""]);
 });
 
-it("should work with NaN values", async () => {
+test("Variant #5: Work with NaN values", async () => {
   var code = `
   
   TEST_ARRAY = [NaN];
@@ -98,7 +98,7 @@ it("should work with NaN values", async () => {
   expect(TEST_ARRAY[0] === TEST_ARRAY[0]).toStrictEqual(false);
 });
 
-it("should work on property keys", async () => {
+test("Variant #6: Work on property keys", async () => {
   var code = `
   var myObject = {
     myKey: 100
@@ -124,7 +124,7 @@ it("should work on property keys", async () => {
   expect(TEST_VAR).toStrictEqual(100);
 });
 
-it("should work on class keys", async () => {
+test("Variant #7: Work on class keys", async () => {
   var code = `
   class MyClass {
     myMethod(){
@@ -150,7 +150,7 @@ it("should work on class keys", async () => {
   expect(TEST_VAR).toStrictEqual(100);
 });
 
-it("should not encode constructor key", async () => {
+test("Variant #8: Do not encode constructor key", async () => {
   var code = `
   class MyClass {
     constructor(){
@@ -177,3 +177,16 @@ it("should not encode constructor key", async () => {
 
   expect(TEST_VAR).toStrictEqual(100);
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/105
+test("Variant #9: Undefined as variable name", async () => {
+  var output = await JsConfuser(
+    `
+  var undefined = 0;
+  var undefined = 1;
+  `,
+    { target: "node", duplicateLiteralsRemoval: true }
+  );
+
+  eval(output);
+});

package/test/transforms/extraction/objectExtraction.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should extract properties", async () => {
+test("Variant #1: Extract properties", async () => {
   var code = `
     var TEST_OBJECT = {
       TEST_1: "Hello World",
@@ -34,7 +34,7 @@ it("should extract properties", async () => {
   eval(output);
 });
 
-it("should extract function properties correctly", async () => {
+test("Variant #2: Extract function properties correctly", async () => {
   var code = `
     var TEST_OBJECT = {
       isBoolean: x=>typeof x === "boolean",
@@ -68,7 +68,7 @@ it("should extract function properties correctly", async () => {
   eval(output);
 });
 
-it("should not extract properties on with dynamically added keys", async () => {
+test("Variant #3: Not extract properties on with dynamically added keys", async () => {
   var code = `
     var TEST_OBJECT = {
       first_key: 1
@@ -100,7 +100,7 @@ it("should not extract properties on with dynamically added keys", async () => {
   eval(output);
 });
 
-it("should not extract properties on with dynamically added keys even when in nested contexts", async () => {
+test("Variant #4: Not extract properties on with dynamically added keys even when in nested contexts", async () => {
   var code = `
     var TEST_OBJECT = {
       first_key: 1
@@ -135,7 +135,7 @@ it("should not extract properties on with dynamically added keys even when in ne
   eval(output);
 });
 
-it("should not extract properties on objects with computed properties", async () => {
+test("Variant #5: Not extract properties on objects with computed properties", async () => {
   var code = `
     
     var key = "111"
@@ -166,7 +166,7 @@ it("should not extract properties on objects with computed properties", async ()
   eval(output);
 });
 
-it("should not extract properties on objects with computed properties (string)", async () => {
+test("Variant #6: Not extract properties on objects with computed properties (string)", async () => {
   var code = `
     
     var v = "key";
@@ -197,7 +197,7 @@ it("should not extract properties on objects with computed properties (string)",
   eval(output);
 });
 
-it("should not extract properties on objects when the object is referenced independently", async () => {
+test("Variant #7: Not extract properties on objects when the object is referenced independently", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -229,7 +229,7 @@ it("should not extract properties on objects when the object is referenced indep
   eval(output);
 });
 
-it("should not extract properties on objects when the variable gets redefined", async () => {
+test("Variant #8: Not extract properties on objects when the variable gets redefined", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -260,7 +260,7 @@ it("should not extract properties on objects when the variable gets redefined",
   eval(output);
 });
 
-it("should not extract properties on objects when the variable gets reassigned", async () => {
+test("Variant #9: Not extract properties on objects when the variable gets reassigned", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -292,7 +292,7 @@ it("should not extract properties on objects when the variable gets reassigned",
   eval(output);
 });
 
-it("should not extract properties on objects with methods referencing 'this'", async () => {
+test("Variant #10: Not extract properties on objects with methods referencing 'this'", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -325,7 +325,7 @@ it("should not extract properties on objects with methods referencing 'this'", a
   eval(output);
 });
 
-it("should not extract properties on objects when properties are dynamically deleted", async () => {
+test("Variant #11: Not extract properties on objects when properties are dynamically deleted", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -356,7 +356,7 @@ it("should not extract properties on objects when properties are dynamically del
   eval(output);
 });
 
-it("should not extract properties on objects with computed accessors", async () => {
+test("Variant #12: Not extract properties on objects with computed accessors", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -388,7 +388,7 @@ it("should not extract properties on objects with computed accessors", async ()
   eval(output);
 });
 
-it("should properly use custom callback to exclude certain names from being changed", async () => {
+test("Variant #13: Properly use custom callback to exclude certain names from being changed", async () => {
   var code = `
     
     var TEST_OBJECT = {
@@ -424,7 +424,7 @@ it("should properly use custom callback to exclude certain names from being chan
   eval(output);
 });
 
-it("should not apply to objects with non-init properties (method, set, get)", async () => {
+test("Variant #14: Not apply to objects with non-init properties (method, set, get)", async () => {
   var code = `
     
     var realValue = 0;
@@ -448,7 +448,7 @@ it("should not apply to objects with non-init properties (method, set, get)", as
 });
 
 // https://github.com/MichaelXF/js-confuser/issues/78
-it("should handle objects with spread elements", async () => {
+test("Variant #15: Handle objects with spread elements", async () => {
   var output = await JsConfuser(
     `
     var x = { firstName: "John", lastName: "Doe" }
@@ -467,3 +467,23 @@ it("should handle objects with spread elements", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual({ firstName: "John", lastName: "Doe" });
 });
+
+// https://github.com/MichaelXF/js-confuser/issues/106
+test("Variant #16: Handle const declarations", async () => {
+  var output = await JsConfuser(
+    `
+    const obj = {prop: 0};
+    obj.prop = 1;
+    TEST_OUTPUT = obj.prop;
+`,
+    {
+      target: "node",
+      objectExtraction: true,
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(1);
+});

package/test/transforms/identifier/globalConcealing.test.ts

@@ -1,6 +1,6 @@
 import JsConfuser from "../../../src/index";
 
-it("should hide global names (such as Math)", async () => {
+test("Variant #1: Hide global names (such as Math)", async () => {
   var code = `
   var TEST_RESULT = Math.floor(10.1);
   `;
@@ -16,7 +16,7 @@ it("should hide global names (such as Math)", async () => {
   expect(output).toContain("window");
 });
 
-it("should not rename global variables", async () => {
+test("Variant #2: Do not hide modified identifiers", async () => {
   var code = `
   var Math = 50;
 
@@ -30,3 +30,24 @@ it("should not rename global variables", async () => {
 
   expect(output).toContain("log'](Math)");
 });
+
+test("Variant #3: Properly hide in default parameter, function expression", async () => {
+  var output = await JsConfuser(
+    `
+  function myFunction( myParameter = function(){
+    var myVariable = true;
+    return myVariable;
+  } ) {
+    return myParameter();
+  }
+
+  TEST_OUTPUT = myFunction(); // true
+  `,
+    { target: "node", globalConcealing: true }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual(true);
+});

package/test/transforms/lock/integrity.test.ts

@@ -135,3 +135,27 @@ it("should work on High Preset", async () => {
 
   expect(TEST_OUTPUT).toStrictEqual("Hello World");
 });
+
+it("should work with RGF enabled", async () => {
+  var output = await JsConfuser(
+    `
+  function getTestOutput(){
+    return "Hello World";
+  }
+
+  TEST_OUTPUT = getTestOutput();
+  `,
+    {
+      target: "node",
+      rgf: true,
+      lock: {
+        integrity: true,
+      },
+    }
+  );
+
+  var TEST_OUTPUT;
+  eval(output);
+
+  expect(TEST_OUTPUT).toStrictEqual("Hello World");
+});

package/test/util/identifiers.test.ts

@@ -153,6 +153,27 @@ describe("getIdentifierInfo", () => {
     expect(nonModifiedInfo.spec.isModified).toStrictEqual(false);
     expect(nonModifiedInfo.spec.isReferenced).toStrictEqual(false);
   });
+
+  test("Variant #7: Default parameter, function expression", async () => {
+    var tree = parseSync(`
+      function myFunction( myParameter = function() {
+        var myNestedDeclaration = true;
+      } ){
+
+      }
+    `);
+
+    var myNestedDeclaration = findIdentifier(tree, "myNestedDeclaration");
+    var myNestedDeclarationInfo = getIdentifierInfo(
+      myNestedDeclaration[0],
+      myNestedDeclaration[1]
+    );
+
+    expect(myNestedDeclarationInfo.isVariableDeclaration).toStrictEqual(true);
+    expect(myNestedDeclarationInfo.spec.isDefined).toStrictEqual(true);
+    expect(myNestedDeclarationInfo.spec.isReferenced).toStrictEqual(true);
+    expect(myNestedDeclarationInfo.spec.isModified).toStrictEqual(false);
+  });
 });
 
 describe("validateChain", () => {