js-confuser 1.7.2 → 2.0.0-alpha.0

package/dist/utils/node.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createLiteral = void 0;
+exports.deepClone = deepClone;
+exports.numericLiteral = numericLiteral;
+var t = _interopRequireWildcard(require("@babel/types"));
+var _assert = require("assert");
+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 _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); }
+var createLiteral = exports.createLiteral = function createLiteral(value) {
+  if (value === null) return t.nullLiteral();
+  if (value === undefined) return t.identifier("undefined");
+  switch (_typeof(value)) {
+    case "string":
+      return t.stringLiteral(value);
+    case "number":
+      return numericLiteral(value);
+    case "boolean":
+      return t.booleanLiteral(value);
+  }
+  (0, _assert.ok)(false);
+};
+
+/**
+ * Handles both positive and negative numeric literals
+ * @param value
+ * @returns
+ */
+function numericLiteral(value) {
+  (0, _assert.ok)(typeof value === "number");
+  if (value < 0) {
+    return t.unaryExpression("-", t.numericLiteral(-value));
+  }
+  return t.numericLiteral(value);
+}
+function deepClone(node) {
+  function deepClone(obj) {
+    // Handle non-objects like null, undefined, primitive values, or functions
+    if (obj === null || _typeof(obj) !== "object") {
+      return obj;
+    }
+
+    // Handle Date
+    if (obj instanceof Date) {
+      return new Date(obj);
+    }
+
+    // Handle Array
+    if (Array.isArray(obj)) {
+      return obj.map(deepClone);
+    }
+
+    // Handle Objects
+    var clonedObj = {};
+
+    // Handle string and symbol property keys
+
+    Object.getOwnPropertyNames(obj).forEach(function (key) {
+      var value = obj[key];
+      clonedObj[key] = deepClone(value);
+    });
+
+    // Copy simple symbols (Avoid objects = infinite recursion)
+    Object.getOwnPropertySymbols(obj).forEach(function (symbol) {
+      var value = obj[symbol];
+      if (_typeof(value) !== "object") {
+        clonedObj[symbol] = deepClone(value);
+      }
+    });
+    return clonedObj;
+  }
+  return deepClone(node);
+}

package/dist/utils/object-utils.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createObject = createObject;
+/**
+ * Creates an object from the given keys and values arrays.
+ * @param keys
+ * @param values
+ */
+function createObject(keys, values) {
+  if (keys.length !== values.length) {
+    throw new Error("length mismatch");
+  }
+  var newObject = {};
+  keys.forEach(function (x, i) {
+    newObject[x] = values[i];
+  });
+  return newObject;
+}

package/dist/utils/random-utils.js

@@ -0,0 +1,91 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chance = chance;
+exports.choice = choice;
+exports.getRandom = getRandom;
+exports.getRandomHexString = getRandomHexString;
+exports.getRandomInteger = getRandomInteger;
+exports.getRandomString = getRandomString;
+exports.shuffle = shuffle;
+exports.splitIntoChunks = splitIntoChunks;
+var _assert = require("assert");
+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; }
+/**
+ * Returns a random element from the given array
+ * @param choices Array of items
+ * @returns One of the items in the array at random
+ */
+function choice(choices) {
+  var index = Math.floor(Math.random() * choices.length);
+  return choices[index];
+}
+
+/**
+ * Returns a true/false based on the percent chance (0%-100%)
+ * @param percentChance AS A PERCENTAGE 0 - 100%
+ */
+function chance(percentChance) {
+  return Math.random() < percentChance / 100;
+}
+
+/**
+ * **Mutates the given array**
+ * @param array
+ */
+function shuffle(array) {
+  array.sort(function () {
+    return Math.random() - 0.5;
+  });
+  return array;
+}
+
+/**
+ * Returns a random hexadecimal string.
+ *
+ * @example getRandomHexString(6) => "CA96BF"
+ * @param length
+ * @returns
+ */
+function getRandomHexString(length) {
+  return _toConsumableArray(Array(length)).map(function () {
+    return Math.floor(Math.random() * 16).toString(16);
+  }).join("").toUpperCase();
+}
+
+/**
+ * Returns a random string.
+ */
+function getRandomString(length) {
+  var result = "";
+  var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  var charactersLength = characters.length;
+  for (var i = 0; i < length; i++) {
+    result += characters.charAt(Math.floor(Math.random() * charactersLength));
+  }
+  return result;
+}
+function getRandom(min, max) {
+  return Math.random() * (max - min) + min;
+}
+function getRandomInteger(min, max) {
+  return Math.floor(getRandom(min, max));
+}
+function splitIntoChunks(str, size) {
+  (0, _assert.ok)(typeof str === "string", "str must be typeof string");
+  (0, _assert.ok)(typeof size === "number", "size must be typeof number");
+  (0, _assert.ok)(Math.floor(size) === size, "size must be integer");
+  var numChunks = Math.ceil(str.length / size);
+  var chunks = new Array(numChunks);
+  for (var i = 0, o = 0; i < numChunks; ++i, o += size) {
+    chunks[i] = str.substr(o, size);
+  }
+  return chunks;
+}

