js-confuser 2.0.0-alpha.5 → 2.0.1

package/src/utils/function-utils.ts

@@ -1,50 +1,50 @@
-import { NodePath } from "@babel/traverse";
-import * as t from "@babel/types";
-import { FN_LENGTH, NodeSymbol, variableFunctionName } from "../constants";
-
-/**
- * @example __JS_CONFUSER_VAR__(identifier) // true
- * @param path
- * @returns
- */
-export function isVariableFunctionIdentifier(path: NodePath<t.Node>) {
-  if (
-    path.isIdentifier() &&
-    path.listKey === "arguments" &&
-    path.key === 0 &&
-    path.parentPath?.isCallExpression()
-  ) {
-    const callee = path.parentPath.get("callee");
-    return callee.isIdentifier({ name: variableFunctionName });
-  }
-
-  return false;
-}
-
-/**
- * Computes the `function.length` property given the parameter nodes.
- *
- * @example function abc(a, b, c = 1, ...d) {} // abc.length = 2
- */
-export function computeFunctionLength(fnPath: NodePath<t.Function>): number {
-  var savedLength = (fnPath.node as NodeSymbol)[FN_LENGTH];
-  if (typeof savedLength === "number") {
-    return savedLength;
-  }
-
-  var count = 0;
-
-  for (var parameterNode of fnPath.node.params) {
-    if (
-      parameterNode.type === "Identifier" ||
-      parameterNode.type === "ObjectPattern" ||
-      parameterNode.type === "ArrayPattern"
-    ) {
-      count++;
-    } else {
-      break;
-    }
-  }
-
-  return count;
-}
+import { NodePath } from "@babel/traverse";
+import * as t from "@babel/types";
+import { FN_LENGTH, NodeSymbol, variableFunctionName } from "../constants";
+
+/**
+ * @example __JS_CONFUSER_VAR__(identifier) // true
+ * @param path
+ * @returns
+ */
+export function isVariableFunctionIdentifier(path: NodePath<t.Node>) {
+  if (
+    path.isIdentifier() &&
+    path.listKey === "arguments" &&
+    path.key === 0 &&
+    path.parentPath?.isCallExpression()
+  ) {
+    const callee = path.parentPath.get("callee");
+    return callee.isIdentifier({ name: variableFunctionName });
+  }
+
+  return false;
+}
+
+/**
+ * Computes the `function.length` property given the parameter nodes.
+ *
+ * @example function abc(a, b, c = 1, ...d) {} // abc.length = 2
+ */
+export function computeFunctionLength(fnPath: NodePath<t.Function>): number {
+  var savedLength = (fnPath.node as NodeSymbol)[FN_LENGTH];
+  if (typeof savedLength === "number") {
+    return savedLength;
+  }
+
+  var count = 0;
+
+  for (var parameterNode of fnPath.node.params) {
+    if (
+      parameterNode.type === "Identifier" ||
+      parameterNode.type === "ObjectPattern" ||
+      parameterNode.type === "ArrayPattern"
+    ) {
+      count++;
+    } else {
+      break;
+    }
+  }
+
+  return count;
+}

package/src/utils/gen-utils.ts

@@ -1,48 +1,48 @@
-import { reservedKeywords } from "../constants";
-import { shuffle } from "./random-utils";
-
-export function alphabeticalGenerator(index: number) {
-  let name = "";
-  while (index > 0) {
-    var t = (index - 1) % 52;
-    var thisChar =
-      t >= 26 ? String.fromCharCode(65 + t - 26) : String.fromCharCode(97 + t);
-    name = thisChar + name;
-    index = ((index - t) / 52) | 0;
-  }
-  if (!name) {
-    name = "_";
-  }
-  return name;
-}
-
-export function createZeroWidthGenerator() {
-  var maxSize = 0;
-  var currentKeyWordsArray: string[] = [];
-
-  function generateArray() {
-    var result = reservedKeywords
-      .map(
-        (keyWord) =>
-          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
-      )
-      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
-
-    if (!result.length) {
-      ++maxSize;
-      return generateArray();
-    }
-
-    return shuffle(result);
-  }
-
-  function getNextVariable(): string {
-    if (!currentKeyWordsArray.length) {
-      ++maxSize;
-      currentKeyWordsArray = generateArray();
-    }
-    return currentKeyWordsArray.pop();
-  }
-
-  return { generate: getNextVariable };
-}
+import { reservedKeywords } from "../constants";
+import { shuffle } from "./random-utils";
+
+export function alphabeticalGenerator(index: number) {
+  let name = "";
+  while (index > 0) {
+    var t = (index - 1) % 52;
+    var thisChar =
+      t >= 26 ? String.fromCharCode(65 + t - 26) : String.fromCharCode(97 + t);
+    name = thisChar + name;
+    index = ((index - t) / 52) | 0;
+  }
+  if (!name) {
+    name = "_";
+  }
+  return name;
+}
+
+export function createZeroWidthGenerator() {
+  var maxSize = 0;
+  var currentKeyWordsArray: string[] = [];
+
+  function generateArray() {
+    var result = reservedKeywords
+      .map(
+        (keyWord) =>
+          keyWord + "\u200C".repeat(Math.max(maxSize - keyWord.length, 1))
+      )
+      .filter((craftedVariableName) => craftedVariableName.length == maxSize);
+
+    if (!result.length) {
+      ++maxSize;
+      return generateArray();
+    }
+
+    return shuffle(result);
+  }
+
+  function getNextVariable(): string {
+    if (!currentKeyWordsArray.length) {
+      ++maxSize;
+      currentKeyWordsArray = generateArray();
+    }
+    return currentKeyWordsArray.pop();
+  }
+
+  return { generate: getNextVariable };
+}

