js-confuser 2.0.0-alpha.4 → 2.0.0

package/src/transforms/lock/lock.ts

@@ -107,7 +107,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
           // Breaks any code formatter
           var namedFunction = function(){
             const test = function(){
-              const regExp=new RegExp('\\n');
+              const regExp= new RegExp('\\n');
               return regExp['test'](namedFunction)
             };
 
@@ -116,13 +116,6 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             }
           }
 
-          // Prepack Breaker
-          if(Math.random() > 1) {
-            while(true) {
-            console.log("Prepack Breaker");
-            }
-          }
-
           return namedFunction();
         }
     )();

package/src/transforms/pack.ts

@@ -60,6 +60,14 @@ export default function pack({ Plugin }: PluginArg): PluginObject {
         // Ensure bindings are removed -> variable becomes a global -> added to mappings object
         path.scope.crawl();
       },
+
+      // TODO: Add support for export statements
+      "ExportNamedDeclaration|ExportDefaultDeclaration|ExportAllDeclaration"(
+        path
+      ) {
+        me.error("Export statements are not supported in packed code.");
+      },
+
       Program(path) {
         path.scope.crawl();
       },

package/src/transforms/plugin.ts

@@ -97,14 +97,24 @@ export class PluginInstance {
       );
     }
 
+    const createCallArguments = (node: t.Expression): t.Expression[] => {
+      var args = [node];
+
+      // 1 is the default value in the setFunction template, can exclude it
+      if (originalLength !== 1) {
+        args.push(numericLiteral(originalLength));
+      }
+      return args;
+    };
+
     if (t.isFunctionDeclaration(path.node)) {
       prepend(
         path.parentPath,
         t.expressionStatement(
-          t.callExpression(t.identifier(this.setFunctionLengthName), [
-            t.identifier(path.node.id.name),
-            numericLiteral(originalLength),
-          ])
+          t.callExpression(
+            t.identifier(this.setFunctionLengthName),
+            createCallArguments(t.identifier(path.node.id.name))
+          )
         )
       );
     } else if (
@@ -112,10 +122,10 @@ export class PluginInstance {
       t.isArrowFunctionExpression(path.node)
     ) {
       path.replaceWith(
-        t.callExpression(t.identifier(this.setFunctionLengthName), [
-          path.node,
-          numericLiteral(originalLength),
-        ])
+        t.callExpression(
+          t.identifier(this.setFunctionLengthName),
+          createCallArguments(path.node)
+        )
       );
     } else {
       // TODO
@@ -158,6 +168,6 @@ export class PluginInstance {
    * @param messages
    */
   error(...messages: any[]): never {
-    throw new Error(`[${this.name}] ${messages.join(", ")}`);
+    throw new Error(`[${this.name}] ${messages.join(" ")}`);
   }
 }

package/src/transforms/string/stringConcealing.ts

@@ -45,6 +45,7 @@ export default ({ Plugin }: PluginArg): PluginObject => {
   const blocks: NodePath<t.Block>[] = [];
   const stringMap = new Map<string, number>();
   const stringArrayName = me.getPlaceholder() + "_array";
+  const stringArrayCacheName = me.getPlaceholder() + "_cache";
 
   let encodingImplementations: { [identity: string]: CustomStringEncoding } =
     Object.create(null);
@@ -263,6 +264,16 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             ])
           );
 
+          // Create the string cache
+          prependProgram(
+            programPath,
+            new Template(`
+            var {stringArrayCacheName} = {};
+            `).single({
+              stringArrayCacheName,
+            })
+          );
+
           for (var block of blocks) {
             const { encodingImplementation, fnName } = (
               block.node as NodeStringConcealing
@@ -283,7 +294,10 @@ export default ({ Plugin }: PluginArg): PluginObject => {
             // The main function to get the string value
             const retrieveFunctionDeclaration = new Template(`
               function ${fnName}(index) {
-                return ${decodeFnName}(${stringArrayName}[index]);
+                if (typeof ${stringArrayCacheName}[index] === 'undefined') {
+                  return ${stringArrayCacheName}[index] = ${decodeFnName}(${stringArrayName}[index]);
+                }
+                return ${stringArrayCacheName}[index];
               }
             `)
               .addSymbols(NO_REMOVE)

package/src/utils/ast-utils.ts

@@ -215,17 +215,6 @@ export function getMemberExpressionPropertyAsString(
   return null; // If the property cannot be determined
 }
 
-function registerPaths(paths: NodePath[]) {
-  for (var path of paths) {
-    if (path.isVariableDeclaration() && path.node.kind === "var") {
-      getParentFunctionOrProgram(path).scope.registerDeclaration(path);
-    }
-    path.scope.registerDeclaration(path);
-  }
-
-  return paths;
-}
-
 function nodeListToNodes(nodesIn: (t.Statement | t.Statement[])[]) {
   var nodes: t.Statement[] = [];
   if (Array.isArray(nodesIn[0])) {
@@ -257,12 +246,12 @@ export function append(
   if (listParent.isProgram()) {
     var lastExpression = listParent.get("body").at(-1);
     if (lastExpression.isExpressionStatement()) {
-      return registerPaths(lastExpression.insertBefore(nodes));
+      return lastExpression.insertBefore(nodes);
     }
   }
 
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.pushContainer("consequent", nodes));
+    return listParent.pushContainer("consequent", nodes);
   }
 
   if (listParent.isFunction()) {
@@ -278,11 +267,11 @@ export function append(
 
     ok(body.isBlockStatement());
 
-    return registerPaths(body.pushContainer("body", nodes));
+    return body.pushContainer("body", nodes);
   }
 
   ok(listParent.isBlock());
-  return registerPaths(listParent.pushContainer("body", nodes));
+  return listParent.pushContainer("body", nodes);
 }
 
 /**
@@ -322,11 +311,11 @@ export function prepend(
 
     if (afterImport === 0) {
       // No import declarations, so we can safely unshift everything
-      return registerPaths(listParent.unshiftContainer("body", nodes));
+      return listParent.unshiftContainer("body", nodes);
     }
 
     // Insert the nodes after the last import declaration
-    return registerPaths(body[afterImport - 1].insertAfter(nodes));
+    return body[afterImport - 1].insertAfter(nodes);
   }
 
   if (listParent.isFunction()) {
@@ -342,15 +331,15 @@ export function prepend(
 
     ok(body.isBlockStatement());
 
-    return registerPaths(body.unshiftContainer("body", nodes));
+    return body.unshiftContainer("body", nodes);
   }
 
   if (listParent.isBlock()) {
-    return registerPaths(listParent.unshiftContainer("body", nodes));
+    return listParent.unshiftContainer("body", nodes);
   }
 
   if (listParent.isSwitchCase()) {
-    return registerPaths(listParent.unshiftContainer("consequent", nodes));
+    return listParent.unshiftContainer("consequent", nodes);
   }
 
   ok(false);
@@ -564,7 +553,7 @@ export function isModifiedIdentifier(identifierPath: NodePath<t.Identifier>) {
 
 export function replaceDefiningIdentifierToMemberExpression(
   path: NodePath<t.Identifier>,
-  memberExpression: t.MemberExpression
+  memberExpression: t.MemberExpression | t.Identifier
 ) {
   // function id(){} -> var id = function() {}
   if (path.key === "id" && path.parentPath.isFunctionDeclaration()) {