js-confuser 2.0.0-alpha.5 → 2.0.1

package/src/transforms/string/stringEncoding.ts

@@ -1,80 +1,80 @@
-import { PluginInstance, PluginObject } from "../plugin";
-import * as t from "@babel/types";
-import { choice } from "../../utils/random-utils";
-import { GEN_NODE, NodeSymbol } from "../../constants";
-import { isModuleImport } from "../../utils/ast-utils";
-
-function pad(x: string, len: number): string {
-  while (x.length < len) {
-    x = "0" + x;
-  }
-  return x;
-}
-
-function even(x: string) {
-  if (x.length % 2 != 0) {
-    return "0" + x;
-  }
-  return x;
-}
-
-function toHexRepresentation(str: string) {
-  var escapedString = "";
-  str.split("").forEach((char) => {
-    var code = char.charCodeAt(0);
-    if (code < 128) {
-      escapedString += "\\x" + even(pad(code.toString(16), 2));
-    } else {
-      escapedString += char;
-    }
-  });
-
-  return escapedString;
-}
-
-function toUnicodeRepresentation(str: string) {
-  var escapedString = "";
-  str.split("").forEach((char) => {
-    var code = char.charCodeAt(0);
-    if (code < 128) {
-      escapedString += "\\u" + even(pad(code.toString(16), 4));
-    } else {
-      escapedString += char;
-    }
-  });
-
-  return escapedString;
-}
-
-export default (me: PluginInstance): PluginObject => {
-  return {
-    visitor: {
-      StringLiteral: {
-        exit(path) {
-          // Ignore module imports
-          if (isModuleImport(path)) return;
-
-          const { value } = path.node;
-
-          // Allow percentages
-          if (!me.computeProbabilityMap(me.options.stringEncoding, value))
-            return;
-
-          var type = choice(["hexadecimal", "unicode"]);
-
-          var escapedString = (
-            type == "hexadecimal"
-              ? toHexRepresentation
-              : toUnicodeRepresentation
-          )(value);
-
-          var id = t.identifier(`"${escapedString}"`);
-
-          (id as NodeSymbol)[GEN_NODE] = true;
-          path.replaceWith(id);
-          path.skip();
-        },
-      },
-    },
-  };
-};
+import { PluginInstance, PluginObject } from "../plugin";
+import * as t from "@babel/types";
+import { choice } from "../../utils/random-utils";
+import { GEN_NODE, NodeSymbol } from "../../constants";
+import { isModuleImport } from "../../utils/ast-utils";
+
+function pad(x: string, len: number): string {
+  while (x.length < len) {
+    x = "0" + x;
+  }
+  return x;
+}
+
+function even(x: string) {
+  if (x.length % 2 != 0) {
+    return "0" + x;
+  }
+  return x;
+}
+
+function toHexRepresentation(str: string) {
+  var escapedString = "";
+  str.split("").forEach((char) => {
+    var code = char.charCodeAt(0);
+    if (code < 128) {
+      escapedString += "\\x" + even(pad(code.toString(16), 2));
+    } else {
+      escapedString += char;
+    }
+  });
+
+  return escapedString;
+}
+
+function toUnicodeRepresentation(str: string) {
+  var escapedString = "";
+  str.split("").forEach((char) => {
+    var code = char.charCodeAt(0);
+    if (code < 128) {
+      escapedString += "\\u" + even(pad(code.toString(16), 4));
+    } else {
+      escapedString += char;
+    }
+  });
+
+  return escapedString;
+}
+
+export default (me: PluginInstance): PluginObject => {
+  return {
+    visitor: {
+      StringLiteral: {
+        exit(path) {
+          // Ignore module imports
+          if (isModuleImport(path)) return;
+
+          const { value } = path.node;
+
+          // Allow percentages
+          if (!me.computeProbabilityMap(me.options.stringEncoding, value))
+            return;
+
+          var type = choice(["hexadecimal", "unicode"]);
+
+          var escapedString = (
+            type == "hexadecimal"
+              ? toHexRepresentation
+              : toUnicodeRepresentation
+          )(value);
+
+          var id = t.identifier(`"${escapedString}"`);
+
+          (id as NodeSymbol)[GEN_NODE] = true;
+          path.replaceWith(id);
+          path.skip();
+        },
+      },
+    },
+  };
+};