package/src/utils/node.ts

@@ -1,78 +1,78 @@
-import * as t from "@babel/types";
-import { ok } from "assert";
-
-export type LiteralValue = string | number | boolean | undefined | null;
-export const createLiteral = (value: LiteralValue) => {
-  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);
-  }
-
-  ok(false);
-};
-
-/**
- * Handles both positive and negative numeric literals
- * @param value
- * @returns
- */
-export function numericLiteral(
-  value: number
-): t.NumericLiteral | t.UnaryExpression {
-  ok(typeof value === "number");
-
-  if (value < 0) {
-    return t.unaryExpression("-", t.numericLiteral(-value));
-  }
-  return t.numericLiteral(value);
-}
-
-export function deepClone(node: t.Node | t.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
-    const clonedObj = {};
-
-    // Handle string and symbol property keys
-
-    Object.getOwnPropertyNames(obj).forEach((key) => {
-      const value = obj[key];
-      clonedObj[key] = deepClone(value);
-    });
-
-    // Copy simple symbols (Avoid objects = infinite recursion)
-    Object.getOwnPropertySymbols(obj).forEach((symbol) => {
-      const value = obj[symbol];
-      if (typeof value !== "object") {
-        clonedObj[symbol] = deepClone(value);
-      }
-    });
-
-    return clonedObj;
-  }
-
-  return deepClone(node);
-}
+import * as t from "@babel/types";
+import { ok } from "assert";
+
+export type LiteralValue = string | number | boolean | undefined | null;
+export const createLiteral = (value: LiteralValue) => {
+  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);
+  }
+
+  ok(false);
+};
+
+/**
+ * Handles both positive and negative numeric literals
+ * @param value
+ * @returns
+ */
+export function numericLiteral(
+  value: number
+): t.NumericLiteral | t.UnaryExpression {
+  ok(typeof value === "number");
+
+  if (value < 0) {
+    return t.unaryExpression("-", t.numericLiteral(-value));
+  }
+  return t.numericLiteral(value);
+}
+
+export function deepClone(node: t.Node | t.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
+    const clonedObj = {};
+
+    // Handle string and symbol property keys
+
+    Object.getOwnPropertyNames(obj).forEach((key) => {
+      const value = obj[key];
+      clonedObj[key] = deepClone(value);
+    });
+
+    // Copy simple symbols (Avoid objects = infinite recursion)
+    Object.getOwnPropertySymbols(obj).forEach((symbol) => {
+      const value = obj[symbol];
+      if (typeof value !== "object") {
+        clonedObj[symbol] = deepClone(value);
+      }
+    });
+
+    return clonedObj;
+  }
+
+  return deepClone(node);
+}

package/src/utils/object-utils.ts

@@ -1,21 +1,21 @@
-/**
- * Creates an object from the given keys and values arrays.
- * @param keys
- * @param values
- */
-export function createObject<T>(
-  keys: string[],
-  values: T[]
-): { [key: string]: T } {
-  if (keys.length !== values.length) {
-    throw new Error("length mismatch");
-  }
-
-  var newObject = {};
-
-  keys.forEach((x, i) => {
-    newObject[x] = values[i];
-  });
-
-  return newObject;
-}
+/**
+ * Creates an object from the given keys and values arrays.
+ * @param keys
+ * @param values
+ */
+export function createObject<T>(
+  keys: string[],
+  values: T[]
+): { [key: string]: T } {
+  if (keys.length !== values.length) {
+    throw new Error("length mismatch");
+  }
+
+  var newObject = {};
+
+  keys.forEach((x, i) => {
+    newObject[x] = values[i];
+  });
+
+  return newObject;
+}

