js-confuser 1.7.3 → 2.0.0-alpha.0

package/dist/transforms/functionOutlining.js

@@ -0,0 +1,230 @@
+"use strict";
+
+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); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+var _order = require("../order");
+var _astUtils = require("../utils/ast-utils");
+var t = _interopRequireWildcard(require("@babel/types"));
+var _randomUtils = require("../utils/random-utils");
+var _probability = require("../probability");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function isSafeForOutlining(path) {
+  if (path.isIdentifier() || path.isLiteral()) return {
+    isSafe: false
+  };
+
+  // Skip direct invocations ('this' will be different)
+  if (path.key === "callee" && path.parentPath.isCallExpression()) {
+    return {
+      isSafe: false
+    };
+  }
+
+  // Skip typeof and delete expressions (identifier behavior is different)
+  if (path.key === "argument" && path.parentPath.isUnaryExpression()) {
+    return {
+      isSafe: false
+    };
+  }
+  if (path.isReturnStatement() || path.isYieldExpression() || path.isAwaitExpression() || path.isContinueStatement() || path.isBreakStatement() || path.isThrowStatement() || path.isDebuggerStatement() || path.isImportDeclaration() || path.isExportDeclaration()) {
+    return {
+      isSafe: false
+    };
+  }
+  var isSafe = true;
+  var bindings = [];
+  var fnPath = path.getFunctionParent();
+  var visitor = {
+    ThisExpression: function ThisExpression(path) {
+      isSafe = false;
+      path.stop();
+    },
+    Identifier: function Identifier(path) {
+      if (["arguments", "eval"].includes(path.node.name)) {
+        isSafe = false;
+        path.stop();
+      }
+    },
+    BindingIdentifier: function BindingIdentifier(path) {
+      var binding = path.scope.getBinding(path.node.name);
+      if (binding) {
+        bindings.push(binding);
+      }
+    },
+    // Function flow guard
+    "ReturnStatement|YieldExpression|AwaitExpression": function ReturnStatementYieldExpressionAwaitExpression(path) {
+      if (path.getFunctionParent() === fnPath) {
+        isSafe = false;
+        path.stop();
+      }
+    }
+  };
+
+  // Exclude 'ThisExpression' and semantic 'Identifier' nodes
+  if (visitor[path.type]) return {
+    isSafe: false
+  };
+  path.traverse(visitor);
+  return {
+    isSafe: isSafe,
+    bindings: bindings
+  };
+}
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.FunctionOutlining, {
+    changeData: {
+      functionsMade: 0
+    }
+  });
+  var changesMade = 0;
+  function checkProbability() {
+    if (!(0, _probability.computeProbabilityMap)(me.options.functionOutlining)) return false;
+    if (changesMade > 100 && (0, _randomUtils.chance)(changesMade - 100)) return false;
+    return true;
+  }
+  return {
+    visitor: {
+      Block: {
+        exit: function exit(blockPath) {
+          if (blockPath.isProgram()) {
+            blockPath.scope.crawl();
+          }
+          if (blockPath.find(function (p) {
+            return me.isSkipped(p);
+          })) return;
+          if (!checkProbability()) return;
+
+          // Extract a random number of statements
+
+          var statements = blockPath.get("body");
+          // var startIndex = getRandomInteger(0, statements.length);
+          // var endIndex = getRandomInteger(startIndex, statements.length);
+
+          var startIndex = 0;
+          var endIndex = statements.length;
+          var extractedStatements = statements.slice(startIndex, endIndex);
+          if (!extractedStatements.length) return;
+          var bindings = [];
+          var _iterator = _createForOfIteratorHelper(extractedStatements),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var statement = _step.value;
+              // Don't override the control node
+              if (me.isSkipped(statement)) return;
+              var result = isSafeForOutlining(statement);
+              if (!result.isSafe) {
+                return;
+              }
+              bindings.push.apply(bindings, _toConsumableArray(result.bindings));
+            }
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          var extractedStatementSet = new Set(extractedStatements);
+          for (var _i = 0, _bindings = bindings; _i < _bindings.length; _i++) {
+            var binding = _bindings[_i];
+            var _iterator2 = _createForOfIteratorHelper(binding.referencePaths),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var referencePath = _step2.value;
+                var found = referencePath.find(function (p) {
+                  return extractedStatementSet.has(p);
+                });
+                if (!found) {
+                  return;
+                }
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            var _iterator3 = _createForOfIteratorHelper(binding.constantViolations),
+              _step3;
+            try {
+              for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+                var constantViolation = _step3.value;
+                var found = constantViolation.find(function (p) {
+                  return extractedStatementSet.has(p);
+                });
+                if (!found) {
+                  return;
+                }
+              }
+            } catch (err) {
+              _iterator3.e(err);
+            } finally {
+              _iterator3.f();
+            }
+          }
+          changesMade++;
+          var isFirst = true;
+          var _iterator4 = _createForOfIteratorHelper(extractedStatements),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var statement = _step4.value;
+              if (isFirst) {
+                isFirst = false;
+                var memberExpression = me.getControlObject(blockPath).addProperty(t.functionExpression(null, [], t.blockStatement(extractedStatements.map(function (x) {
+                  return x.node;
+                }))));
+                me.changeData.functionsMade++;
+                var callExpression = t.callExpression(memberExpression, []);
+                statement.replaceWith(callExpression);
+                continue;
+              }
+              statement.remove();
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      },
+      Expression: {
+        exit: function exit(path) {
+          // Skip assignment left
+          if (path.find(function (p) {
+            var _p$parentPath;
+            return p.key === "left" && ((_p$parentPath = p.parentPath) === null || _p$parentPath === void 0 ? void 0 : _p$parentPath.type) === "AssignmentExpression";
+          })) {
+            return;
+          }
+          if (!checkProbability()) return;
+          if (path.find(function (p) {
+            return me.isSkipped(p);
+          })) return;
+          if (!isSafeForOutlining(path).isSafe) return;
+          changesMade++;
+          var blockPath = path.find(function (p) {
+            return p.isBlock();
+          });
+          var memberExpression = me.getControlObject(blockPath).addProperty(t.functionExpression(null, [], t.blockStatement([t.returnStatement(t.cloneNode(path.node))])));
+          me.changeData.functionsMade++;
+          var callExpression = t.callExpression(memberExpression, []);
+          (0, _astUtils.ensureComputedExpression)(path);
+          path.replaceWith(callExpression);
+          me.skip(path);
+        }
+      }
+    }
+  };
+};

