js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/transforms/string/stringConcealing.js

@@ -1,243 +1,208 @@
 "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 _assert = require("assert");
-var _order = require("../../order");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
 var _template = _interopRequireDefault(require("../../templates/template"));
-var _traverse = require("../../traverse");
-var _compare = require("../../util/compare");
-var _gen = require("../../util/gen");
-var _insert = require("../../util/insert");
-var _random = require("../../util/random");
-var _transform = _interopRequireDefault(require("../transform"));
-var _encoding = require("./encoding");
+var _order = require("../../order");
 var _probability = require("../../probability");
-var _bufferToString = require("../../templates/bufferToString");
-var _constants = require("../../constants");
-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); }
-class StringConcealing extends _transform.default {
-  constructor(o) {
-    super(o, _order.ObfuscateOrder.StringConcealing);
-    _defineProperty(this, "arrayExpression", void 0);
-    _defineProperty(this, "set", void 0);
-    _defineProperty(this, "index", void 0);
-    // index, fnName, block
-    _defineProperty(this, "arrayName", this.getPlaceholder());
-    _defineProperty(this, "ignore", new Set());
-    _defineProperty(this, "variablesMade", 1);
-    _defineProperty(this, "gen", void 0);
-    _defineProperty(this, "functionObjects", []);
-    this.set = new Set();
-    this.index = Object.create(null);
-    this.arrayExpression = (0, _gen.ArrayExpression)([]);
-    this.gen = this.getGenerator();
-  }
-  apply(tree) {
-    super.apply(tree);
-
-    // Pad array with useless strings
-    var dead = (0, _random.getRandomInteger)(5, 15);
-    for (var i = 0; i < dead; i++) {
-      var str = (0, _random.getRandomString)((0, _random.getRandomInteger)(5, 40));
-      var fn = this.transform((0, _gen.Literal)(str), [tree]);
-      if (fn) {
-        fn();
-      }
+var _assert = require("assert");
+var _bufferToStringTemplate = require("../../templates/bufferToStringTemplate");
+var _getGlobalTemplate = require("../../templates/getGlobalTemplate");
+var _astUtils = require("../../utils/ast-utils");
+var _randomUtils = require("../../utils/random-utils");
+var _encoding = require("./encoding");
+var _node = require("../../utils/node");
+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 _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 STRING_CONCEALING = Symbol("StringConcealing");
+var _default = exports["default"] = function _default(_ref) {
+  var Plugin = _ref.Plugin;
+  var me = Plugin(_order.Order.StringConcealing, {
+    changeData: {
+      strings: 0
     }
-    var cacheName = this.getPlaceholder();
-    var bufferToStringName = this.getPlaceholder() + _constants.predictableFunctionTag;
-
-    // This helper functions convert UInt8 Array to UTf-string
-    (0, _insert.prepend)(tree, ..._bufferToString.BufferToStringTemplate.compile({
-      name: bufferToStringName,
-      getGlobalFnName: this.getPlaceholder() + _constants.predictableFunctionTag
-    }));
-    for (var functionObject of this.functionObjects) {
-      var {
-        block,
-        fnName: getterFnName,
-        encodingImplementation
-      } = functionObject;
-      var decodeFn = this.getPlaceholder() + _constants.predictableFunctionTag + _constants.criticalFunctionTag;
-      (0, _insert.append)(block, encodingImplementation.template.single({
-        __fnName__: decodeFn,
-        __bufferToString__: bufferToStringName
-      }));
-      // All these are fake and never ran
-      var ifStatements = (0, _template.default)(`if ( z == x ) {
-          return y[${cacheName}[z]] = ${getterFnName}(x, y);
-        }
-        if ( y ) {
-          [b, y] = [a(b), x || z]
-          return ${getterFnName}(x, b, z)
-        }
-        if ( z && a !== ${decodeFn} ) {
-          ${getterFnName} = ${decodeFn}
-          return ${getterFnName}(x, -1, z, a, b)
-        }
-        if ( a === ${getterFnName} ) {
-          ${decodeFn} = y
-          return ${decodeFn}(z)
-        }
-        if( a === undefined ) {
-          ${getterFnName} = b
-        }
-        if( z == a ) {
-          return y ? x[b[y]] : ${cacheName}[x] || (z=(b[x] || a), ${cacheName}[x] = z(${this.arrayName}[x]))
-        }
-        `).compile();
+  });
+  var blocks = [];
+  var stringMap = new Map();
+  var stringArrayName = me.getPlaceholder() + "_array";
+  var encodingImplementations = Object.create(null);
+  var availableStringEncodings = me.options.customStringEncodings;
 
-      // Not all fake if-statements are needed
-      ifStatements = ifStatements.filter(() => (0, _random.chance)(50));
+  // If no custom encodings are provided, use the default encoding
+  if (!availableStringEncodings || availableStringEncodings.length === 0) {
+    availableStringEncodings = [_encoding.createDefaultStringEncoding];
+  }
+  function hasAllEncodings() {
+    return availableStringEncodings.length === 0;
+  }
+  function createStringEncoding() {
+    var encodingIndex = (0, _randomUtils.getRandomInteger)(0, availableStringEncodings.length);
+    var encoding = availableStringEncodings[encodingIndex];
+    if (typeof encoding === "function") {
+      encoding = encoding(encodingImplementations);
+      var duplicateIdentity = typeof encoding.identity !== "undefined" && typeof encodingImplementations[encoding.identity] !== "undefined";
+      if (duplicateIdentity || encoding === null) {
+        // Null returned -> All encodings have been created
+        // Duplicate identity -> Most likely all encodings have been created
 
-      // This one is always used
-      ifStatements.push((0, _template.default)(`
-      if ( x !== y ) {
-        return b[x] || (b[x] = a(${this.arrayName}[x]))
-      }
-      `).single());
-      (0, _random.shuffle)(ifStatements);
-      var varDeclaration = (0, _template.default)(`
-      var ${getterFnName} = (x, y, z, a, b)=>{
-        if(typeof a === "undefined") {
-          a = ${decodeFn}
-        }
-        if(typeof b === "undefined") {
-          b = ${cacheName}
-        }
+        // No longer create new encodings using this function
+        availableStringEncodings = availableStringEncodings.filter(function (x) {
+          return x !== encoding;
+        });
+
+        // Return a random encoding already made
+        encoding = (0, _randomUtils.choice)(Object.values(encodingImplementations));
+        (0, _assert.ok)(encoding, "Failed to create main string encoding");
       }
-      `).single();
-      varDeclaration.declarations[0].init.body.body.push(...ifStatements);
-      (0, _insert.prepend)(block, varDeclaration);
     }
-    (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)([(0, _gen.VariableDeclarator)(cacheName, (0, _gen.ArrayExpression)([])), (0, _gen.VariableDeclarator)(this.arrayName, this.arrayExpression)]));
-  }
-  match(object, parents) {
-    return object.type == "Literal" && typeof object.value === "string" && object.value.length >= 3 && !(0, _compare.isModuleSource)(object, parents) && !(0, _compare.isDirective)(object, parents) //&&
-    /*!parents.find((x) => x.$dispatcherSkip)*/;
+    if (typeof encoding.identity === "undefined") {
+      encoding.identity = encodingIndex.toString();
+    }
+    if (typeof encoding.code === "string") {
+      encoding.code = new _template["default"](encoding.code);
+    }
+    encodingImplementations[encoding.identity] = encoding;
+    return encoding;
   }
-  transform(object, parents) {
-    return () => {
-      // Empty strings are discarded
-      if (!object.value || this.ignore.has(object.value) || object.value.length == 0) {
-        return;
-      }
+  return {
+    visitor: {
+      Program: {
+        exit: function exit(programPath) {
+          var mainEncodingImplementation;
 
-      // Allow user to choose which strings get changed
-      if (!(0, _probability.ComputeProbabilityMap)(this.options.stringConcealing, x => x, object.value)) {
-        return;
-      }
-      var currentBlock = (0, _traverse.getBlock)(object, parents);
-
-      // Find created functions
-      var functionObjects = parents.filter(node => node.$stringConcealingFunctionObject).map(item => item.$stringConcealingFunctionObject);
-
-      // Choose random functionObject to use
-      var functionObject = (0, _random.choice)(functionObjects);
-      if (!functionObject || !(0, _encoding.hasAllEncodings)() && (0, _random.chance)(25 / this.functionObjects.length) && !currentBlock.$stringConcealingFunctionObject) {
-        // No functions, create one
-
-        var newFunctionObject = {
-          block: currentBlock,
-          encodingImplementation: (0, _encoding.createEncodingImplementation)(),
-          fnName: this.getPlaceholder() + _constants.predictableFunctionTag
-        };
-        this.functionObjects.push(newFunctionObject);
-        currentBlock.$stringConcealingFunctionObject = newFunctionObject;
-        functionObject = newFunctionObject;
-      }
-      var {
-        fnName,
-        encodingImplementation
-      } = functionObject;
-      var index = -1;
-
-      // String already decoded?
-      if (this.set.has(object.value)) {
-        var row = this.index[object.value];
-        if (parents.includes(row[2])) {
-          [index, fnName] = row;
-          (0, _assert.ok)(typeof index === "number");
-        }
-      }
-      if (index == -1) {
-        // The decode function must return correct result
-        var encoded = encodingImplementation.encode(object.value);
-        if (encodingImplementation.decode(encoded) !== object.value) {
-          this.ignore.add(object.value);
-          this.warn(encodingImplementation.identity, object.value.slice(0, 100));
-          delete _encoding.EncodingImplementations[encodingImplementation.identity];
-          return;
-        }
-        this.arrayExpression.elements.push((0, _gen.Literal)(encoded));
-        index = this.arrayExpression.elements.length - 1;
-        this.index[object.value] = [index, fnName, currentBlock];
-        this.set.add(object.value);
-      }
-      (0, _assert.ok)(index != -1, "index == -1");
-      var callExpr = (0, _gen.CallExpression)((0, _gen.Identifier)(fnName), [(0, _gen.Literal)(index)]);
+          // Create a main encoder function for the Program
+          programPath.node[STRING_CONCEALING] = {
+            encodingImplementation: mainEncodingImplementation = createStringEncoding(),
+            fnName: me.getPlaceholder() + "_MAIN_STR"
+          };
+          blocks.push(programPath);
 
-      // use `.apply` to fool automated de-obfuscators
-      if ((0, _random.chance)(10)) {
-        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Literal)("apply"), true), [(0, _gen.Identifier)("undefined"), (0, _gen.ArrayExpression)([(0, _gen.Literal)(index)])]);
-      }
+          // Use that encoder function for these fake strings
+          var fakeStringCount = (0, _randomUtils.getRandomInteger)(75, 125);
+          for (var i = 0; i < fakeStringCount; i++) {
+            var fakeString = (0, _randomUtils.getRandomString)((0, _randomUtils.getRandomInteger)(5, 50));
+            stringMap.set(mainEncodingImplementation.encode(fakeString), stringMap.size);
+          }
+          programPath.traverse({
+            StringLiteral: {
+              exit: function exit(path) {
+                var _block;
+                var originalValue = path.node.value;
 
-      // use `.call`
-      else if ((0, _random.chance)(10)) {
-        callExpr = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Literal)("call"), true), [(0, _gen.Identifier)("undefined"), (0, _gen.Literal)(index)]);
-      }
-      var referenceType = "call";
-      if (parents.length && (0, _random.chance)(50 - this.variablesMade)) {
-        referenceType = "constantReference";
-      }
-      var newExpr = callExpr;
-      if (referenceType === "constantReference") {
-        // Define the string earlier, reference the name here
-        this.variablesMade++;
-        var constantReferenceType = (0, _random.choice)(["variable", "array", "object"]);
-        var place = currentBlock;
-        if (!place) {
-          this.error(new Error("No lexical block to insert code"));
-        }
-        switch (constantReferenceType) {
-          case "variable":
-            var name = this.getPlaceholder();
-            (0, _insert.prepend)(place, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(name, callExpr)));
-            newExpr = (0, _gen.Identifier)(name);
-            break;
-          case "array":
-            if (!place.$stringConcealingArray) {
-              place.$stringConcealingArray = (0, _gen.ArrayExpression)([]);
-              place.$stringConcealingArrayName = this.getPlaceholder();
-              (0, _insert.prepend)(place, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(place.$stringConcealingArrayName, place.$stringConcealingArray)));
-            }
-            var arrayIndex = place.$stringConcealingArray.elements.length;
-            place.$stringConcealingArray.elements.push(callExpr);
-            var memberExpression = (0, _gen.MemberExpression)((0, _gen.Identifier)(place.$stringConcealingArrayName), (0, _gen.Literal)(arrayIndex), true);
-            newExpr = memberExpression;
-            break;
-          case "object":
-            if (!place.$stringConcealingObject) {
-              place.$stringConcealingObject = (0, _gen.ObjectExpression)([]);
-              place.$stringConcealingObjectName = this.getPlaceholder();
-              (0, _insert.prepend)(place, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(place.$stringConcealingObjectName, place.$stringConcealingObject)));
+                // Ignore require() calls / Import statements
+                if ((0, _astUtils.isModuleImport)(path)) {
+                  return;
+                }
+
+                // Minimum length of 3 characters
+                if (originalValue.length < 3) {
+                  return;
+                }
+
+                // Check user setting
+                if (!(0, _probability.computeProbabilityMap)(me.options.stringConcealing, originalValue)) {
+                  return;
+                }
+                var block = path.findParent(function (p) {
+                  var _p$node;
+                  return p.isBlock() && !!((_p$node = p.node) !== null && _p$node !== void 0 && _p$node[STRING_CONCEALING]);
+                });
+                var stringConcealingInterface = (_block = block) === null || _block === void 0 || (_block = _block.node) === null || _block === void 0 ? void 0 : _block[STRING_CONCEALING];
+                if (!block || !hasAllEncodings() && (0, _randomUtils.chance)(75 - blocks.length)) {
+                  // Create a new encoder function
+                  // Select random block parent (or Program)
+                  block = path.findParent(function (p) {
+                    return p.isBlock();
+                  });
+                  var stringConcealingNode = block.node;
+
+                  // Ensure not to overwrite the previous encoders
+                  if (!stringConcealingNode[STRING_CONCEALING]) {
+                    // Create a new encoding function for this block
+                    var encodingImplementation = createStringEncoding();
+                    var fnName = me.getPlaceholder() + "_STR_" + blocks.length;
+                    stringConcealingInterface = {
+                      encodingImplementation: encodingImplementation,
+                      fnName: fnName
+                    };
+
+                    // Save this info in the AST for future strings
+                    stringConcealingNode[STRING_CONCEALING] = stringConcealingInterface;
+                    blocks.push(block);
+                  }
+                }
+                (0, _assert.ok)(stringConcealingInterface);
+                var encodedValue = stringConcealingInterface.encodingImplementation.encode(originalValue);
+
+                // If a decoder function is provided, use it to validate each encoded string
+                if (typeof stringConcealingInterface.encodingImplementation.decode === "function") {
+                  var decodedValue = stringConcealingInterface.encodingImplementation.decode(encodedValue);
+                  if (decodedValue !== originalValue) {
+                    return;
+                  }
+                }
+                var index = stringMap.get(encodedValue);
+                if (typeof index === "undefined") {
+                  index = stringMap.size;
+                  stringMap.set(encodedValue, index);
+                }
+                me.changeData.strings++;
+
+                // Ensure the string is computed so we can replace it with complex call expression
+                (0, _astUtils.ensureComputedExpression)(path);
+
+                // Replace the string literal with a call to the decoder function
+                path.replaceWith(t.callExpression(t.identifier(stringConcealingInterface.fnName), [(0, _node.numericLiteral)(index)]));
+
+                // Skip the transformation for the newly created node
+                path.skip();
+              }
             }
-            var propName = this.gen.generate();
-            var property = (0, _gen.Property)((0, _gen.Literal)(propName), callExpr, true);
-            place.$stringConcealingObject.properties.push(property);
-            var memberExpression = (0, _gen.MemberExpression)((0, _gen.Identifier)(place.$stringConcealingObjectName), (0, _gen.Literal)(propName), true);
-            newExpr = memberExpression;
-            break;
+          });
+          var bufferToStringName = me.getPlaceholder() + "_bufferToString";
+          var getGlobalFnName = me.getPlaceholder() + "_getGlobal";
+          var bufferToStringCode = _bufferToStringTemplate.BufferToStringTemplate.compile({
+            GetGlobalTemplate: (0, _getGlobalTemplate.createGetGlobalTemplate)(me, programPath),
+            getGlobalFnName: getGlobalFnName,
+            BufferToString: bufferToStringName
+          });
+          (0, _astUtils.prependProgram)(programPath, bufferToStringCode);
+
+          // Create the string array
+          (0, _astUtils.prependProgram)(programPath, t.variableDeclaration("var", [t.variableDeclarator(t.identifier(stringArrayName), t.arrayExpression(Array.from(stringMap.keys()).map(function (x) {
+            return t.stringLiteral(x);
+          })))]));
+          for (var _i = 0, _blocks = blocks; _i < _blocks.length; _i++) {
+            var block = _blocks[_i];
+            var _ref2 = block.node[STRING_CONCEALING],
+              encodingImplementation = _ref2.encodingImplementation,
+              fnName = _ref2.fnName;
+            var decodeFnName = fnName + "_decode";
+            (0, _assert.ok)(encodingImplementation.code instanceof _template["default"]);
+
+            // The decoder function
+            var decoder = encodingImplementation.code.compile({
+              fnName: decodeFnName,
+              __bufferToStringFunction__: bufferToStringName
+            });
+
+            // The main function to get the string value
+            var retrieveFunctionDeclaration = new _template["default"]("\n              function ".concat(fnName, "(index) {\n                return ").concat(decodeFnName, "(").concat(stringArrayName, "[index]);\n              }\n            ")).single();
+            (0, _astUtils.prepend)(block, [].concat(_toConsumableArray(decoder), [retrieveFunctionDeclaration]));
+          }
         }
       }
-      this.replaceIdentifierOrLiteral(object, newExpr, parents);
-    };
-  }
-}
-exports.default = StringConcealing;
+    }
+  };
+};

