DuplicateLiteralsRemoval

Author: echo094

src/plugin/jsconfuser.js

@@ -5,10 +5,6 @@ const t = require('@babel/types')
 const ivm = require('isolated-vm')
 
 const isolate = new ivm.Isolate()
-const globalContext = isolate.createContextSync()
-function virtualGlobalEval(jsStr) {
-  return globalContext.evalSync(String(jsStr))
-}
 
 const collect_id = {
   arrowFunc: null,
@@ -148,6 +144,120 @@ const deMinifyArrow = {
   },
 }
 
+function checkArrayName(path) {
+  if (path.key !== 'argument') {
+    return null
+  }
+  const ret_path = path.parentPath
+  if (!ret_path.isReturnStatement() || ret_path.key !== 0) {
+    return null
+  }
+  const array_fn_path = ret_path.getFunctionParent()
+  const array_fn_name = array_fn_path.node.id?.name
+  if (!array_fn_name) {
+    return null
+  }
+  const binding = array_fn_path.parentPath.scope.bindings[array_fn_name]
+  if (binding.references !== 1) {
+    return null
+  }
+  let ref = binding.referencePaths[0]
+  while (ref && !ref.isAssignmentExpression()) {
+    ref = ref.parentPath
+  }
+  if (!ref) {
+    return null
+  }
+  const array_name = ref.node.left?.name
+  if (!array_name) {
+    return null
+  }
+  return {
+    func_name: array_fn_name,
+    func_path: array_fn_path,
+    array_name: array_name,
+    array_path: ref,
+  }
+}
+
+function parseArrayWarp(vm, path) {
+  let func = path.getFunctionParent(path)
+  let name = null
+  let binding = null
+  if (func.isArrowFunctionExpression()) {
+    func = func.parentPath
+    name = func.node.id.name
+    binding = func.scope.getBinding(name)
+  } else {
+    name = func.node.id.name
+    binding = func.parentPath.scope.getBinding(name)
+  }
+  console.log(`Process array warp function: ${name}`)
+  vm.evalSync(generator(func.node).code)
+  for (const ref of binding.referencePaths) {
+    const call = ref.parentPath
+    if (ref.key !== 'callee') {
+      console.warn(`Unexpected ref of array warp function: ${call}`)
+      continue
+    }
+    const ret = vm.evalSync(generator(call.node).code)
+    if (typeof ret === 'string') {
+      call.replaceWith(t.stringLiteral(ret))
+    } else {
+      call.replaceWithSourceString(ret)
+    }
+  }
+  binding.scope.crawl()
+  binding = binding.scope.getBinding(name)
+  if (!binding.references) {
+    func.remove()
+  }
+}
+
+/**
+ * Template:
+ * ```javascript
+ * var arrayName = getArrayFn()
+ * function getArrayFn (){
+ *   return [...arrayExpression]
+ * }
+ * ```
+ */
+const deDuplicateLiteral = {
+  ArrayExpression(path) {
+    let obj = checkArrayName(path)
+    if (!obj) {
+      return
+    }
+    console.log(`Find arrayName: ${obj.array_name}`)
+    let decl_node = t.variableDeclarator(
+      obj.array_path.node.left,
+      obj.array_path.node.right
+    )
+    decl_node = t.variableDeclaration('var', [decl_node])
+    const code = [generator(obj.func_path.node).code, generator(decl_node).code]
+    let binding = obj.array_path.scope.getBinding(obj.array_name)
+    for (const ref of binding.referencePaths) {
+      const vm = isolate.createContextSync()
+      vm.evalSync(code[0])
+      vm.evalSync(code[1])
+      parseArrayWarp(vm, ref)
+    }
+    binding.scope.crawl()
+    binding = binding.scope.bindings[obj.array_name]
+    if (!binding.references) {
+      obj.array_path.remove()
+      binding.path.remove()
+    }
+    binding = obj.func_path.parentPath.scope.getBinding(obj.func_name)
+    binding.scope.crawl()
+    binding = binding.scope.getBinding(obj.func_name)
+    if (!binding.references) {
+      obj.func_path.remove()
+    }
+  },
+}
+
 function checkFuncLen(path) {
   if (path.node?.name !== 'configurable' || path.key !== 'key') {
     return null
@@ -222,6 +332,8 @@ module.exports = function (code) {
   traverse(ast, deAntiTooling)
   // Minify
   traverse(ast, deMinifyArrow)
+  // DuplicateLiteralsRemoval
+  traverse(ast, deDuplicateLiteral)
   // Stack
   traverse(ast, deStackFuncLen)
   code = generator(ast, {