js-confuser 1.5.9 → 1.7.0

package/README.md

@@ -1,8 +1,8 @@
 # JS Confuser
 
-JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://master--hungry-shannon-c1ce6b.netlify.app/).
+JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_ to read. [Try the web version](https://js-confuser.com).
 
-  [![NPM](https://img.shields.io/badge/NPM-%23000000.svg?style=for-the-badge&logo=npm&logoColor=white)](https://npmjs.com/package/js-confuser) [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/MichaelXF/js-confuser) [![Netlify](https://img.shields.io/badge/netlify-%23000000.svg?style=for-the-badge&logo=netlify&logoColor=#00C7B7)](https://master--hungry-shannon-c1ce6b.netlify.app/)
+  [![NPM](https://img.shields.io/badge/NPM-%23000000.svg?style=for-the-badge&logo=npm&logoColor=white)](https://npmjs.com/package/js-confuser) [![GitHub](https://img.shields.io/badge/github-%23121011.svg?style=for-the-badge&logo=github&logoColor=white)](https://github.com/MichaelXF/js-confuser) [![Netlify](https://img.shields.io/badge/netlify-%23000000.svg?style=for-the-badge&logo=netlify&logoColor=#00C7B7)](https://js-confuser.com)
 
 ## Key features
 
@@ -11,7 +11,7 @@ JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_
 - String concealing
 - Function obfuscation
 - Locks (domainLock, date)
-- [Detect changes to source code](https://github.com/MichaelXF/js-confuser/blob/master/Integrity.md)
+- [Detect changes to source code](https://github.com/MichaelXF/js-confuser/blob/master/docs/Integrity.md)
 
 ## Presets
 
@@ -19,9 +19,9 @@ JS-Confuser comes with three presets built into the obfuscator.
 
 | Preset | Transforms | Performance Reduction | Sample |
 | --- | --- | --- | --- |
-| High | 21/22 | 98% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/high.js) |
-| Medium | 15/22 | 52% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/medium.js) |
-| Low | 10/22 | 30% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/low.js) |
+| High | 22/25 | 98% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/high.js) |
+| Medium | 19/25 | 52% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/medium.js) |
+| Low | 15/25 | 30% | [Sample](https://github.com/MichaelXF/js-confuser/blob/master/samples/low.js) |
 
 You can extend each preset or all go without them entirely.
 
@@ -109,7 +109,7 @@ JsConfuser.obfuscate(`<source code>`, {
   target: "node",
   preset: "high" // | "medium" | "low"
 }).then(obfuscated=>{
-  console.log(obfuscated) // obfuscated is a string
+  console.log(obfuscated); // obfuscated is a string
 })
 ```
 
@@ -119,7 +119,7 @@ Remove's whitespace from the final output. Enabled by default. (`true/false`)
 
 ### `hexadecimalNumbers`
 
-Uses the hexadecimal representation (`50` -> `0x32`) for numbers. (`true/false`)
+Uses the hexadecimal representation for numbers. (`true/false`)
 
 ### `minify`
 
@@ -135,14 +135,79 @@ Does not cover all cases such as Promises or Generator functions. Use [Babel](ht
 
 Determines if variables should be renamed. (`true/false`)
 
-- Potency High
-- Resilience High
-- Cost Medium
+```js
+// Input
+var twoSum = function (nums, target) {
+  var hash = {};
+  var len = nums.length;
+  for (var i = 0; i < len; i++) {
+    if (nums[i] in hash) return [hash[nums[i]], i];
+    hash[target - nums[i]] = i;
+  }
+  return [-1, -1];
+};
+
+var test = function () {
+  var inputNums = [2, 7, 11, 15];
+  var inputTarget = 9;
+  var expectedResult = [0, 1];
+
+  var actualResult = twoSum(inputNums, inputTarget);
+  ok(actualResult[0] === expectedResult[0]);
+  ok(actualResult[1] === expectedResult[1]);
+};
+
+test();
+
+// Output
+var _O2mOcF = function (kB4uXM, w_07HXS) {
+  var ZLTJcx = {};
+  var sXQOaUx = kB4uXM["length"];
+  for (var JYYxEk = 0; JYYxEk < sXQOaUx; JYYxEk++) {
+    if (kB4uXM[JYYxEk] in ZLTJcx) {
+      return [ZLTJcx[kB4uXM[JYYxEk]], JYYxEk];
+    }
+    ZLTJcx[w_07HXS - kB4uXM[JYYxEk]] = JYYxEk;
+  }
+  return [-1, -1];
+};
+var qFaI6S = function () {
+  var fZpeOw = [2, 7, 11, 15];
+  var UJ62R2c = 9;
+  var dG6R0cV = [0, 1];
+  var WgYXwn = _O2mOcF(fZpeOw, UJ62R2c);
+  void (ok(WgYXwn[0] === dG6R0cV[0]), ok(WgYXwn[1] === dG6R0cV[1]));
+};
+qFaI6S();
+```
 
 ### `renameGlobals`
 
 Renames top-level variables, turn this off for web-related scripts. Enabled by default. (`true/false`)
 
+```js
+// Output (Same input from above)
+var twoSum = function (Oc4nmjB, Fk3nptX) {
+  var on_KnCm = {};
+  var lqAauc = Oc4nmjB["length"];
+  for (var mALijp8 = 0; mALijp8 < lqAauc; mALijp8++) {
+    if (Oc4nmjB[mALijp8] in on_KnCm) {
+      return [on_KnCm[Oc4nmjB[mALijp8]], mALijp8];
+    }
+    on_KnCm[Fk3nptX - Oc4nmjB[mALijp8]] = mALijp8;
+  }
+  return [-1, -1];
+};
+var test = function () {
+  var y5ySeZ = [2, 7, 11, 15];
+  var gHYMOm = 9;
+  var aAdj3v = [0, 1];
+  var GnLVHX = twoSum(y5ySeZ, gHYMOm);
+  !(ok(GnLVHX[0] === aAdj3v[0]), ok(GnLVHX[1] === aAdj3v[1]));
+};
+test();
+```
+
 ### `identifierGenerator`
 
 Determines how variables are renamed.
@@ -179,169 +244,325 @@ JsConfuser.obfuscate(code, {
 
 JSConfuser tries to reuse names when possible, creating very potent code.
 
-### `nameRecycling`
+### `controlFlowFlattening`
+
+**⚠️ Significantly impacts performance, use sparingly!**
 
-⚠️ Experimental feature, may break your code!
+Control-flow Flattening hinders program comprehension by creating convoluted switch statements. (`true/false/0-1`)
 
-Attempts to reuse released names.
+Use a number to control the percentage from 0 to 1.
 
-- Potency Medium
-- Resilience High
-- Cost Low
+[Learn more here.](https://github.com/MichaelXF/js-confuser/blob/master/docs/ControlFlowFlattening.md)
 
 ```js
 // Input
-function percentage(x) {
-  var multiplied = x * 100;
-  var floored = Math.floor(multiplied);
-  var output = floored + "%"
-  return output;
+function countTo(num){
+  for ( var i = 1; i <= num; i++ ) {
+    console.log(i);
+  }
 }
 
+var number = 10;
+countTo(number); // 1,2,3,4,5,6,7,8,9,10
+
 // Output
-function percentage(x) {
-  var multiplied = x * 100;
-  var floored = Math.floor(multiplied);
-  multiplied = floored + "%";
-  return multiplied;
+var n2DUka,
+  O7yZ0oU,
+  mJMdMhJ = -337,
+  A1Nyvv = -94,
+  xDwpOk6 = 495,
+  uKcJl2 = {
+    TGCpW6t: "log",
+    qUrjFe: function () {
+      return xDwpOk6 == (126 > mJMdMhJ ? -16 : 34);
+    },
+    YN20IBx: function () {
+      return (A1Nyvv -= 53);
+    },
+    CTW4vwx: -73,
+    PLzWYDx: function () {
+      return (O7yZ0oU = [[385, -94, -282], [10]]);
+    },
+    bW2FK2: function () {
+      return (mJMdMhJ *= 2), (mJMdMhJ += 366);
+    },
+    AfOoRT: function () {
+      return xDwpOk6 == xDwpOk6 + 867;
+    },
+    KTNMdj: function () {
+      if (uKcJl2.AfOoRT()) {
+        typeof ((mJMdMhJ += 0), uKcJl2.Q0I6e4f(), (xDwpOk6 += 0));
+        return "cobTe8G";
+      }
+      typeof (uKcJl2.htRXYx(),
+      (mJMdMhJ += 59),
+      (A1Nyvv -= 537),
+      (xDwpOk6 += uKcJl2.mLuSzZ < mJMdMhJ ? 449 : -33));
+      return "cobTe8G";
+    },
+  };
+while (mJMdMhJ + A1Nyvv + xDwpOk6 != 83) {
+  var yQNDJh = (mJMdMhJ + A1Nyvv + xDwpOk6) * 58 + 54;
+  switch (yQNDJh) {
+    case 750:
+      if (A1Nyvv == 24) {
+        uKcJl2.FxREGd6();
+        break;
+      }
+    case 1214:
+      if (uKcJl2.qUrjFe()) {
+        typeof ((mJMdMhJ *= -8 > xDwpOk6 ? -109 : 2),
+        (mJMdMhJ += 1168),
+        (xDwpOk6 += xDwpOk6 - 1290));
+        break;
+      }
+      function _VSsIw() {
+        var [yQNDJh, _VSsIw] = O7yZ0oU,
+          [L9B14E] = _VSsIw,
+          uTyFFb = 322;
+        while (uTyFFb != 23) {
+          var cBx3ysg = uTyFFb * 48 - 77;
+          switch (cBx3ysg) {
+            case 15379:
+              var IOoqIZ = 1;
+              uTyFFb -= 306;
+              break;
+            case 691:
+              uTyFFb += IOoqIZ <= L9B14E ? 976 : 7;
+              break;
+            case 47539:
+              typeof (console[uKcJl2.TGCpW6t](IOoqIZ), (uTyFFb -= 795));
+              break;
+            case 9379:
+              !(IOoqIZ++, (uTyFFb -= 181));
+          }
+        }
+        return ([mJMdMhJ, A1Nyvv, xDwpOk6] = yQNDJh), (n2DUka = void 0);
+      }
+      (xDwpOk6 == -73 ? parseInt : _VSsIw)();
+      break;
+    case 576:
+      typeof (mJMdMhJ == -4 ? clearImmediate : void 0,
+      uKcJl2.bky8kL(),
+      (xDwpOk6 -= 463));
+      break;
+    case 4172:
+      var L9B14E = 10;
+      void ((O7yZ0oU = [[385, -94, -282], [10]]),
+      (mJMdMhJ -= 187),
+      uKcJl2.YN20IBx(),
+      (xDwpOk6 += 189));
+      break;
+    case 3766:
+      !((uKcJl2.Fpp8x5 = -167),
+      (uKcJl2.mLuSzZ = 144),
+      (uKcJl2.FxREGd6 = function () {
+        return (mJMdMhJ += uKcJl2.Fpp8x5), (xDwpOk6 += 164);
+      }),
+      (uKcJl2.bky8kL = function () {
+        return (A1Nyvv += 537);
+      }),
+      (uKcJl2.Q0I6e4f = function () {
+        return (A1Nyvv += 0);
+      }),
+      (uKcJl2.htRXYx = function () {
+        return (xDwpOk6 = -82);
+      }));
+      var L9B14E = 10;
+      void (uKcJl2.PLzWYDx(), uKcJl2.bW2FK2(), (xDwpOk6 += uKcJl2.CTW4vwx));
+      break;
+    default:
+      if (uKcJl2.KTNMdj() == "cobTe8G") {
+        break;
+      }
+  }
 }
 ```
 
-### `controlFlowFlattening`
-
-⚠️ Significantly impacts performance, use sparingly!
-
-[Control-flow Flattening](https://docs.jscrambler.com/code-integrity/documentation/transformations/control-flow-flattening) hinders program comprehension by creating convoluted switch statements. (`true/false/0-1`)
-
-Use a number to control the percentage from 0 to 1.
-
-- Potency High
-- Resilience High
-- Cost High
-
 ### `globalConcealing`
 
 Global Concealing hides global variables being accessed. (`true/false`)
 
-- Potency Medium
-- Resilience High
-- Cost Low
+```js
+// Input
+console.log("Hello World");
+
+// Output
+yAt1T_y(-93)["log"]("Hello World");
+```
 
 ### `stringCompression`
 String Compression uses LZW's compression algorithm to compress strings. (`true/false/0-1`)
 
 `"console"` -> `inflate('replaĕ!ğğuģģ<~@')`
-- Potency High
-- Resilience Medium
-- Cost Medium
 
 ### `stringConcealing`
 
-[String Concealing](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-concealing) involves encoding strings to conceal plain-text values. (`true/false/0-1`)
+String Concealing involves encoding strings to conceal plain-text values. (`true/false/0-1`)
 
 Use a number to control the percentage of strings.
 
 `"console"` -> `decrypt('<~@rH7+Dert~>')`
    
-- Potency High
-- Resilience Medium
-- Cost Medium
-
 ### `stringEncoding`
 
-[String Encoding](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-encoding) transforms a string into an encoded representation. (`true/false/0-1`)
+String Encoding transforms a string into an encoded representation. (`true/false/0-1`)
 
 Use a number to control the percentage of strings.
 
 `"console"` -> `'\x63\x6f\x6e\x73\x6f\x6c\x65'`
 
-- Potency Low
-- Resilience Low
-- Cost Low
-
 ### `stringSplitting`
 
-[String Splitting](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-splitting) splits your strings into multiple expressions. (`true/false/0-1`)
+String Splitting splits your strings into multiple expressions. (`true/false/0-1`)
 
 Use a number to control the percentage of strings.
 
 `"console"` -> `String.fromCharCode(99) + 'ons' + 'ole'`
 
-- Potency Medium
-- Resilience Medium
-- Cost Medium
-
 ### `duplicateLiteralsRemoval`
 
-[Duplicate Literals Removal](https://docs.jscrambler.com/code-integrity/documentation/transformations/duplicate-literals-removal) replaces duplicate literals with a single variable name. (`true/false`)
-
-- Potency Medium
-- Resilience Low
-- Cost High
+Duplicate Literals Removal replaces duplicate literals with a single variable name. (`true/false`)
 
 ### `dispatcher`
 
 Creates a middleman function to process function calls. (`true/false/0-1`)
 
-- Potency Medium
-- Resilience Medium
-- Cost High
+```js
+// Input
+function print(x){
+  console.log(x);
+}
+
+print("Hello World"); // "Hello World"
+
+// Output
+var RfN5Yz = Object.create(null),
+  GEMxMoq = [];
+typeof ((GEMxMoq = ["Hello World"]), yT9GzM("jlg2V0"));
+function yT9GzM(yT9GzM, ChVrLK, b8q2HVZ) {
+  var RuH38a = {
+      jlg2V0: function (_x5bmV, fslYszl, YbdYYlj) {
+        if (!_x5bmV) {
+          return fslYszl(this, YbdYYlj);
+        }
+        var [yT9GzM] = GEMxMoq;
+        console.log(yT9GzM);
+      },
+    },
+    JwN3oMY;
+  if (ChVrLK == "smHux1f") {
+    GEMxMoq = [];
+  }
+  JwN3oMY =
+    ChVrLK == "DiwMvrE"
+      ? RfN5Yz[yT9GzM] ||
+        (RfN5Yz[yT9GzM] = function (...fslYszl) {
+          GEMxMoq = fslYszl;
+          return RuH38a[yT9GzM].call(this, "vZWlke7");
+        })
+      : RuH38a[yT9GzM]("EuVJE6");
+  return b8q2HVZ == "ePsy9W" ? { occYQrC: JwN3oMY } : JwN3oMY;
+}
+```
+
+### `rgf`
 
-### `eval`
+RGF (Runtime-Generated-Functions) uses the [`new Function(code...)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/Function) syntax to construct executable code from strings. (`true/false/0-1`)
 
-#### **`Security Warning`**
+- **This can break your code.**
+- **Due to the security concerns of arbitrary code execution, you must enable this yourself.**
+- The arbitrary code is also obfuscated.
+
+Note: RGF will only apply to functions that do not rely on any outside-scoped variables. Enable `flatten` along with `rgf` to apply to these functions.
 
-From [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval): Executing JavaScript from a string is an enormous security risk. It is far too easy for a bad actor to run arbitrary code when you use eval(). Never use eval()!
+Note: Does not apply to arrow, async, or generator functions.
 
-Wraps defined functions within eval statements.
+Use a number to control the percentage of functions changed.
 
-- **`false`** - Avoids using the `eval` function. _Default_.
-- **`true`** - Wraps function's code into an `eval` statement.
+[Learn more here.](https://github.com/MichaelXF/js-confuser/blob/master/docs/RGF.md)
 
 ```js
-// Output.js
-var Q4r1__ = {
-  Oo$Oz8t: eval(
-    "(function(YjVpAp){var gniSBq6=kHmsJrhOO;switch(gniSBq6){case'RW11Hj5x':return console;}});"
-  ),
-};
-Q4r1__.Oo$Oz8t("RW11Hj5x");
+// Input
+function printToConsole(message){
+  console.log(message);
+}
+
+printToConsole("Hello World"); // "Hello World"
+
+// Output
+var Ricvq8s = [new Function('function HIGRHaD(ANVivo_){console[\'log\'](ANVivo_)}return HIGRHaD[\'apply\'](this,arguments)')];
+function uhj6obs() {
+    return Ricvq8s[0]['apply'](this, arguments);
+}
+uhj6obs('Hello World'); // "Hello World"
 ```
 
-### `rgf`
 
-RGF (Runtime-Generated-Functions) uses the [`new Function(code...)`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/Function) syntax to construct executable code from strings. (`"all"/true/false`)
+### `flatten`
 
-- **This can break your code. This is also as dangerous as `eval`.**
-- **Due to the security concerns of arbitrary code execution, you must enable this yourself.**
-- The arbitrary code is also obfuscated.
+Brings independent declarations to the highest scope. (`true/false/0-1`)
 
-| Mode | Description |
-| --- | --- |
-| `"all"` | Recursively applies to every scope (slow) |
-| `true` | Applies to the top level only |
-| `false` | Feature disabled |
+This transformation makes functions eligible for the RGF transformation.
+
+Use a number to control the percentage of functions changed.
 
 ```js
 // Input
-function log(x){
-  console.log(x)
-}
+(function(){
+  var stringToPrint = "Hello World";
+  var timesPrinted = 0;
+
+  function printString(){
+    timesPrinted++;
+    console.log(stringToPrint);
+  }
 
-log("Hello World")
+  printString(); // "Hello World"
+})();
 
 // Output
-var C6z0jyO=[new Function('a2Fjjl',"function OqNW8x(OqNW8x){console['log'](OqNW8x)}return OqNW8x(...Array.prototype.slice.call(arguments,1))")];(function(){return C6z0jyO[0](C6z0jyO,...arguments)}('Hello World'))
+var XKlik0N = lP2p9dc(([], pgswImq) => {
+  void (pgswImq.rGFfJKd++, console.log(pgswImq.I6NTID));
+});
+function M5IeIO([], mu63vsS) {
+  var p_hOdnM = "Hello World",
+    X_bU9rL = 0;
+  function Iwe3cJW(...nuTwoiz) {
+    var aNxnp94 = {
+      set rGFfJKd(C9XSMeD) {
+        X_bU9rL = C9XSMeD;
+      },
+      get I6NTID() {
+        return p_hOdnM;
+      },
+      get rGFfJKd() {
+        return X_bU9rL;
+      },
+    };
+    return mu63vsS.PbELcOw(nuTwoiz, aNxnp94);
+  }
+  Iwe3cJW();
+}
+lP2p9dc((...AvydL3) => {
+  var B6ymQf = {
+    get PbELcOw() {
+      return XKlik0N;
+    },
+  };
+  return M5IeIO(AvydL3, B6ymQf);
+})();
+function lP2p9dc(fJxfZW) {
+  return function () {
+    return fJxfZW(...arguments);
+  };
+}
 ```
 
 ### `objectExtraction`
 
 Extracts object properties into separate variables. (`true/false`)
 
-- Potency Medium
-- Resilience Medium
-- Cost Low
-
 ```js
 // Input
 var utils = {
@@ -360,32 +581,16 @@ if ( utils_isString("Hello") ) {
 }
 ```
 
-### `flatten`
-
-Brings independent declarations to the highest scope. (`true/false`)
-
-- Potency Medium
-- Resilience Medium
-- Cost High
-
 ### `deadCode`
 
 Randomly injects dead code. (`true/false/0-1`)
 
 Use a number to control the percentage from 0 to 1.
 
-- Potency Medium
-- Resilience Medium
-- Cost Low 
-
 ### `calculator`
 
 Creates a calculator function to handle arithmetic and logical expressions. (`true/false/0-1`)
 
-- Potency Medium
-- Resilience Medium
-- Cost Low
-
 ### `lock.antiDebug`
 
 Adds `debugger` statements throughout the code. Additionally adds a background function for DevTools detection. (`true/false/0-1`)
@@ -400,36 +605,20 @@ When the program is first able to be used. (`number` or `Date`)
 
 Number should be in milliseconds.
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
-
 ### `lock.endDate`
 
 When the program is no longer able to be used. (`number` or `Date`)
 
 Number should be in milliseconds.
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
-
 ### `lock.domainLock`
 
 Array of regex strings that the `window.location.href` must follow. (`Regex[]` or `string[]`)
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
-
 ### `lock.osLock`
 
 Array of operating-systems where the script is allowed to run. (`string[]`)
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
-
 Allowed values: `"linux"`, `"windows"`, `"osx"`, `"android"`, `"ios"`
 
 Example: `["linux", "windows"]`
@@ -438,38 +627,27 @@ Example: `["linux", "windows"]`
 
 Array of browsers where the script is allowed to run. (`string[]`)
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
-
 Allowed values: `"firefox"`, `"chrome"`, `"iexplorer"`, `"edge"`, `"safari"`, `"opera"`
 
 Example: `["firefox", "chrome"]`
 
-### `lock.nativeFunctions`
+### `lock.selfDefending`
 
-Set of global functions that are native. Such as `require`, `fetch`. If these variables are modified the program crashes.
-Set to `true` to use the default set of native functions. (`string[]/true/false`)
+Prevents the use of code beautifiers or formatters against your code.
 
-- Potency Low
-- Resilience Medium
-- Cost Medium
+[Identical to Obfuscator.io's Self Defending](https://github.com/javascript-obfuscator/javascript-obfuscator#selfdefending)
 
 ### `lock.integrity`
 
 Integrity ensures the source code is unchanged. (`true/false/0-1`)
 
-[Learn more here](https://github.com/MichaelXF/js-confuser/blob/master/Integrity.md).
-
-- Potency Medium
-- Resilience High
-- Cost High
+[Learn more here](https://github.com/MichaelXF/js-confuser/blob/master/docs/Integrity.md).
 
 ### `lock.countermeasures`
 
 A custom callback function to invoke when a lock is triggered. (`string/false`)
 
-[Learn more about the countermeasures function](https://github.com/MichaelXF/js-confuser/blob/master/Countermeasures.md).
+[Learn more about the countermeasures function](https://github.com/MichaelXF/js-confuser/blob/master/docs/Countermeasures.md).
 
 Otherwise, the obfuscator falls back to crashing the process.
 
@@ -477,26 +655,33 @@ Otherwise, the obfuscator falls back to crashing the process.
 
 Moves variable declarations to the top of the context. (`true/false`)
 
-- Potency Medium
-- Resilience Medium
-- Cost Low
+```js
+// Input
+function getAreaOfCircle(radius) {
+  var pi = Math.PI;
+  var radiusSquared = Math.pow(radius, 2);
+  var area = pi * radiusSquared;
 
-### `opaquePredicates`
+  return area;
+}
 
-An [Opaque Predicate](https://en.wikipedia.org/wiki/Opaque_predicate) is a predicate(true/false) that is evaluated at runtime, this can confuse reverse engineers from understanding your code. (`true/false/0-1`)
+// Output
+function getAreaOfCircle(yLu5YB1) {
+  var eUf7Wle, XVYH4D;
+  var F8QuPL = Math["PI"];
+  typeof ((eUf7Wle = Math["pow"](yLu5YB1, 2)), (XVYH4D = F8QuPL * eUf7Wle));
+  return XVYH4D;
+}
+```
+
+### `opaquePredicates`
 
-- Potency Medium
-- Resilience Medium
-- Cost Low
+An Opaque Predicate that is evaluated at runtime, this can confuse reverse engineers from understanding your code. (`true/false/0-1`)
 
 ### `shuffle`
 
 Shuffles the initial order of arrays. The order is brought back to the original during runtime. (`"hash"/true/false/0-1`)
 
-- Potency Medium
-- Resilience Low
-- Cost Low
-
 | Mode | Description |
 | --- | --- |
 | `"hash"`| Array is shifted based on hash of the elements  |
@@ -509,10 +694,6 @@ Local variables are consolidated into a rotating array. (`true/false/0-1`)
 
 [Similar to Jscrambler's Variable Masking](https://docs.jscrambler.com/code-integrity/documentation/transformations/variable-masking)
 
-- Potency Medium
-- Resilience Medium
-- Cost Low
-
 ```js
 // Input
 function add3(x, y, z){
@@ -623,13 +804,13 @@ You must enable locks yourself, and configure them to your needs.
   target: "node",
   lock: {
     integrity: true,
+    selfDefending: true,
     domainLock: ["mywebsite.com"],
     osLock: ["windows", "linux"],
     browserLock: ["firefox"],
     startDate: new Date("Feb 1 2021"),
     endDate: new Date("Mar 1 2021"),
     antiDebug: true,
-    nativeFunctions: true,
 
     // crashes browser
     countermeasures: true,