package/dist/utils/static-utils.js

@@ -0,0 +1,64 @@
+"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.isStaticValue = isStaticValue;
+var t = _interopRequireWildcard(require("@babel/types"));
+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 to check if a node is a static value
+function isStaticValue(node) {
+  // Check for literals which are considered static
+  if (t.isStringLiteral(node) || t.isNumericLiteral(node) || t.isBooleanLiteral(node) || t.isNullLiteral(node)) {
+    if (t.isDirectiveLiteral(node)) return false;
+    return true;
+  }
+
+  // Handle unary expressions like -42
+  if (t.isUnaryExpression(node)) {
+    // Only consider certain operators as static (e.g., -, +)
+    if (["-", "+", "!", "~", "void"].includes(node.operator)) {
+      return isStaticValue(node.argument);
+    }
+    return false;
+  }
+
+  // Handle binary expressions with static values only
+  if (t.isBinaryExpression(node)) {
+    return isStaticValue(node.left) && isStaticValue(node.right);
+  }
+
+  // Handle logical expressions (&&, ||) with static values only
+  if (t.isLogicalExpression(node)) {
+    return isStaticValue(node.left) && isStaticValue(node.right);
+  }
+
+  // Handle conditional (ternary) expressions with static values
+  if (t.isConditionalExpression(node)) {
+    return isStaticValue(node.test) && isStaticValue(node.consequent) && isStaticValue(node.alternate);
+  }
+
+  // Handle array expressions where all elements are static
+  if (t.isArrayExpression(node)) {
+    return node.elements.every(function (element) {
+      return element !== null && isStaticValue(element);
+    });
+  }
+
+  // Handle object expressions where all properties are static
+  if (t.isObjectExpression(node)) {
+    return node.properties.every(function (prop) {
+      if (t.isObjectProperty(prop)) {
+        return isStaticValue(prop.key) && isStaticValue(prop.value);
+      } else if (t.isSpreadElement(prop)) {
+        return isStaticValue(prop.argument);
+      }
+      return false;
+    });
+  }
+
+  // Add more cases as needed, depending on what you consider "static"
+  return false;
+}

package/dist/validateOptions.js

