js-confuser 1.7.1 → 1.7.3

package/dist/transforms/extraction/classExtraction.js

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _assert = require("assert");
+var _traverse = require("../../traverse");
+var _gen = require("../../util/gen");
+var _guard = require("../../util/guard");
+var _insert = require("../../util/insert");
+var _scope = require("../../util/scope");
+var _transform = _interopRequireDefault(require("../transform"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+class ClassExtraction extends _transform.default {
+  constructor(o) {
+    super(o);
+  }
+  match(object, parents) {
+    return object.type === "ClassDeclaration" || object.type === "ClassExpression";
+  }
+  extractKeyString(property) {
+    if (property.key.type === "Identifier" && !property.key.computed) {
+      return property.key.name;
+    }
+    if ((0, _guard.isStringLiteral)(property.key)) {
+      return property.key.value;
+    }
+    return null;
+  }
+  transform(object, parents) {
+    return () => {
+      var _object$id, _object$id2;
+      var classBody = object.body;
+      var className = ((_object$id = object.id) === null || _object$id === void 0 ? void 0 : _object$id.type) === "Identifier" && ((_object$id2 = object.id) === null || _object$id2 === void 0 ? void 0 : _object$id2.name);
+      if (!className) className = this.getPlaceholder();
+      var lexicalScope = (0, _scope.getLexicalScope)(object, parents);
+      var superMethodName;
+      for (var methodDefinition of classBody.body) {
+        if (methodDefinition.type === "MethodDefinition" && methodDefinition.value.type === "FunctionExpression") {
+          // Don't change constructors calling super()
+          if (methodDefinition.kind === "constructor" && object.superClass) continue;
+          var functionExpression = methodDefinition.value;
+          var fnName = className + "_" + methodDefinition.kind + "_" + this.extractKeyString(methodDefinition) || this.getPlaceholder();
+          (0, _traverse.walk)(functionExpression, [methodDefinition, object, ...parents], (o, p) => {
+            if (o.type === "Super") {
+              var classContext = p.find(node => (0, _insert.isClass)(node));
+              if (classContext !== object) return;
+              return () => {
+                if (!superMethodName) {
+                  superMethodName = this.getGenerator("randomized").generate();
+                }
+                var memberExpression = p[0];
+                if (memberExpression.type === "CallExpression") {
+                  throw new Error("Failed to detect super() usage");
+                }
+                (0, _assert.ok)(memberExpression.type === "MemberExpression");
+                var propertyArg = memberExpression.computed ? memberExpression.property : ((0, _assert.ok)(memberExpression.property.type === "Identifier"), (0, _gen.Literal)(memberExpression.property.name));
+                var getSuperExpression = (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.ThisExpression)(), (0, _gen.Literal)(superMethodName), true), [propertyArg]);
+                if (p[1].type === "CallExpression" && p[1].callee === p[0]) {
+                  getSuperExpression = (0, _gen.CallExpression)((0, _gen.MemberExpression)(getSuperExpression, (0, _gen.Literal)("bind"), true), [(0, _gen.ThisExpression)()]);
+                }
+                this.replace(p[0], getSuperExpression);
+              };
+            }
+          });
+          var originalParams = functionExpression.params;
+          var originalBody = functionExpression.body.body;
+          functionExpression.body.body = [(0, _gen.ReturnStatement)((0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(fnName), (0, _gen.Literal)("apply"), true), [(0, _gen.ThisExpression)(), (0, _gen.Identifier)("arguments")]))];
+          functionExpression.params = [];
+          if (methodDefinition.kind === "set") {
+            functionExpression.params = [(0, _gen.Identifier)(this.getPlaceholder())];
+          }
+          (0, _insert.prepend)(lexicalScope, (0, _gen.FunctionDeclaration)(fnName, [...originalParams], [...originalBody]));
+        }
+      }
+      if (superMethodName) {
+        classBody.body.push((0, _gen.MethodDefinition)((0, _gen.Literal)(superMethodName), (0, _gen.FunctionExpression)([(0, _gen.Identifier)("key")], [(0, _gen.ReturnStatement)((0, _gen.MemberExpression)((0, _gen.Super)(), (0, _gen.Identifier)("key"), true))]), "method", false, true));
+      }
+    };
+  }
+}
+exports.default = ClassExtraction;