package/dist/transforms/identifier/globalConcealing.js

@@ -1,154 +1,233 @@
 "use strict";
 
+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); }
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _NameGen = require("../../utils/NameGen");
 var _template = _interopRequireDefault(require("../../templates/template"));
-var _transform = _interopRequireDefault(require("../transform"));
 var _order = require("../../order");
-var _gen = require("../../util/gen");
-var _insert = require("../../util/insert");
-var _random = require("../../util/random");
-var _constants = require("../../constants");
 var _probability = require("../../probability");
-var _globalAnalysis = _interopRequireDefault(require("./globalAnalysis"));
-var _bufferToString = require("../../templates/bufferToString");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == typeof i ? i : i + ""; }
-function _toPrimitive(t, r) { if ("object" != typeof t || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != typeof i) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-/**
- * Global Concealing hides global variables being accessed.
- *
- * - Any variable that is not defined is considered "global"
- */
-class GlobalConcealing extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.GlobalConcealing);
-    _defineProperty(this, "globalAnalysis", void 0);
-    _defineProperty(this, "ignoreGlobals", new Set(["require", "__dirname", "eval", _constants.variableFunctionName]));
-    this.globalAnalysis = new _globalAnalysis.default(o);
-    this.before.push(this.globalAnalysis);
-  }
-  match(object, parents) {
-    return object.type == "Program";
-  }
-  transform(object, parents) {
-    return () => {
-      var globals = this.globalAnalysis.globals;
-      this.globalAnalysis.notGlobals.forEach(del => {
-        delete globals[del];
-      });
-      for (var varName of this.ignoreGlobals) {
-        delete globals[varName];
-      }
-      _constants.reservedIdentifiers.forEach(x => {
-        delete globals[x];
-      });
-      Object.keys(globals).forEach(x => {
-        if (this.globalAnalysis.globals[x].length < 1) {
-          delete globals[x];
-        } else if (!(0, _probability.ComputeProbabilityMap)(this.options.globalConcealing, x => x, x)) {
-          delete globals[x];
-        }
+var _constants = require("../../constants");
+var _astUtils = require("../../utils/ast-utils");
+var _getGlobalTemplate = require("../../templates/getGlobalTemplate");
+var _randomUtils = require("../../utils/random-utils");
+var _assert = require("assert");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { "default": e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n["default"] = e, t && t.set(e, n), n; }
+function _slicedToArray(r, e) { return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t["return"] || t["return"](); } finally { if (u) throw o; } } }; }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return _arrayLikeToArray(r); }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var ignoreGlobals = new Set(["require", "__dirname", "eval", "arguments", _constants.variableFunctionName].concat(_toConsumableArray(_constants.reservedIdentifiers)));
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.GlobalConcealing, {
+    changeData: {
+      globals: 0,
+      nativeFunctions: 0
+    }
+  });
+  var globalMapping = new Map(),
+    globalFnName = me.getPlaceholder() + "_getGlobal",
+    globalVarName = me.getPlaceholder() + "_globalVar",
+    gen = new _NameGen.NameGen();
+
+  // Create the getGlobal function using a template
+  function createGlobalConcealingFunction() {
+    // Create fake global mappings
+
+    var fakeCount = (0, _randomUtils.getRandomInteger)(20, 40);
+    for (var i = 0; i < fakeCount; i++) {
+      var fakeName = (0, _randomUtils.getRandomString)((0, _randomUtils.getRandomInteger)(6, 8));
+      globalMapping.set(gen.generate(), fakeName);
+    }
+    var createSwitchStatement = function createSwitchStatement() {
+      var cases = Array.from(globalMapping.keys()).map(function (originalName) {
+        var mappedKey = globalMapping.get(originalName);
+        return t.switchCase(t.stringLiteral(mappedKey), [t.returnStatement(t.memberExpression(t.identifier(globalVarName), t.stringLiteral(originalName), true))]);
       });
-      if (Object.keys(globals).length > 0) {
-        var usedStates = new Set();
+      return t.switchStatement(t.identifier("mapping"), cases);
+    };
+    return t.functionDeclaration(t.identifier(globalFnName), [t.identifier("mapping")], t.blockStatement([createSwitchStatement()]));
+  }
+  return {
+    visitor: {
+      Program: {
+        exit: function exit(programPath) {
+          var illegalGlobals = new Set();
+          var pendingReplacements = new Map();
+          programPath.traverse({
+            Identifier: function Identifier(identifierPath) {
+              if (!(0, _astUtils.isVariableIdentifier)(identifierPath)) return;
+              var identifierName = identifierPath.node.name;
+              if (ignoreGlobals.has(identifierName)) return;
+              var binding = identifierPath.scope.getBinding(identifierName);
+              if (binding) {
+                illegalGlobals.add(identifierName);
+                return;
+              }
+              if (!identifierPath.scope.hasGlobal(identifierName)) {
+                return;
+              }
+              var assignmentChild = identifierPath.find(function (p) {
+                var _p$parentPath;
+                return (_p$parentPath = p.parentPath) === null || _p$parentPath === void 0 ? void 0 : _p$parentPath.isAssignmentExpression();
+              });
+              if (assignmentChild && t.isAssignmentExpression(assignmentChild.parent) && assignmentChild.parent.left === assignmentChild.node && !t.isMemberExpression(identifierPath.parent)) {
+                illegalGlobals.add(identifierName);
+                return;
+              }
+              if (!pendingReplacements.has(identifierName)) {
+                pendingReplacements.set(identifierName, [identifierPath]);
+              } else {
+                pendingReplacements.get(identifierName).push(identifierPath);
+              }
+            }
+          });
 
-        // Make getter function
+          // Remove illegal globals
+          illegalGlobals.forEach(function (globalName) {
+            pendingReplacements["delete"](globalName);
+          });
+          var _iterator = _createForOfIteratorHelper(pendingReplacements),
+            _step;
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              var _step$value = _slicedToArray(_step.value, 2),
+                globalName = _step$value[0],
+                paths = _step$value[1];
+              var mapping = globalMapping.get(globalName);
+              if (!mapping) {
+                // Allow user to disable custom global variables
+                if (!(0, _probability.computeProbabilityMap)(me.options.globalConcealing, globalName)) continue;
+                mapping = gen.generate();
+                globalMapping.set(globalName, mapping);
+              }
 
-        // holds "window" or "global"
-        var globalVar = this.getPlaceholder();
-        var getGlobalVariableFnName = this.getPlaceholder() + _constants.predictableFunctionTag;
+              // Replace global reference with getGlobal("name")
+              var callExpression = t.callExpression(t.identifier(globalFnName), [t.stringLiteral(mapping)]);
+              var nativeFunctionName = me.globalState.internals.nativeFunctionName;
+              var _iterator2 = _createForOfIteratorHelper(paths),
+                _step2;
+              try {
+                var _loop = function _loop() {
+                    var path = _step2.value;
+                    var replaceExpression = t.cloneNode(callExpression);
+                    me.skip(replaceExpression);
+                    if (
+                    // Native Function will only be populated if tamper protection is enabled
+                    nativeFunctionName &&
+                    // Avoid maximum call stack error
+                    !path.find(function (p) {
+                      return p.node[_constants.MULTI_TRANSFORM] || me.isSkipped(p);
+                    })) {
+                      // First extract the member expression chain
+                      var nameAndPropertyPath = [globalName];
+                      var cursorPath = path;
+                      var callExpressionPath = null;
+                      var checkForCallExpression = function checkForCallExpression() {
+                        var _cursorPath$parentPat;
+                        if ((_cursorPath$parentPat = cursorPath.parentPath) !== null && _cursorPath$parentPat !== void 0 && _cursorPath$parentPat.isCallExpression() && cursorPath.key === "callee") {
+                          callExpressionPath = cursorPath.parentPath;
+                          return true;
+                        }
+                      };
+                      if (!checkForCallExpression()) {
+                        var _cursorPath;
+                        cursorPath = (_cursorPath = cursorPath) === null || _cursorPath === void 0 ? void 0 : _cursorPath.parentPath;
+                        while ((_cursorPath2 = cursorPath) !== null && _cursorPath2 !== void 0 && _cursorPath2.isMemberExpression()) {
+                          var _cursorPath2;
+                          var propertyString = (0, _astUtils.getMemberExpressionPropertyAsString)(cursorPath.node);
+                          if (!propertyString || typeof propertyString !== "string") {
+                            break;
+                          }
+                          nameAndPropertyPath.push(propertyString);
+                          if (checkForCallExpression()) break;
+                          cursorPath = cursorPath.parentPath;
+                        }
+                      }
 
-        // Returns global variable or fall backs to `this`
-        var getGlobalVariableFn = (0, _bufferToString.createGetGlobalTemplate)(this, object, parents).compile({
-          getGlobalFnName: getGlobalVariableFnName
-        });
+                      // Eligible member-expression/identifier
+                      if (callExpressionPath) {
+                        // Check user's custom implementation
+                        shouldTransform = me.obfuscator.shouldTransformNativeFunction(nameAndPropertyPath);
+                        if (shouldTransform) {
+                          path.replaceWith(replaceExpression);
 
-        // 2. Replace old accessors
-        var globalFn = this.getPlaceholder() + _constants.predictableFunctionTag;
-        var newNames = Object.create(null);
-        Object.keys(globals).forEach(name => {
-          var locations = globals[name];
-          var state;
-          do {
-            state = (0, _random.getRandomInteger)(-1000, 1000 + usedStates.size);
-          } while (usedStates.has(state));
-          usedStates.add(state);
-          newNames[name] = state;
-          locations.forEach(_ref => {
-            var _this$options$lock;
-            let [node, p] = _ref;
-            if (p.find(x => x.$multiTransformSkip)) {
-              return;
-            }
-            var newExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(globalFn), [(0, _gen.Literal)(state)]);
-            this.replace(node, newExpression);
-            if ((_this$options$lock = this.options.lock) !== null && _this$options$lock !== void 0 && _this$options$lock.tamperProtection && this.lockTransform.nativeFunctionName) {
-              var isMemberExpression = false;
-              var nameAndPropertyPath = [name];
-              var callExpression;
-              var index = 0;
-              do {
-                if (p[index].type === "CallExpression") {
-                  callExpression = p[index];
-                  break;
-                }
-                var memberExpression = p[index];
-                if (memberExpression.type !== "MemberExpression") return;
-                var property = memberExpression.property;
-                var stringValue = property.type === "Literal" ? property.value : memberExpression.computed ? null : property.type === "Identifier" ? property.name : null;
-                if (!stringValue) return;
-                isMemberExpression = true;
-                nameAndPropertyPath.push(stringValue);
-                index++;
-              } while (index < p.length);
-              if (!this.lockTransform.shouldTransformNativeFunction(nameAndPropertyPath)) return;
-              if (callExpression && callExpression.type === "CallExpression") {
-                if (isMemberExpression) {
-                  callExpression.callee = (0, _gen.CallExpression)((0, _gen.Identifier)(this.lockTransform.nativeFunctionName), [callExpression.callee.object, callExpression.callee.computed ? callExpression.callee.property : (0, _gen.Literal)(callExpression.callee.property.name || callExpression.callee.property.value)]);
-                } else {
-                  callExpression.callee = (0, _gen.CallExpression)((0, _gen.Identifier)(this.lockTransform.nativeFunctionName), [{
-                    ...callExpression.callee
-                  }]);
+                          // console.log("Hello World") ->
+                          // checkNative(getGlobal("console")["log"])("Hello World")
+
+                          // Parent-most member expression must be wrapped
+                          // This to preserve proper 'this' binding in member expression invocations
+                          var callee = callExpressionPath.get("callee");
+                          var callArgs = [callee.node];
+                          if (callee.isMemberExpression()) {
+                            var additionalPropertyString = (0, _astUtils.getMemberExpressionPropertyAsString)(callee.node);
+                            (0, _assert.ok)(additionalPropertyString, "Expected additional property to be a string");
+                            callee = callee.get("object");
+                            callArgs = [callee.node, t.stringLiteral(additionalPropertyString)];
+                          }
+
+                          // Method supports two signatures:
+                          // checkNative(fetch)(...)
+                          // checkNative(console, "log")(...)
+
+                          callExpressionPath.get("callee").replaceWith(me.skip(t.callExpression(t.identifier(nativeFunctionName), callArgs)));
+                          me.changeData.nativeFunctions++;
+                          return 1; // continue
+                        }
+                      }
+                    }
+                    me.changeData.globals++;
+
+                    // Regular replacement
+                    // console -> getGlobal("console")
+                    path.replaceWith(replaceExpression);
+                  },
+                  shouldTransform;
+                for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                  if (_loop()) continue;
                 }
+              } catch (err) {
+                _iterator2.e(err);
+              } finally {
+                _iterator2.f();
               }
             }
-          });
-        });
 
-        // Adds all global variables to the switch statement
-        this.options.globalVariables.forEach(name => {
-          if (!newNames[name]) {
-            var state;
-            do {
-              state = (0, _random.getRandomInteger)(0, 1000 + usedStates.size + this.options.globalVariables.size * 100);
-            } while (usedStates.has(state));
-            usedStates.add(state);
-            newNames[name] = state;
-          }
-        });
-        var indexParamName = this.getPlaceholder();
-        var returnName = this.getPlaceholder();
-        var functionDeclaration = (0, _gen.FunctionDeclaration)(globalFn, [(0, _gen.Identifier)(indexParamName)], [(0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(returnName)), (0, _gen.SwitchStatement)((0, _gen.Identifier)(indexParamName), Object.keys(newNames).map(name => {
-          var code = newNames[name];
-          var body = [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(globalVar), (0, _gen.Literal)(name), true))];
-          if ((0, _random.chance)(50)) {
-            body = [(0, _gen.ExpressionStatement)((0, _gen.AssignmentExpression)("=", (0, _gen.Identifier)(returnName), (0, _gen.LogicalExpression)("||", (0, _gen.Literal)(name), (0, _gen.MemberExpression)((0, _gen.Identifier)(globalVar), (0, _gen.Literal)(name), true)))), (0, _gen.BreakStatement)()];
+            // No globals changed, no need to insert the getGlobal function
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
           }
-          return (0, _gen.SwitchCase)((0, _gen.Literal)(code), body);
-        })), (0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Identifier)(globalVar), (0, _gen.Identifier)(returnName), true))]);
-        var tempVar = this.getPlaceholder();
-        var variableDeclaration = new _template.default(`
-        var ${globalVar};
-        `).single();
-        variableDeclaration.declarations.push((0, _gen.VariableDeclarator)(tempVar, (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.FunctionExpression)([], [...getGlobalVariableFn, new _template.default(`return ${globalVar} = ${getGlobalVariableFnName}["call"](this)`).single()]), (0, _gen.Literal)("call"), true), [])));
-        (0, _insert.prepend)(object, variableDeclaration);
-        (0, _insert.append)(object, functionDeclaration);
+          if (globalMapping.size === 0) return;
+
+          // The Global Concealing function returns the global variable from the specified parameter
+          var globalConcealingFunction = createGlobalConcealingFunction();
+          (0, _astUtils.prepend)(programPath, globalConcealingFunction);
+          var getGlobalVarFnName = me.getPlaceholder() + "_getGlobalVarFn";
+
+          // Insert the get global function
+          (0, _astUtils.prepend)(programPath, (0, _getGlobalTemplate.createGetGlobalTemplate)(me, programPath).compile({
+            getGlobalFnName: getGlobalVarFnName
+          }));
+
+          // Call the get global function and store result in 'globalVarName'
+          (0, _astUtils.prepend)(programPath, new _template["default"]("var ".concat(globalVarName, " = ").concat(getGlobalVarFnName, "()")).single());
+        }
       }
-    };
-  }
-}
-exports.default = GlobalConcealing;
+    }
+  };
+};