package/src/utils/random-utils.ts

@@ -1,93 +1,93 @@
-import { ok } from "assert";
-
-/**
- * Returns a random element from the given array
- * @param choices Array of items
- * @returns One of the items in the array at random
- */
-export function choice<T>(choices: T[]): T {
-  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%
- */
-export function chance(percentChance: number): boolean {
-  return Math.random() < percentChance / 100;
-}
-
-/**
- * **Mutates the given array**
- * @param array
- */
-export function shuffle<T>(array: T[]): T[] {
-  array.sort(() => Math.random() - 0.5);
-  return array;
-}
-
-/**
- * Returns a random hexadecimal string.
- *
- * @example getRandomHexString(6) => "CA96BF"
- * @param length
- * @returns
- */
-export function getRandomHexString(length: number) {
-  return [...Array(length)]
-    .map(() => Math.floor(Math.random() * 16).toString(16))
-    .join("")
-    .toUpperCase();
-}
-
-/**
- * @see https://github.com/MichaelXF/js-confuser/issues/150#issuecomment-2466159582
- */
-export function getRandomChineseString(length: number) {
-  const characters: string[] = [];
-  for (let i = 0; i < length; i++)
-    characters.push(
-      String.fromCharCode(
-        Math.floor(Math.random() * (0x9fff - 0x4e00)) + 0x4e00
-      )
-    );
-  return characters.join("");
-}
-
-/**
- * Returns a random string.
- */
-export function getRandomString(length: number) {
-  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;
-}
-
-export function getRandom(min: number, max: number) {
-  return Math.random() * (max - min) + min;
-}
-
-export function getRandomInteger(min: number, max: number) {
-  return Math.floor(getRandom(min, max));
-}
-
-export function splitIntoChunks(str: string, size: number) {
-  ok(typeof str === "string", "str must be typeof string");
-  ok(typeof size === "number", "size must be typeof number");
-  ok(Math.floor(size) === size, "size must be integer");
-
-  const numChunks = Math.ceil(str.length / size);
-  const chunks: string[] = new Array(numChunks);
-
-  for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
-    chunks[i] = str.substr(o, size);
-  }
-
-  return chunks;
-}
+import { ok } from "assert";
+
+/**
+ * Returns a random element from the given array
+ * @param choices Array of items
+ * @returns One of the items in the array at random
+ */
+export function choice<T>(choices: T[]): T {
+  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%
+ */
+export function chance(percentChance: number): boolean {
+  return Math.random() < percentChance / 100;
+}
+
+/**
+ * **Mutates the given array**
+ * @param array
+ */
+export function shuffle<T>(array: T[]): T[] {
+  array.sort(() => Math.random() - 0.5);
+  return array;
+}
+
+/**
+ * Returns a random hexadecimal string.
+ *
+ * @example getRandomHexString(6) => "CA96BF"
+ * @param length
+ * @returns
+ */
+export function getRandomHexString(length: number) {
+  return [...Array(length)]
+    .map(() => Math.floor(Math.random() * 16).toString(16))
+    .join("")
+    .toUpperCase();
+}
+
+/**
+ * @see https://github.com/MichaelXF/js-confuser/issues/150#issuecomment-2466159582
+ */
+export function getRandomChineseString(length: number) {
+  const characters: string[] = [];
+  for (let i = 0; i < length; i++)
+    characters.push(
+      String.fromCharCode(
+        Math.floor(Math.random() * (0x9fff - 0x4e00)) + 0x4e00
+      )
+    );
+  return characters.join("");
+}
+
+/**
+ * Returns a random string.
+ */
+export function getRandomString(length: number) {
+  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;
+}
+
+export function getRandom(min: number, max: number) {
+  return Math.random() * (max - min) + min;
+}
+
+export function getRandomInteger(min: number, max: number) {
+  return Math.floor(getRandom(min, max));
+}
+
+export function splitIntoChunks(str: string, size: number) {
+  ok(typeof str === "string", "str must be typeof string");
+  ok(typeof size === "number", "size must be typeof number");
+  ok(Math.floor(size) === size, "size must be integer");
+
+  const numChunks = Math.ceil(str.length / size);
+  const chunks: string[] = new Array(numChunks);
+
+  for (let i = 0, o = 0; i < numChunks; ++i, o += size) {
+    chunks[i] = str.substr(o, size);
+  }
+
+  return chunks;
+}