package/dist/transforms/extraction/duplicateLiteralsRemoval.js

@@ -4,33 +4,21 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _transform = _interopRequireDefault(require("../transform"));
-
 var _gen = require("../../util/gen");
-
 var _insert = require("../../util/insert");
-
 var _compare = require("../../util/compare");
-
 var _order = require("../../order");
-
-var _stringConcealing = require("../string/stringConcealing");
-
 var _probability = require("../../probability");
-
 var _assert = require("assert");
-
 var _random = require("../../util/random");
-
 var _traverse = require("../../traverse");
-
 var _identifiers = require("../../util/identifiers");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+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); }
 /**
  * [Duplicate Literals Removal](https://docs.jscrambler.com/code-integrity/documentation/transformations/duplicate-literals-removal) replaces duplicate literals with a variable name.
  *
@@ -50,58 +38,49 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
  * ```
  */
 class DuplicateLiteralsRemoval extends _transform.default {
-  // The array holding all the duplicate literals
-  // The array expression node to be inserted into the program
-
-  /**
-   * Literals in the array
-   */
-
-  /**
-   * Literals are saved here the first time they are seen.
-   */
-
-  /**
-   * Block -> { functionName, indexShift }
-   */
   constructor(o) {
     super(o, _order.ObfuscateOrder.DuplicateLiteralsRemoval);
-
+    // The array holding all the duplicate literals
     _defineProperty(this, "arrayName", void 0);
-
+    // The array expression node to be inserted into the program
     _defineProperty(this, "arrayExpression", void 0);
-
+    /**
+     * Literals in the array
+     */
     _defineProperty(this, "map", void 0);
-
+    /**
+     * Literals are saved here the first time they are seen.
+     */
     _defineProperty(this, "first", void 0);
-
+    /**
+     * Block -> { functionName, indexShift }
+     */
     _defineProperty(this, "functions", void 0);
-
     this.map = new Map();
     this.first = new Map();
     this.functions = new Map();
   }
-
   apply(tree) {
     super.apply(tree);
-
     if (this.arrayName && this.arrayExpression.elements.length > 0) {
       // This function simply returns the array
       var getArrayFn = this.getPlaceholder();
-      (0, _insert.append)(tree, (0, _gen.FunctionDeclaration)(getArrayFn, [], [(0, _gen.ReturnStatement)(this.arrayExpression)])); // This variable holds the array
+      (0, _insert.append)(tree, (0, _gen.FunctionDeclaration)(getArrayFn, [], [(0, _gen.ReturnStatement)(this.arrayExpression)]));
 
-      (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.arrayName, (0, _gen.CallExpression)((0, _gen.MemberExpression)((0, _gen.Identifier)(getArrayFn), (0, _gen.Literal)("call"), true), [(0, _gen.ThisExpression)()])))); // Create all the functions needed
+      // This variable holds the array
+      (0, _insert.prepend)(tree, (0, _gen.VariableDeclaration)((0, _gen.VariableDeclarator)(this.arrayName, (0, _gen.CallExpression)((0, _gen.Identifier)(getArrayFn), []))));
 
+      // Create all the functions needed
       for (var blockNode of this.functions.keys()) {
         var {
           functionName,
           indexShift
         } = this.functions.get(blockNode);
         var propertyNode = (0, _gen.BinaryExpression)("-", (0, _gen.Identifier)("index_param"), (0, _gen.Literal)(indexShift));
-        var indexRangeInclusive = [0 + indexShift - 1, this.map.size + indexShift]; // The function uses mangling to hide the index being accessed
-
-        var mangleCount = (0, _random.getRandomInteger)(1, 10);
+        var indexRangeInclusive = [0 + indexShift - 1, this.map.size + indexShift];
 
+        // The function uses mangling to hide the index being accessed
+        var mangleCount = (0, _random.getRandomInteger)(1, 5);
         for (var i = 0; i < mangleCount; i++) {
           var operator = (0, _random.choice)([">", "<"]);
           var compareValue = (0, _random.choice)(indexRangeInclusive);
@@ -110,86 +89,74 @@ class DuplicateLiteralsRemoval extends _transform.default {
           var testValue = operator === ">" && compareValue === indexRangeInclusive[0] || operator === "<" && compareValue === indexRangeInclusive[1];
           propertyNode = (0, _gen.ConditionalExpression)(test, testValue ? propertyNode : alternate, !testValue ? propertyNode : alternate);
         }
-
         var returnArgument = (0, _gen.MemberExpression)((0, _gen.Identifier)(this.arrayName), propertyNode, true);
         (0, _insert.prepend)(blockNode, (0, _gen.FunctionDeclaration)(functionName, [(0, _gen.Identifier)("index_param")], [(0, _gen.ReturnStatement)(returnArgument)]));
       }
     }
   }