package/src/transforms/string/stringSplitting.ts

@@ -1,77 +1,77 @@
-import { PluginArg, PluginObject } from "../plugin";
-import { getRandomInteger, splitIntoChunks } from "../../utils/random-utils";
-import { binaryExpression, stringLiteral } from "@babel/types";
-import { ok } from "assert";
-import { Order } from "../../order";
-import {
-  ensureComputedExpression,
-  isModuleImport,
-} from "../../utils/ast-utils";
-
-export default ({ Plugin }: PluginArg): PluginObject => {
-  const me = Plugin(Order.StringSplitting, {
-    changeData: {
-      strings: 0,
-    },
-  });
-
-  return {
-    visitor: {
-      StringLiteral: {
-        exit(path) {
-          var object = path.node;
-
-          // Don't change module imports
-          if (isModuleImport(path)) return;
-
-          var size = Math.round(
-            Math.max(6, object.value.length / getRandomInteger(3, 8))
-          );
-          if (object.value.length <= size) {
-            return;
-          }
-
-          var chunks = splitIntoChunks(object.value, size);
-          if (!chunks || chunks.length <= 1) {
-            return;
-          }
-
-          if (
-            !me.computeProbabilityMap(me.options.stringSplitting, object.value)
-          ) {
-            return;
-          }
-
-          var binExpr;
-          var parent;
-          var last = chunks.pop();
-          chunks.forEach((chunk, i) => {
-            if (i == 0) {
-              parent = binExpr = binaryExpression(
-                "+",
-                stringLiteral(chunk),
-                stringLiteral("")
-              );
-            } else {
-              binExpr.left = binaryExpression(
-                "+",
-                { ...binExpr.left },
-                stringLiteral(chunk)
-              );
-              ok(binExpr);
-            }
-          });
-
-          parent.right = stringLiteral(last);
-
-          me.changeData.strings++;
-
-          ensureComputedExpression(path);
-
-          path.replaceWith(parent);
-          path.skip();
-        },
-      },
-    },
-  };
-};
+import { PluginArg, PluginObject } from "../plugin";
+import { getRandomInteger, splitIntoChunks } from "../../utils/random-utils";
+import { binaryExpression, stringLiteral } from "@babel/types";
+import { ok } from "assert";
+import { Order } from "../../order";
+import {
+  ensureComputedExpression,
+  isModuleImport,
+} from "../../utils/ast-utils";
+
+export default ({ Plugin }: PluginArg): PluginObject => {
+  const me = Plugin(Order.StringSplitting, {
+    changeData: {
+      strings: 0,
+    },
+  });
+
+  return {
+    visitor: {
+      StringLiteral: {
+        exit(path) {
+          var object = path.node;
+
+          // Don't change module imports
+          if (isModuleImport(path)) return;
+
+          var size = Math.round(
+            Math.max(6, object.value.length / getRandomInteger(3, 8))
+          );
+          if (object.value.length <= size) {
+            return;
+          }
+
+          var chunks = splitIntoChunks(object.value, size);
+          if (!chunks || chunks.length <= 1) {
+            return;
+          }
+
+          if (
+            !me.computeProbabilityMap(me.options.stringSplitting, object.value)
+          ) {
+            return;
+          }
+
+          var binExpr;
+          var parent;
+          var last = chunks.pop();
+          chunks.forEach((chunk, i) => {
+            if (i == 0) {
+              parent = binExpr = binaryExpression(
+                "+",
+                stringLiteral(chunk),
+                stringLiteral("")
+              );
+            } else {
+              binExpr.left = binaryExpression(
+                "+",
+                { ...binExpr.left },
+                stringLiteral(chunk)
+              );
+              ok(binExpr);
+            }
+          });
+
+          parent.right = stringLiteral(last);
+
+          me.changeData.strings++;
+
+          ensureComputedExpression(path);
+
+          path.replaceWith(parent);
+          path.skip();
+        },
+      },
+    },
+  };
+};