js-confuser 2.0.0-alpha.2 → 2.0.0-alpha.4

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+  "tabWidth": 2,
+  "singleQuote": false
+}

package/CHANGELOG.md

@@ -3,10 +3,12 @@
 
 **⚠️ Warning: This an alpha release. This version is not stable and the likelihood of encountering bugs is significantly higher.**
 
-### Complete rewrite of JS-Confuser using Babel!
+### Complete rewrite of JS-Confuser using Babel! 🎉
 
 **⚠️ Breaking changes**
 
+> Check out the [Migration guide](./Migration.md) on how to properly update from 1.X to 2.0. The obfuscation upgrades in 2.0 are worth the small refactoring.
+
 - Revamped API Interface
 
 - - JSConfuser.obfuscate() resolves to an object
@@ -17,13 +19,29 @@
 
 - Renamed `Stack` to `Variable Masking`
 
+- Added configurable limits to options:
+
+```js
+const options = {
+  target: "node",
+
+  rgf: {
+    value: 0.5, // = 50% of eligible functions
+    limit: 10 // Maximum of 10 changes for performance reasons
+  },
+
+  // Original format is still valid (No limit applied)
+  rgf: 0.5
+}
+```
+
 ### 2.0 Changes
 
-- Added Custom String Encoding and Custom Lock Code options
+- Added [Custom String Encoding](https://new--confuser.netlify.app/docs/options/customStringEncodings) and [Custom Lock Code](https://new--confuser.netlify.app/docs/options/customLocks) options
 
-- Added `Rename Labels` Learn more here
+- Added `Rename Labels` [Learn more here](https://new--confuser.netlify.app/docs/options/renamelabels#rename-labels)
 
-- Added `Pack` Learn more here
+- Added `Pack` [Learn more here](https://new--confuser.netlify.app/docs/options/pack#pack)
 
 - RGF no longers uses `new Function` instead uses `eval`
 
@@ -49,11 +67,27 @@
 
 - - [Regular expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions) are now obfuscated (First converted into equivalent RegExp() constructor calls)
 
-- - `String Compression` now uses zlib decompression ([Pako](https://github.com/nodeca/pako))
+- - `String Compression` now uses LZ-string compression ([lz-string](https://www.npmjs.com/package/lz-string))
+
+- New Comment Syntax
+
+- - `/* @js-confuser-var */ "name"` for improved variable mappings for eval() calls
+
+```js
+// Input
+var name = "Internet User";
+eval( "console.log(" + /* @js-confuser-var */ "name" + ")" );
+
+// Output
+var zC3PLKu = "Internet User";
+eval("console.log(" + "zC3PLKu" + ")");
+```
+
+The function `__JS_CONFUSER_VAR__` is identical in outcome and still be used, however, the comment syntax is preferred as the comment syntax's preserves the original script's behavior.
 
 ### JS-Confuser.com Revamp
 
-A new UI for JS-Confuser.com, featuring an advanced playground and documentation pages.
+A new UI for [JS-Confuser.com](https://js-confuser.com), featuring an advanced playground and documentation pages.
 
 The previous version will remain available: [old--confuser.netlify.com](https://old--confuser.netlify.app/)
 
@@ -61,11 +95,11 @@ The previous version will remain available: [old--confuser.netlify.com](https://
 
 - Removed `ES5` option - Use Babel Instead
 
-- Removed `Browser Lock` and `OS Lock` - Use Custom Locks instead
+- Removed `Browser Lock` and `OS Lock` - Use [Custom Locks](https://new--confuser.netlify.app/docs/options/customlocks#custom-locks) instead
 
 - Removed `Shuffle`'s Hash option
 
-- Removed `Indent` option. [`@babel/generator`](https://www.npmjs.com/package/@babel/generator) does not allow customizing the indentation size. Use Prettier if you still wish for 4 space or tabs. Be mindful if you have `Integrity` or `Self Defending` enabled, as you should not alter the obfuscated code.
+- Removed `Indent` option
 
 
 # `1.7.3`

package/Migration.md

@@ -6,15 +6,20 @@ JS-Confuser 2.0 is complete rewrite of the original JS-Confuser created in 2020!
 
 ### JSConfuser.obfuscate() returns an object now
 
-The method `JSConfuser.obfuscate()` resolves to a object now instead of a string. This result object contains the obfuscated code on the `code` property.
+The method `JSConfuser.obfuscate()` resolves to a object now instead of a string. This result object contains a property `code` which is the obfuscated code.
 
 ```diff
-+JSConfuser.obfuscate(sourceCode, options).then(result=>{
-+  console.log(result.code);
-+});
--JSConfuser.obfuscate(sourceCode, options).then(obfuscatedCode=>{
--  console.log(obfuscatedCode);
--});
+const sourceCode = `console.log("Hello World")`;
+const options = {
+  target: "node",
+  preset: "high"
+};
+
+JSConfuser.obfuscate(sourceCode, options).then(result=>{
+  // 'result' is now an object
+- console.log(result);
++ console.log(result.code);
+});
 ```
 
 ### Removed Anti Debug Lock / Browser Lock / OS Lock
@@ -54,4 +59,14 @@ These features have been removed but you can still add these locks using the `lo
 
 The option `stack` has been renamed to `variableMasking`
 
-[Similar to JScrambler's Variable Masking](https://docs.jscrambler.com/code-integrity/documentation/transformations/variable-masking)
+[Similar to JScrambler's Variable Masking](https://docs.jscrambler.com/code-integrity/documentation/transformations/variable-masking)
+
+```diff
+const options = {
+  target: "node",
+  preset: "high"
+
+- stack: true,
++ variableMasking: true
+};
+```

package/README.md

@@ -21,9 +21,9 @@ JS-Confuser is a JavaScript obfuscation tool to make your programs _impossible_
 
 - - [FAQ](https://new--confuser.netlify.app/docs/getting-started/faq)
 
-- [Options](https://new--confuser.netlify.app/docs)
+- [Options](https://new--confuser.netlify.app/docs/options)
 
-- [Presets](https://new--confuser.netlify.app/docs)
+- [Presets](https://new--confuser.netlify.app/docs/presets)
 
 ## API Usage
 

package/dist/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.variableFunctionName = exports.reservedObjectPrototype = exports.reservedKeywords = exports.reservedIdentifiers = exports.predictableFunctionTag = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.WITH_STATEMENT = exports.UNSAFE = exports.SKIP = exports.PREDICTABLE = exports.NO_RENAME = exports.MULTI_TRANSFORM = exports.GEN_NODE = exports.FN_LENGTH = exports.CONTROL_OBJECTS = void 0;
+exports.variableFunctionName = exports.reservedObjectPrototype = exports.reservedNodeModuleIdentifiers = exports.reservedKeywords = exports.reservedIdentifiers = exports.predictableFunctionTag = exports.placeholderVariablePrefix = exports.noRenameVariablePrefix = exports.WITH_STATEMENT = exports.UNSAFE = exports.SKIP = exports.PREDICTABLE = exports.NO_RENAME = exports.NO_REMOVE = exports.MULTI_TRANSFORM = exports.GEN_NODE = exports.FN_LENGTH = void 0;
 var predictableFunctionTag = exports.predictableFunctionTag = "__JS_PREDICT__";
 
 /**
@@ -34,7 +34,6 @@ var SKIP = exports.SKIP = Symbol("skip");
  * Saves the original length of a function.
  */
 var FN_LENGTH = exports.FN_LENGTH = Symbol("fnLength");
-var CONTROL_OBJECTS = exports.CONTROL_OBJECTS = Symbol("controlObjects");
 var NO_RENAME = exports.NO_RENAME = Symbol("noRename");
 
 /**
@@ -60,6 +59,11 @@ var MULTI_TRANSFORM = exports.MULTI_TRANSFORM = Symbol("multiTransform");
  */
 var WITH_STATEMENT = exports.WITH_STATEMENT = Symbol("withStatement");
 
+/**
+ * Tells minify to not remove the node.
+ */
+var NO_REMOVE = exports.NO_REMOVE = Symbol("noRemove");
+
 /**
  * Symbols describe precomputed semantics of a node, allowing the obfuscator to make the best choices for the node.
  */
@@ -75,6 +79,11 @@ var placeholderVariablePrefix = exports.placeholderVariablePrefix = "__p_";
  * Identifiers that are not actually variables.
  */
 var reservedIdentifiers = exports.reservedIdentifiers = new Set(["undefined", "null", "NaN", "Infinity", "eval", "arguments"]);
+
+/**
+ * Reserved Node.JS module identifiers.
+ */
+var reservedNodeModuleIdentifiers = exports.reservedNodeModuleIdentifiers = new Set(["module", "exports", "require"]);
 var reservedObjectPrototype = exports.reservedObjectPrototype = new Set(["toString", "valueOf", "constructor", "__proto__", "hasOwnProperty", "isPrototypeOf", "propertyIsEnumerable", "toLocaleString"]);
 
 /**

package/dist/index.js

@@ -3,10 +3,28 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+Object.defineProperty(exports, "Obfuscator", {
+  enumerable: true,
+  get: function get() {
+    return _obfuscator["default"];
+  }
+});
+Object.defineProperty(exports, "Template", {
+  enumerable: true,
+  get: function get() {
+    return _template["default"];
+  }
+});
 exports["default"] = void 0;
 exports.obfuscate = obfuscate;
 exports.obfuscateAST = obfuscateAST;
 exports.obfuscateWithProfiler = obfuscateWithProfiler;
+Object.defineProperty(exports, "presets", {
+  enumerable: true,
+  get: function get() {
+    return _presets["default"];
+  }
+});
 var _obfuscator = _interopRequireDefault(require("./obfuscator"));
 var _presets = _interopRequireDefault(require("./presets"));
 var _template = _interopRequireDefault(require("./templates/template"));
@@ -53,15 +71,37 @@ function _obfuscateAST() {
   }));
   return _obfuscateAST.apply(this, arguments);
 }
-function obfuscateWithProfiler(_x5, _x6, _x7) {
+function obfuscateWithProfiler(_x5, _x6) {
   return _obfuscateWithProfiler.apply(this, arguments);
 }
 function _obfuscateWithProfiler() {
-  _obfuscateWithProfiler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(sourceCode, options, _profiler) {
-    var startTime, obfuscator, totalTransforms, transformMap, beforeParseTime, ast, parseTime, currentTransformTime, beforeCompileTime, code, compileTime, endTime, obfuscationTime;
+  _obfuscateWithProfiler = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(sourceCode, options) {
+    var _profiler,
+      startTime,
+      obfuscator,
+      totalTransforms,
+      transformMap,
+      beforeParseTime,
+      ast,
+      parseTime,
+      currentTransformTime,
+      beforeCompileTime,
+      code,
+      compileTime,
+      endTime,
+      obfuscationTime,
+      _args3 = arguments;
     return _regeneratorRuntime().wrap(function _callee3$(_context3) {
       while (1) switch (_context3.prev = _context3.next) {
         case 0:
+          _profiler = _args3.length > 2 && _args3[2] !== undefined ? _args3[2] : {};
+          if (!_profiler.performance) {
+            _profiler.performance = {
+              now: function now() {
+                return Date.now();
+              }
+            };
+          }
           startTime = performance.now();
           obfuscator = new _obfuscator["default"](options);
           totalTransforms = obfuscator.plugins.length;
@@ -72,13 +112,15 @@ function _obfuscateWithProfiler() {
           currentTransformTime = performance.now();
           ast = obfuscator.obfuscateAST(ast, {
             profiler: function profiler(log) {
+              var _profiler$callback;
               var nowTime = performance.now();
-              transformMap[log.currentTransform] = {
+              var entry = {
                 transformTime: nowTime - currentTransformTime,
                 changeData: {}
               };
+              transformMap[log.currentTransform] = entry;
               currentTransformTime = nowTime;
-              _profiler.callback(log);
+              (_profiler$callback = _profiler.callback) === null || _profiler$callback === void 0 || _profiler$callback.call(_profiler, log, entry, ast);
             }
           });
           obfuscator.plugins.forEach(function (_ref) {
@@ -103,7 +145,7 @@ function _obfuscateWithProfiler() {
               totalPossibleTransforms: obfuscator.totalPossibleTransforms
             }
           });
-        case 16:
+        case 18:
         case "end":
           return _context3.stop();
       }
@@ -115,6 +157,7 @@ var JsConfuser = {
   obfuscate: obfuscate,
   obfuscateAST: obfuscateAST,
   obfuscateWithProfiler: obfuscateWithProfiler,
+  Obfuscator: _obfuscator["default"],
   presets: _presets["default"],
   Template: _template["default"]
 };

package/dist/obfuscator.js

@@ -9,17 +9,16 @@ var _generator = _interopRequireDefault(require("@babel/generator"));
 var _traverse = _interopRequireDefault(require("@babel/traverse"));
 var _parser = require("@babel/parser");
 var _validateOptions = require("./validateOptions");
-var _probability = require("./probability");
 var _NameGen = require("./utils/NameGen");
 var _order = require("./order");
 var _plugin = require("./transforms/plugin");
+var _objectUtils = require("./utils/object-utils");
 var _preparation = _interopRequireDefault(require("./transforms/preparation"));
 var _renameVariables = _interopRequireDefault(require("./transforms/identifier/renameVariables"));
 var _variableMasking = _interopRequireDefault(require("./transforms/variableMasking"));
 var _dispatcher = _interopRequireDefault(require("./transforms/dispatcher"));
 var _duplicateLiteralsRemoval = _interopRequireDefault(require("./transforms/extraction/duplicateLiteralsRemoval"));
 var _objectExtraction = _interopRequireDefault(require("./transforms/extraction/objectExtraction"));
-var _functionOutlining = _interopRequireDefault(require("./transforms/functionOutlining"));
 var _globalConcealing = _interopRequireDefault(require("./transforms/identifier/globalConcealing"));
 var _stringCompression = _interopRequireDefault(require("./transforms/string/stringCompression"));
 var _deadCode = _interopRequireDefault(require("./transforms/deadCode"));
@@ -87,12 +86,13 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
       }
     });
     _defineProperty(this, "index", 0);
+    _defineProperty(this, "probabilityMapCounter", new WeakMap());
     this.parentObfuscator = parentObfuscator;
     (0, _validateOptions.validateOptions)(userOptions);
     this.options = (0, _validateOptions.applyDefaultsToOptions)(_objectSpread({}, userOptions));
     this.nameGen = new _NameGen.NameGen(this.options.identifierGenerator);
     var shouldAddLockTransform = this.options.lock && (Object.keys(this.options.lock).filter(function (key) {
-      return key !== "customLocks" && (0, _probability.isProbabilityMapProbable)(_this.options.lock[key]);
+      return key !== "customLocks" && _this.isProbabilityMapProbable(_this.options.lock[key]);
     }).length > 0 || this.options.lock.customLocks.length > 0);
     var allPlugins = [];
     var push = function push(probabilityMap) {
@@ -100,7 +100,7 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
         pluginFns[_key - 1] = arguments[_key];
       }
       _this.totalPossibleTransforms += pluginFns.length;
-      if (!(0, _probability.isProbabilityMapProbable)(probabilityMap)) return;
+      if (!_this.isProbabilityMapProbable(probabilityMap)) return;
       allPlugins.push.apply(allPlugins, pluginFns);
     };
     push(true, _preparation["default"]);
@@ -114,10 +114,12 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
     push(this.options.calculator, _calculator["default"]);
     push(this.options.globalConcealing, _globalConcealing["default"]);
     push(this.options.opaquePredicates, _opaquePredicates["default"]);
-    push(this.options.functionOutlining, _functionOutlining["default"]);
     push(this.options.stringSplitting, _stringSplitting["default"]);
     push(this.options.stringConcealing, _stringConcealing["default"]);
-    push(this.options.stringCompression, _stringCompression["default"]);
+    // String Compression is only applied to the main obfuscator
+    // Any RGF functions will not have string compression due to the size of the decompression function
+
+    push(!parentObfuscator && this.options.stringCompression, _stringCompression["default"]);
     push(this.options.variableMasking, _variableMasking["default"]);
     push(this.options.duplicateLiteralsRemoval, _duplicateLiteralsRemoval["default"]);
     push(this.options.shuffle, _shuffle["default"]);
@@ -163,7 +165,10 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
   }
   return _createClass(Obfuscator, [{
     key: "isInternalVariable",
-    value: function isInternalVariable(name) {
+    value:
+    // Pack Interface for sharing globals across RGF functions
+
+    function isInternalVariable(name) {
       return Object.values(this.globalState.internals).includes(name);
     }
   }, {
@@ -231,9 +236,6 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
         var _this$plugins$i = this.plugins[i],
           plugin = _this$plugins$i.plugin,
           pluginInstance = _this$plugins$i.pluginInstance;
-
-        // Skip pack if disabled
-        if (pluginInstance.order === _order.Order.Pack && options !== null && options !== void 0 && options.disablePack) continue;
         if (this.options.verbose) {
           console.log("Applying ".concat(pluginInstance.name, " (").concat(i + 1, "/").concat(this.plugins.length, ")"));
         }
@@ -311,6 +313,115 @@ var Obfuscator = exports["default"] = /*#__PURE__*/function () {
     /**
      * Generates code from an AST using `@babel/generator`
      */
+  }, {
+    key: "computeProbabilityMap",
+    value:
+    /**
+     * Evaluates a ProbabilityMap.
+     * @param map The setting object.
+     * @param customFnArgs Args given to user-implemented function, such as a variable name.
+     */
+    function computeProbabilityMap(map) {
+      for (var _len2 = arguments.length, customImplementationArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        customImplementationArgs[_key2 - 1] = arguments[_key2];
+      }
+      // Check if this probability map uses the {value: ..., limit: ...} format
+      if (_typeof(map) === "object" && map && "value" in map) {
+        // Check for the limit property
+        if ("limit" in map && typeof map.limit === "number" && map.limit >= 0) {
+          // Check if the limit has been reached
+          if (this.probabilityMapCounter.get(map) >= map.limit) {
+            return false;
+          }
+        }
+        var value = this.computeProbabilityMap.apply(this, [map.value].concat(customImplementationArgs));
+        if (value) {
+          // Increment the counter for this map
+          this.probabilityMapCounter.set(map, this.probabilityMapCounter.get(map) + 1 || 1);
+        }
+        return value;
+      }
+      if (!map) {
+        return false;
+      }
+      if (map === true || map === 1) {
+        return true;
+      }
+      if (typeof map === "number") {
+        return Math.random() < map;
+      }
+      if (typeof map === "function") {
+        return map.apply(void 0, customImplementationArgs);
+      }
+      if (typeof map === "string") {
+        return map;
+      }
+      var asObject = {};
+      if (Array.isArray(map)) {
+        map.forEach(function (x) {
+          asObject[x.toString()] = 1;
+        });
+      } else {
+        asObject = map;
+      }
+      var total = Object.values(asObject).reduce(function (a, b) {
+        return a + b;
+      });
+      var percentages = (0, _objectUtils.createObject)(Object.keys(asObject), Object.values(asObject).map(function (x) {
+        return x / total;
+      }));
+      var ticket = Math.random();
+      var count = 0;
+      var winner = null;
+      Object.keys(percentages).forEach(function (key) {
+        var x = Number(percentages[key]);
+        if (ticket >= count && ticket < count + x) {
+          winner = key;
+        }
+        count += x;
+      });
+      return winner;
+    }
+
+    /**
+     * Determines if a probability map can return a positive result (true, or some string mode).
+     * - Negative probability maps are used to remove transformations from running entirely.
+     * @param map
+     */
+  }, {
+    key: "isProbabilityMapProbable",
+    value: function isProbabilityMapProbable(map) {
+      (0, _assert.ok)(!Number.isNaN(map), "Numbers cannot be NaN");
+      if (!map || typeof map === "undefined") {
+        return false;
+      }
+      if (typeof map === "function") {
+        return true;
+      }
+      if (typeof map === "number") {
+        if (map > 1 || map < 0) {
+          throw new Error("Numbers must be between 0 and 1 for 0% - 100%");
+        }
+      }
+      if (Array.isArray(map)) {
+        (0, _assert.ok)(map.length != 0, "Empty arrays are not allowed for options. Use false instead.");
+        if (map.length == 1) {
+          return !!map[0];
+        }
+      }
+      if (_typeof(map) === "object") {
+        if (map instanceof Date) return true;
+        if (map instanceof RegExp) return true;
+        if ("value" in map && !map.value) return false;
+        if ("limit" in map && map.limit === 0) return false;
+        var keys = Object.keys(map);
+        (0, _assert.ok)(keys.length != 0, "Empty objects are not allowed for options. Use false instead.");
+        if (keys.length == 1) {
+          return !!map[keys[0]];
+        }
+      }
+      return true;
+    }
   }], [{
     key: "generateCode",
     value: function generateCode(ast) {

package/dist/order.js

@@ -26,7 +26,6 @@ var Order = exports.Order = /*#__PURE__*/function (Order) {
   Order[Order["Shuffle"] = 23] = "Shuffle";
   Order[Order["ControlFlowFlattening"] = 24] = "ControlFlowFlattening";
   Order[Order["MovedDeclarations"] = 25] = "MovedDeclarations";
-  Order[Order["FunctionOutlining"] = 26] = "FunctionOutlining";
   Order[Order["RenameLabels"] = 27] = "RenameLabels";
   Order[Order["Minify"] = 28] = "Minify";
   Order[Order["AstScrambler"] = 29] = "AstScrambler";

package/dist/probability.js

@@ -1,96 +1 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.computeProbabilityMap = computeProbabilityMap;
-exports.isProbabilityMapProbable = isProbabilityMapProbable;
-var _assert = require("assert");
-var _objectUtils = require("./utils/object-utils");
-function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
-/**
- * Evaluates a ProbabilityMap.
- * @param map The setting object.
- * @param customFnArgs Args given to user-implemented function, such as a variable name.
- */
-function computeProbabilityMap(map) {
-  if (!map) {
-    return false;
-  }
-  if (map === true || map === 1) {
-    return true;
-  }
-  if (typeof map === "number") {
-    return Math.random() < map;
-  }
-  if (typeof map === "function") {
-    for (var _len = arguments.length, customImplementationArgs = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-      customImplementationArgs[_key - 1] = arguments[_key];
-    }
-    return map.apply(void 0, customImplementationArgs);
-  }
-  if (typeof map === "string") {
-    return map;
-  }
-  var asObject = {};
-  if (Array.isArray(map)) {
-    map.forEach(function (x) {
-      asObject[x.toString()] = 1;
-    });
-  } else {
-    asObject = map;
-  }
-  var total = Object.values(asObject).reduce(function (a, b) {
-    return a + b;
-  });
-  var percentages = (0, _objectUtils.createObject)(Object.keys(asObject), Object.values(asObject).map(function (x) {
-    return x / total;
-  }));
-  var ticket = Math.random();
-  var count = 0;
-  var winner = null;
-  Object.keys(percentages).forEach(function (key) {
-    var x = Number(percentages[key]);
-    if (ticket >= count && ticket < count + x) {
-      winner = key;
-    }
-    count += x;
-  });
-  return winner;
-}
-
-/**
- * Determines if a probability map can return a positive result (true, or some string mode).
- * - Negative probability maps are used to remove transformations from running entirely.
- * @param map
- */
-function isProbabilityMapProbable(map) {
-  (0, _assert.ok)(!Number.isNaN(map), "Numbers cannot be NaN");
-  if (!map || typeof map === "undefined") {
-    return false;
-  }
-  if (typeof map === "function") {
-    return true;
-  }
-  if (typeof map === "number") {
-    if (map > 1 || map < 0) {
-      throw new Error("Numbers must be between 0 and 1 for 0% - 100%");
-    }
-  }
-  if (Array.isArray(map)) {
-    (0, _assert.ok)(map.length != 0, "Empty arrays are not allowed for options. Use false instead.");
-    if (map.length == 1) {
-      return !!map[0];
-    }
-  }
-  if (_typeof(map) === "object") {
-    if (map instanceof Date) return true;
-    if (map instanceof RegExp) return true;
-    var keys = Object.keys(map);
-    (0, _assert.ok)(keys.length != 0, "Empty objects are not allowed for options. Use false instead.");
-    if (keys.length == 1) {
-      return !!keys[0];
-    }
-  }
-  return true;
-}
+"use strict";

package/dist/templates/getGlobalTemplate.js

@@ -6,10 +6,13 @@ Object.defineProperty(exports, "__esModule", {
 exports.createGetGlobalTemplate = void 0;
 var _template = _interopRequireDefault(require("./template"));
 var _constants = require("../constants");
+var _astUtils = require("../utils/ast-utils");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
 var createGetGlobalTemplate = exports.createGetGlobalTemplate = function createGetGlobalTemplate(pluginInstance, path) {
   var _pluginInstance$optio;
-  if ((_pluginInstance$optio = pluginInstance.options.lock) !== null && _pluginInstance$optio !== void 0 && _pluginInstance$optio.tamperProtection) {
+  if ((_pluginInstance$optio = pluginInstance.options.lock) !== null && _pluginInstance$optio !== void 0 && _pluginInstance$optio.tamperProtection && !path.find(function (p) {
+    return (0, _astUtils.isStrictMode)(p);
+  })) {
     return new _template["default"]("\n      function {getGlobalFnName}(){\n        var localVar = false;\n        eval(__JS_CONFUSER_VAR__(localVar) + \" = true\")\n        if (!localVar) {\n          {countermeasures}\n\n          return {};\n        }\n\n        const root = eval(\"this\");\n        return root;\n      }\n    ").addSymbols(_constants.UNSAFE).setDefaultVariables({
       countermeasures: pluginInstance.globalState.lock.createCountermeasuresCode()
     });

package/dist/templates/integrityTemplate.js

@@ -27,4 +27,4 @@ function HashFunction(str, seed) {
 }
 
 // In template form to be inserted into code
-var HashTemplate = exports.HashTemplate = new _template["default"]("\n// Must be Function Declaration for hoisting\n// Math.imul polyfill for ES5\nfunction {imul}(opA, opB) {\n  var MathImul = Math[\"imul\"] || function(opA, opB){\n    opB |= 0; // ensure that opB is an integer. opA will automatically be coerced.\n    // floating points give us 53 bits of precision to work with plus 1 sign bit\n    // automatically handled for our convienence:\n    // 1. 0x003fffff /*opA & 0x000fffff*/ * 0x7fffffff /*opB*/ = 0x1fffff7fc00001\n    //    0x1fffff7fc00001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n    var result = (opA & 0x003fffff) * opB;\n    // 2. We can remove an integer coersion from the statement above because:\n    //    0x1fffff7fc00001 + 0xffc00000 = 0x1fffffff800001\n    //    0x1fffffff800001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n    if (opA & 0xffc00000 /*!== 0*/) result += (opA & 0xffc00000) * opB |0;\n    return result |0;\n  };\n\n  var result = MathImul(opA, opB);\n\n  return result;\n}\n\n\nfunction {hashingUtilFnName}(str, seed) {\n  var h1 = 0xdeadbeef ^ seed;\n  var h2 = 0x41c6ce57 ^ seed;\n  for (var i = 0, ch; i < str.length; i++) {\n      ch = str.charCodeAt(i);\n      h1 = {imul}(h1 ^ ch, 2654435761);\n      h2 = {imul}(h2 ^ ch, 1597334677);\n  }\n  h1 = {imul}(h1 ^ (h1>>>16), 2246822507) ^ {imul}(h2 ^ (h2>>>13), 3266489909);\n  h2 = {imul}(h2 ^ (h2>>>16), 2246822507) ^ {imul}(h1 ^ (h1>>>13), 3266489909);\n  return 4294967296 * (2097151 & h2) + (h1>>>0);\n};\n\n// Simple function that returns .toString() value with spaces replaced out\nfunction {name}(fnObject, seed, regex={sensitivityRegex}){\n  var fnStringed = fnObject[\"toString\"]()[\"replace\"](regex, \"\");\n  return {hashingUtilFnName}(fnStringed, seed);\n}\n").addSymbols(_constants.SKIP, _constants.MULTI_TRANSFORM);
+var HashTemplate = exports.HashTemplate = new _template["default"]("\n// Must be Function Declaration for hoisting\n// Math.imul polyfill for ES5\nfunction MathImulPolyfill(opA, opB){\n  opB |= 0; // ensure that opB is an integer. opA will automatically be coerced.\n  // floating points give us 53 bits of precision to work with plus 1 sign bit\n  // automatically handled for our convienence:\n  // 1. 0x003fffff /*opA & 0x000fffff*/ * 0x7fffffff /*opB*/ = 0x1fffff7fc00001\n  //    0x1fffff7fc00001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n  var result = (opA & 0x003fffff) * opB;\n  // 2. We can remove an integer coersion from the statement above because:\n  //    0x1fffff7fc00001 + 0xffc00000 = 0x1fffffff800001\n  //    0x1fffffff800001 < Number.MAX_SAFE_INTEGER /*0x1fffffffffffff*/\n  if (opA & 0xffc00000 /*!== 0*/) result += (opA & 0xffc00000) * opB |0;\n  return result |0;\n};\n\nvar {imul} = Math[\"imul\"] || MathImulPolyfill;\n\nfunction {hashingUtilFnName}(str, seed) {\n  var h1 = 0xdeadbeef ^ seed;\n  var h2 = 0x41c6ce57 ^ seed;\n  for (var i = 0, ch; i < str.length; i++) {\n      ch = str.charCodeAt(i);\n      h1 = {imul}(h1 ^ ch, 2654435761);\n      h2 = {imul}(h2 ^ ch, 1597334677);\n  }\n  h1 = {imul}(h1 ^ (h1>>>16), 2246822507) ^ {imul}(h2 ^ (h2>>>13), 3266489909);\n  h2 = {imul}(h2 ^ (h2>>>16), 2246822507) ^ {imul}(h1 ^ (h1>>>13), 3266489909);\n  return 4294967296 * (2097151 & h2) + (h1>>>0);\n};\n\n// Simple function that returns .toString() value with spaces replaced out\nfunction {name}(fnObject, seed, regex={sensitivityRegex}){\n  var fnStringed = fnObject[\"toString\"]()[\"replace\"](regex, \"\");\n  return {hashingUtilFnName}(fnStringed, seed);\n}\n").addSymbols(_constants.SKIP, _constants.MULTI_TRANSFORM);