-
   match(object, parents) {
-    return (0, _compare.isPrimitive)(object) && !(0, _compare.isDirective)(object, parents) && !(0, _stringConcealing.isModuleSource)(object, parents) && !parents.find(x => x.$dispatcherSkip);
+    return (0, _compare.isPrimitive)(object) && !(0, _compare.isDirective)(object, parents) && !(0, _compare.isModuleSource)(object, parents) && !parents.find(x => x.$multiTransformSkip);
   }
+
   /**
    * Converts ordinary literal to go through a getter function.
    * @param object
    * @param parents
    * @param index
    */
-
-
   transformLiteral(object, parents, index) {
-    var blockNode = (0, _random.choice)(parents.filter(x => this.functions.has(x))); // Create initial function if none exist
+    var blockNode = (0, _random.choice)(parents.filter(x => this.functions.has(x)));
 
+    // Create initial function if none exist
     if (this.functions.size === 0) {
       var root = parents[parents.length - 1];
       var rootFunctionName = this.getPlaceholder() + "_dLR_0";
       this.functions.set(root, {
-        functionName: rootFunctionName,
+        functionName: rootFunctionName + _constants.predictableFunctionTag,
         indexShift: (0, _random.getRandomInteger)(-100, 100)
       });
       blockNode = root;
-    } // If no function here exist, possibly create new chained function
-
+    }
 
+    // If no function here exist, possibly create new chained function
     var block = (0, _traverse.getBlock)(object, parents);
-
     if (!this.functions.has(block) && (0, _random.chance)(50 - this.functions.size)) {
-      var newFunctionName = this.getPlaceholder() + "_dLR_" + this.functions.size;
+      var newFunctionName = this.getPlaceholder() + "_dLR_" + this.functions.size + _constants.predictableFunctionTag;
       this.functions.set(block, {
         functionName: newFunctionName,
         indexShift: (0, _random.getRandomInteger)(-100, 100)
       });
       blockNode = block;
-    } // Derive the function to call from the selected blockNode
-
+    }
 
+    // Derive the function to call from the selected blockNode
     var {
       functionName,
       indexShift
-    } = this.functions.get(blockNode); // Call the function given it's indexShift
+    } = this.functions.get(blockNode);
 
+    // Call the function given it's indexShift
     var callExpression = (0, _gen.CallExpression)((0, _gen.Identifier)(functionName), [(0, _gen.Literal)(index + indexShift)]);
     this.replaceIdentifierOrLiteral(object, callExpression, parents);
   }