@@ -0,0 +1,122 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyDefaultsToOptions = applyDefaultsToOptions;
+exports.validateOptions = validateOptions;
+var _assert = require("assert");
+var _presets = _interopRequireDefault(require("./presets"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { "default": e }; }
+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); }
+var validProperties = new Set(["preset", "target", "indent", "compact", "hexadecimalNumbers", "minify", "es5", "renameVariables", "renameGlobals", "renameLabels", "identifierGenerator", "controlFlowFlattening", "globalConcealing", "stringCompression", "stringConcealing", "stringEncoding", "stringSplitting", "duplicateLiteralsRemoval", "dispatcher", "rgf", "objectExtraction", "flatten", "deadCode", "calculator", "lock", "movedDeclarations", "opaquePredicates", "shuffle", "variableMasking", "verbose", "globalVariables", "debugComments", "preserveFunctionLength", "astScrambler", "customStringEncodings", "functionOutlining", "pack"]);
+var validLockProperties = new Set(["selfDefending", "antiDebug", "tamperProtection", "startDate", "endDate", "domainLock", "integrity", "countermeasures", "customLocks"]);
+function validateOptions(options) {
+  if (!options || Object.keys(options).length <= 1) {
+    /**
+     * Give a welcoming introduction to those who skipped the documentation.
+     */
+    var line = "You provided zero obfuscation options. By default everything is disabled.\nYou can use a preset with:\n\n> {target: '".concat(options.target || "node", "', preset: 'high' | 'medium' | 'low'}.\n\n\nView all settings here:\nhttps://github.com/MichaelXF/js-confuser#options");
+    throw new Error("\n\n" + line.split("\n").map(function (x) {
+      return "\t".concat(x);
+    }).join("\n") + "\n\n");
+  }
+  (0, _assert.ok)(options, "options cannot be null");
+  (0, _assert.ok)(options.target, "Missing options.target option (required, must one the following: 'browser' or 'node')");
+  (0, _assert.ok)(["browser", "node"].includes(options.target), "'".concat(options.target, "' is not a valid target mode"));
+  Object.keys(options).forEach(function (key) {
+    if (!validProperties.has(key)) {
+      throw new TypeError("Invalid option: '" + key + "'");
+    }
+  });
+  if (options.lock) {
+    (0, _assert.ok)(_typeof(options.lock) === "object", "options.lock must be an object");
+    Object.keys(options.lock).forEach(function (key) {
+      if (!validLockProperties.has(key)) {
+        throw new TypeError("Invalid lock option: '" + key + "'");
+      }
+    });
+
+    // Validate domain-lock option
+    if (options.lock.domainLock && typeof options.lock.domainLock !== "undefined") {
+      (0, _assert.ok)(Array.isArray(options.lock.domainLock), "domainLock must be an array");
+    }
+
+    // Validate start-date option
+    if (typeof options.lock.startDate !== "undefined" && options.lock.startDate) {
+      (0, _assert.ok)(typeof options.lock.startDate === "number" || options.lock.startDate instanceof Date, "startDate must be Date object or number");
+    }
+
+    // Validate end-date option
+    if (typeof options.lock.endDate !== "undefined" && options.lock.endDate) {
+      (0, _assert.ok)(typeof options.lock.endDate === "number" || options.lock.endDate instanceof Date, "endDate must be Date object or number");
+    }
+  }
+  if (options.preset) {
+    if (!_presets["default"][options.preset]) {
+      throw new TypeError("Unknown preset of '" + options.preset + "'");
+    }
+  }
+}
+
+/**
+ * Sets the default values and validates the configuration.
+ */
+function applyDefaultsToOptions(options) {
+  if (options.preset) {
+    // Clone and allow overriding
+    options = Object.assign({}, _presets["default"][options.preset], options);
+  }
+  if (!options.hasOwnProperty("compact")) {
+    options.compact = true; // Compact is on by default
+  }
+  if (!options.hasOwnProperty("renameGlobals")) {
+    options.renameGlobals = true; // RenameGlobals is on by default
+  }
+  if (!options.hasOwnProperty("preserveFunctionLength")) {
+    options.preserveFunctionLength = true; // preserveFunctionLength is on by default
+  }
+  if (!options.hasOwnProperty("renameLabels")) {
+    options.renameLabels = true; // RenameLabels is on by default
+  }
+  if (options.globalVariables && !(options.globalVariables instanceof Set)) {
+    options.globalVariables = new Set(Object.keys(options.globalVariables));
+  }
+  if (options.lock) {
+    (0, _assert.ok)(_typeof(options.lock) === "object", "options.lock must be an object");
+    if (options.lock.selfDefending) {
+      options.compact = true; // self defending forcibly enables this
+    }
+    if (!options.lock.customLocks) {
+      options.lock.customLocks = [];
+    }
+
+    // Convert 'startDate' and 'endDate' to Dates
+    if (typeof options.lock.startDate === "number") {
+      options.lock.startDate = new Date(options.lock.startDate);
+    }
+    if (typeof options.lock.endDate === "number") {
+      options.lock.endDate = new Date(options.lock.endDate);
+    }
+  }
+
+  // options.globalVariables outlines generic globals that should be present in the execution context
+  if (!options.hasOwnProperty("globalVariables")) {
+    options.globalVariables = new Set([]);
+    if (options.target == "browser") {
+      // browser
+      ["window", "document", "postMessage", "alert", "confirm", "location", "btoa", "atob", "unescape", "encodeURIComponent"].forEach(function (x) {
+        return options.globalVariables.add(x);
+      });
+    } else {
+      // node
+      ["global", "Buffer", "require", "process", "exports", "module", "__dirname", "__filename"].forEach(function (x) {
+        return options.globalVariables.add(x);
+      });
+    }
+    ["globalThis", "console", "parseInt", "parseFloat", "Math", "JSON", "RegExp", "Promise", "String", "Boolean", "Function", "Object", "Array", "Proxy", "Error", "TypeError", "ReferenceError", "RangeError", "EvalError", "setTimeout", "clearTimeout", "setInterval", "clearInterval", "setImmediate", "clearImmediate", "queueMicrotask", "isNaN", "isFinite", "Set", "Map", "WeakSet", "WeakMap", "Symbol"].forEach(function (x) {
+      return options.globalVariables.add(x);
+    });
+  }
+  return options;
+}