package/dist/transforms/string/stringEncoding.js

@@ -1,15 +1,16 @@
 "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 _transform = _interopRequireDefault(require("../transform"));
-var _random = require("../../util/random");
-var _compare = require("../../util/compare");
+exports["default"] = void 0;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _randomUtils = require("../../utils/random-utils");
 var _probability = require("../../probability");
-var _gen = require("../../util/gen");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+var _constants = require("../../constants");
+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 pad(x, len) {
   while (x.length < len) {
     x = "0" + x;
@@ -24,54 +25,45 @@ function even(x) {
 }
 function toHexRepresentation(str) {
   var escapedString = "";
-  str.split("").forEach(char => {
-    var code = char.charCodeAt(0);
+  str.split("").forEach(function (_char) {
+    var code = _char.charCodeAt(0);
     if (code < 128) {
       escapedString += "\\x" + even(pad(code.toString(16), 2));
     } else {
-      escapedString += char;
+      escapedString += _char;
     }
   });
   return escapedString;
 }
 function toUnicodeRepresentation(str) {
   var escapedString = "";
-  str.split("").forEach(char => {
-    var code = char.charCodeAt(0);
+  str.split("").forEach(function (_char2) {
+    var code = _char2.charCodeAt(0);
     if (code < 128) {
       escapedString += "\\u" + even(pad(code.toString(16), 4));
     } else {
-      escapedString += char;
+      escapedString += _char2;
     }
   });
   return escapedString;
 }
+var _default = exports["default"] = function _default(me) {
+  return {
+    visitor: {
+      StringLiteral: {
+        exit: function exit(path) {
+          var value = path.node.value;
 
-/**
- * [String Encoding](https://docs.jscrambler.com/code-integrity/documentation/transformations/string-encoding) transforms a string into an encoded representation.
- *
- * - Potency Low
- * - Resilience Low
- * - Cost Low
- */
-class StringEncoding extends _transform.default {
-  constructor(o) {
-    super(o);
-  }
-  match(object, parents) {
-    return object.type == "Literal" && typeof object.value === "string" && object.value.length > 0 && !(0, _compare.isModuleSource)(object, parents) && !(0, _compare.isDirective)(object, parents);
-  }
-  transform(object, parents) {
-    // Allow percentages
-    if (!(0, _probability.ComputeProbabilityMap)(this.options.stringEncoding, x => x, object.value)) return;
-    var type = (0, _random.choice)(["hexadecimal", "unicode"]);
-    var escapedString = (type == "hexadecimal" ? toHexRepresentation : toUnicodeRepresentation)(object.value);
-    return () => {
-      if (object.type !== "Literal") return;
-
-      // ESCodeGen tries to escape backslashes, here is a work-around
-      this.replace(object, (0, _gen.Identifier)(`'${escapedString}'`));
-    };
-  }
-}
-exports.default = StringEncoding;
+          // Allow percentages
+          if (!(0, _probability.computeProbabilityMap)(me.options.stringEncoding, value)) return;
+          var type = (0, _randomUtils.choice)(["hexadecimal", "unicode"]);
+          var escapedString = (type == "hexadecimal" ? toHexRepresentation : toUnicodeRepresentation)(value);
+          var id = t.identifier("\"".concat(escapedString, "\""));
+          id[_constants.GEN_NODE] = true;
+          path.replaceWith(id);
+          path.skip();
+        }
+      }
+    }
+  };
+};