-
   transform(object, parents) {
     return () => {
       if (object.type === "Identifier") {
         var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-        if (info.isLabel || info.spec.isDefined) return;
+        if (info.isLabel || info.spec.isDefined || info.spec.isModified) return;
       }
-
       if (object.regex) {
         return;
       }
-
       if (!(0, _probability.ComputeProbabilityMap)(this.options.duplicateLiteralsRemoval)) {
         return;
-      } // HARD CODED LIMIT of 10,000 (after 1,000 elements)
-
-
-      if (this.map.size > 1000 && (0, _random.chance)(this.map.size / 100)) return;
-
+      }
       if (this.arrayName && parents[0].object && parents[0].object.name == this.arrayName) {
         return;
       }
-
       var stringValue;
-
       if (object.type == "Literal") {
         stringValue = typeof object.value + ":" + object.value;
-
         if (object.value === null) {
           stringValue = "null:null";
         } else {
@@ -203,19 +170,16 @@ class DuplicateLiteralsRemoval extends _transform.default {
       } else {
         throw new Error("Unsupported primitive type: " + object.type);
       }
-
       (0, _assert.ok)(stringValue);
-
       if (this.map.has(stringValue) || this.first.has(stringValue)) {
         // Create the array if not already made
         if (!this.arrayName) {
           this.arrayName = this.getPlaceholder();
           this.arrayExpression = (0, _gen.ArrayExpression)([]);
-        } // Delete with first location
-
+        }
 
+        // Delete with first location
         var firstLocation = this.first.get(stringValue);
-
         if (firstLocation) {
           var index = this.map.size;
           (0, _assert.ok)(!this.map.has(stringValue));
@@ -226,18 +190,15 @@ class DuplicateLiteralsRemoval extends _transform.default {
           (0, _assert.ok)(this.arrayExpression.elements[index] === pushing);
           this.transformLiteral(firstLocation[0], firstLocation[1], index);
         }
-
         var index = this.map.get(stringValue);
         (0, _assert.ok)(typeof index === "number");
         this.transformLiteral(object, parents, index);
         return;
-      } // Save this, maybe a duplicate will be found.
-
+      }
 
+      // Save this, maybe a duplicate will be found.
       this.first.set(stringValue, [object, parents]);
     };
   }
-
 }
-
 exports.default = DuplicateLiteralsRemoval;

package/dist/transforms/extraction/objectExtraction.js

@@ -4,29 +4,17 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _transform = _interopRequireDefault(require("../transform"));
-
 var _traverse = require("../../traverse");
-
 var _gen = require("../../util/gen");
-
 var _insert = require("../../util/insert");
-
 var _order = require("../../order");
-
 var _identifiers = require("../../util/identifiers");
-
 var _compare = require("../../util/compare");
-
 var _probability = require("../../probability");
-
 var _assert = require("assert");