package/index.d.ts

@@ -1,19 +1,3 @@
-import TransformClass from "./src/transforms/transform";
-import ObfuscatorClass from "./src/obfuscator";
-import {
-  IJsConfuser as JsConfuser,
-  IJsConfuserDebugObfuscation,
-  IJsConfuserDebugTransformations,
-  IJsConfuserObfuscate,
-  IJsConfuserObfuscateAST,
-  IJsConfuserPresets,
-} from "./src/types";
+import JsConfuser from "./src";
 
 export default JsConfuser;
-export const obfuscate: IJsConfuserObfuscate;
-export const obfuscateAST: IJsConfuserObfuscateAST;
-export const presets: IJsConfuserPresets;
-export const debugTransformations: IJsConfuserDebugTransformations;
-export const debugObfuscation: IJsConfuserDebugObfuscation;
-export const Obfuscator: typeof ObfuscatorClass;
-export const Transform: typeof TransformClass;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "js-confuser",
-  "version": "1.7.2",
+  "version": "2.0.0-alpha.0",
   "description": "JavaScript Obfuscation Tool.",
   "main": "dist/index.js",
   "types": "index.d.ts",
   "scripts": {
-    "dev": "node ./dev.js",
-    "build": "./node_modules/.bin/babel src --out-dir dist --copy-files --extensions \".ts\"",
+    "build": "tsc && babel src --out-dir dist --extensions \".ts,.tsx\"",
+    "dev": "node babel.register.js",
     "test": "jest --forceExit",
-    "test:coverage": "jest --coverage",
-    "prepublishOnly": "npm run build & npm run test --forceExit"
+    "test:coverage": "jest --coverage --coverageReporters=html",
+    "prepublishOnly": "npm run build"
   },
   "keywords": [
     "obfuscator",
@@ -22,21 +22,28 @@
   "author": "MichaelXF",
   "license": "MIT",
   "dependencies": {
-    "acorn": "^8.12.1",
-    "escodegen": "^2.1.0"
+    "@babel/generator": "^7.25.6",
+    "@babel/parser": "^7.25.6",
+    "@babel/traverse": "^7.25.6",
+    "@babel/types": "^7.25.6",
+    "pako": "^2.1.0"
   },
   "devDependencies": {
-    "@babel/cli": "^7.17.6",
-    "@babel/core": "^7.17.8",
-    "@babel/plugin-proposal-class-properties": "^7.16.7",
-    "@babel/plugin-proposal-optional-chaining": "^7.16.7",
-    "@babel/preset-env": "^7.16.11",
-    "@babel/preset-typescript": "^7.16.7",
-    "@babel/register": "^7.17.7",
-    "@types/jest": "^26.0.24",
-    "@types/node": "^15.14.9",
-    "babel-jest": "^26.6.3",
-    "jest": "^29.5.0"
+    "@babel/cli": "^7.24.8",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.24.7",
+    "@babel/plugin-proposal-private-methods": "^7.18.6",
+    "@babel/preset-env": "^7.25.3",
+    "@babel/preset-typescript": "^7.24.7",
+    "@babel/register": "^7.24.6",
+    "@eslint/js": "^9.9.0",
+    "@types/babel__core": "^7.20.5",
+    "@types/jest": "^29.5.12",
+    "@types/node": "^22.2.0",
+    "globals": "^15.9.0",
+    "jest": "^29.7.0",
+    "typescript": "^5.5.4",
+    "typescript-eslint": "^8.1.0"
   },
   "repository": {
     "type": "git",
@@ -46,9 +53,7 @@
     "url": "https://github.com/MichaelXF/js-confuser/issues"
   },
   "homepage": "https://js-confuser.com",
-  "jest": {
-    "coverageReporters": [
-      "html"
-    ]
+  "engines": {
+    "node": ">=12.0.0"
   }
 }