-
 var _guard = require("../../util/guard");
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * Extracts keys out of an object if possible.
  * ```js
@@ -52,13 +40,12 @@ class ObjectExtraction extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.ObjectExtraction);
   }
-
   match(object, parents) {
     return (0, _insert.isVarContext)(object);
   }
-
   transform(context, contextParents) {
     // ObjectExpression Extractor
+
     return () => {
       // First pass through to find the maps
       var objectDefs = Object.create(null);
@@ -69,45 +56,40 @@ class ObjectExtraction extends _transform.default {
           // this.log(object, parents);
           if (parents[0].type == "VariableDeclarator" && parents[0].init == object && parents[0].id.type == "Identifier") {
             var name = parents[0].id.name;
-
             if (name) {
               if ((0, _insert.getVarContext)(object, parents) != context) {
                 illegal.add(name);
                 return;
               }
-
               if (!object.properties.length) {
                 illegal.add(name);
                 return;
-              } // duplicate name
-
+              }
 
+              // duplicate name
               if (objectDefiningIdentifiers[name]) {
                 illegal.add(name);
                 return;
-              } // check for computed properties
-              // Change String literals to non-computed
-
+              }
 
+              // check for computed properties
+              // Change String literals to non-computed
               object.properties.forEach(prop => {
                 if (prop.computed && (0, _guard.isStringLiteral)(prop.key)) {
                   prop.computed = false;
                 }
               });
               var nonInitOrComputed = object.properties.find(x => x.kind !== "init" || x.computed);
-
               if (nonInitOrComputed) {
                 if (nonInitOrComputed.key) {
                   this.log(name + " has non-init/computed property: " + nonInitOrComputed.key.name || nonInitOrComputed.key.value);
                 } else {
                   this.log(name + " has spread-element or other type of property");
                 }
-
                 illegal.add(name);
                 return;
               } else {
                 var illegalName = object.properties.map(x => x.computed ? x.key.value : x.key.name || x.key.value).find(x => !x || !(0, _compare.isValidIdentifier)(x));
-
                 if (illegalName) {
                   this.log(name + " has an illegal property '" + illegalName + "'");
                   illegal.add(name);
@@ -120,12 +102,10 @@ class ObjectExtraction extends _transform.default {
                       return "EXIT";
                     }
                   });
-
                   if (isIllegal) {
                     illegal.add(name);
                     return;
                   }
-
                   objectDefs[name] = [object, parents];
                   objectDefiningIdentifiers[name] = [parents[0].id, [...parents]];
                 }
@@ -137,27 +117,24 @@ class ObjectExtraction extends _transform.default {
       illegal.forEach(name => {
         delete objectDefs[name];
         delete objectDefiningIdentifiers[name];
-      }); // this.log("object defs", objectDefs);
-      // huge map of changes
+      });
 
+      // this.log("object defs", objectDefs);
+      // huge map of changes
       var objectDefChanges = {};
-
       if (Object.keys(objectDefs).length) {
         // A second pass through is only required when extracting object keys
+
         // Second pass through the exclude the dynamic map (counting keys, re-assigning)
         (0, _traverse.walk)(context, contextParents, (object, parents) => {
           if (object.type == "Identifier") {
             var info = (0, _identifiers.getIdentifierInfo)(object, parents);
-
             if (!info.spec.isReferenced) {
               return;
             }
-
             var def = objectDefs[object.name];
-
             if (def) {
               var isIllegal = false;
-
               if (info.spec.isDefined) {
                 if (objectDefiningIdentifiers[object.name][0] !== object) {
                   this.log(object.name, "you can't redefine the object");
@@ -165,13 +142,11 @@ class ObjectExtraction extends _transform.default {
                 }
               } else {
                 var isMemberExpression = parents[0].type == "MemberExpression" && parents[0].object == object;
-
                 if (parents.find(x => x.type == "AssignmentExpression") && !isMemberExpression || parents.find(x => x.type == "UnaryExpression" && x.operator == "delete")) {
                   this.log(object.name, "you can't re-assign the object");
                   isIllegal = true;
                 } else if (isMemberExpression) {
                   var key = parents[0].property.value || parents[0].property.name;
-
                   if (parents[0].computed && parents[0].property.type !== "Literal") {
                     this.log(object.name, "object[expr] detected, only object['key'] is allowed");
                     isIllegal = true;
@@ -184,15 +159,13 @@ class ObjectExtraction extends _transform.default {
                     this.log(object.name, "not in initialized object.", def[0].properties, key);
                     isIllegal = true;
                   }
-
                   if (!isIllegal && key) {
                     // allowed.
                     // start the array if first time
                     if (!objectDefChanges[object.name]) {
                       objectDefChanges[object.name] = [];
-                    } // add to array
-
-
+                    }
+                    // add to array
                     objectDefChanges[object.name].push({
                       key: key,
                       object: object,
@@ -204,7 +177,6 @@ class ObjectExtraction extends _transform.default {
                   isIllegal = true;
                 }
               }
-
               if (isIllegal) {
                 // this is illegal, delete it from being moved and delete accessor changes from happening
                 this.log(object.name + " is illegal");
@@ -219,14 +191,13 @@ class ObjectExtraction extends _transform.default {
             //continue;
             return;
           }
-
           var [object, parents] = objectDefs[name];
           var declarator = parents[0];
           var declaration = parents[2];
           (0, _assert.ok)(declarator.type === "VariableDeclarator");
           (0, _assert.ok)(declaration.type === "VariableDeclaration");
-          var properties = object.properties; // change the prop names while extracting
-
+          var properties = object.properties;
+          // change the prop names while extracting
           var newPropNames = {};
           var variableDeclarators = [];
           properties.forEach(property => {
@@ -234,41 +205,38 @@ class ObjectExtraction extends _transform.default {
             var nn = name + "_" + keyName;
             newPropNames[keyName] = nn;
             var v = property.value;
-            variableDeclarators.push((0, _gen.VariableDeclarator)(nn, this.addComment(v, "".concat(name, ".").concat(keyName))));
+            variableDeclarators.push((0, _gen.VariableDeclarator)(nn, this.addComment(v, `${name}.${keyName}`)));
           });
           declaration.declarations.splice(declaration.declarations.indexOf(declarator), 1, ...variableDeclarators);
 
+          // const can only be safely changed to let
           if (declaration.kind === "const") {
-            declaration.kind = "var";
-          } // update all identifiers that pointed to the old object
-
+            declaration.kind = "let";
+          }
 
+          // update all identifiers that pointed to the old object
           objectDefChanges[name] && objectDefChanges[name].forEach(change => {
             if (!change.key) {
               this.error(new Error("key is undefined"));
             }
-
             if (newPropNames[change.key]) {
               var memberExpression = change.parents[0];
-
               if (memberExpression.type == "MemberExpression") {
-                this.replace(memberExpression, this.addComment((0, _gen.Identifier)(newPropNames[change.key]), "Original Accessor: ".concat(name, ".").concat(change.key)));
+                this.replace(memberExpression, this.addComment((0, _gen.Identifier)(newPropNames[change.key]), `Original Accessor: ${name}.${change.key}`));
               } else {
                 // Provide error with more information:
                 console.log(memberExpression);
-                this.error(new Error("should be MemberExpression, found type=".concat(memberExpression.type)));
+                this.error(new Error(`should be MemberExpression, found type=${memberExpression.type}`));
               }
             } else {
               console.log(objectDefChanges[name], newPropNames);
-              this.error(new Error("\"".concat(change.key, "\" not found in [").concat(Object.keys(newPropNames).join(", "), "] while flattening ").concat(name, ".")));
+              this.error(new Error(`"${change.key}" not found in [${Object.keys(newPropNames).join(", ")}] while flattening ${name}.`));
             }
           });
-          this.log("Extracted ".concat(Object.keys(newPropNames).length, " properties from ").concat(name, ", affecting ").concat(Object.keys(objectDefChanges[name] || {}).length, " line(s) of code."));
+          this.log(`Extracted ${Object.keys(newPropNames).length} properties from ${name}, affecting ${Object.keys(objectDefChanges[name] || {}).length} line(s) of code.`);
         });
       }
     };
   }
-
 }
-
 exports.default = ObjectExtraction;

package/dist/transforms/finalizer.js

@@ -4,19 +4,14 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _order = require("../order");
-
 var _gen = require("../util/gen");
-
 var _stringEncoding = _interopRequireDefault(require("./string/stringEncoding"));
-
 var _transform = _interopRequireDefault(require("./transform"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
+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); }
 /**
  * The Finalizer is the last transformation before the code is ready to be generated.
  *
@@ -32,24 +27,18 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 class Finalizer extends _transform.default {
   constructor(o) {
     super(o, _order.ObfuscateOrder.Finalizer);
-
     _defineProperty(this, "stringEncoding", void 0);
-
     this.stringEncoding = new _stringEncoding.default(o);
   }
-
   isNumberLiteral(object) {
     return object.type === "Literal" && typeof object.value === "number" && Math.floor(object.value) === object.value;
   }
-
   isBigIntLiteral(object) {
     return object.type === "Literal" && typeof object.value === "bigint";
   }
-
   match(object, parents) {
     return object.type === "Literal";
   }
-
   transform(object, parents) {
     // Hexadecimal Numbers
     if (this.options.hexadecimalNumbers && this.isNumberLiteral(object)) {
@@ -61,9 +50,9 @@ class Finalizer extends _transform.default {
         var newStr = (isNegative ? "-" : "") + "0x" + hex;
         this.replace(object, (0, _gen.Identifier)(newStr));
       };
-    } // BigInt support
-
+    }
 
+    // BigInt support
     if (this.isBigIntLiteral(object)) {
       // https://github.com/MichaelXF/js-confuser/issues/79
       return () => {
@@ -71,12 +60,9 @@ class Finalizer extends _transform.default {
         this.replace(object, (0, _gen.Identifier)(object.raw));
       };
     }
-
     if (this.options.stringEncoding && this.stringEncoding.match(object, parents)) {
       return this.stringEncoding.transform(object, parents);
     }
   }
-
 }
-
 exports.default = Finalizer;