Remove unused classes + Fix mapping + Further abstract transformers

Author: cvs0

README.md

@@ -1273,6 +1273,19 @@ ObfuscationConfig config = new ObfuscationConfig.Builder()
    - Renames methods and updates method invocations
    - Skips constructors and static initializers
 
+4. **AntiDebuggingTransformer** (Priority: 100)
+   - Adds anti-debugging checks and responses
+   - Configurable actions on debugger detection
+   - Adds VM checks to prevent debugging
+
+5. **ConditionObfuscationTransformer** (Priority: 250)
+   - Transforms boolean constants into complex expressions
+   - Ensures stackmap safety
+
+6. **StringCompressionTransformer** (Priority: 350)
+    - Compresses string literals using Deflate and Base64
+    - Decompresses strings at runtime
+
 ### Validation System
 
 - **Input Validation** - Validates JAR files, output paths, and file permissions
@@ -1335,22 +1348,6 @@ ObfuscationConfig config = ConfigPresets.createDebugObfuscation()
     .build();
 ```
 
-## Contributing
-
-### Adding New Transformers
-
-1. Extend `AbstractTransformer`
-2. Implement required methods
-3. Set appropriate priority
-4. Register with `ObfuscationEngine`
-
-### Configuration Extensions
-
-1. Add new properties to `ObfuscationConfig`
-2. Update `Builder` class
-3. Add validation in `ConfigValidator`
-4. Create preset if needed
-
 ## License
 
 This project is licensed under the MIT License - see the LICENSE file for details.

src/main/java/net/cvs0/config/ConfigPresets.java

@@ -0,0 +1,115 @@
+package net.cvs0.core;
+
+import net.cvs0.context.ObfuscationContext;
+import net.cvs0.utils.BytecodeUtils;
+import org.objectweb.asm.ClassVisitor;
+import org.objectweb.asm.FieldVisitor;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+
+public abstract class BaseClassVisitor extends ClassVisitor implements ContextProvider
+{
+    protected final ObfuscationContext context;
+    protected String currentClassName;
+
+    protected BaseClassVisitor(ClassVisitor classVisitor, ObfuscationContext context)
+    {
+        super(Opcodes.ASM9, classVisitor);
+        this.context = context;
+    }
+
+    @Override
+    public final ObfuscationContext getContext()
+    {
+        return context;
+    }
+
+    @Override
+    public final String getCurrentClassName()
+    {
+        return currentClassName;
+    }
+
+    @Override
+    public void visit(int version, int access, String name, String signature, String superName, String[] interfaces)
+    {
+        this.currentClassName = name;
+        super.visit(version, access, name, signature, superName, interfaces);
+    }
+
+    @Override
+    public MethodVisitor visitMethod(int access, String name, String descriptor, String signature, String[] exceptions)
+    {
+        MethodVisitor mv = super.visitMethod(access, name, descriptor, signature, exceptions);
+        
+        if (!shouldProcessMethod(name, access, descriptor)) {
+            return mv;
+        }
+        
+        return createMethodVisitor(mv, access, name, descriptor, signature, exceptions);
+    }
+
+    @Override
+    public FieldVisitor visitField(int access, String name, String descriptor, String signature, Object value)
+    {
+        if (!shouldProcessField(name, access, descriptor)) {
+            return super.visitField(access, name, descriptor, signature, value);
+        }
+        
+        return createFieldVisitor(super.visitField(access, name, descriptor, signature, value), 
+                                access, name, descriptor, signature, value);
+    }
+
+    protected boolean shouldProcessMethod(String name, int access, String descriptor)
+    {
+        if (BytecodeUtils.isMethodSkippable(name, access)) {
+            return false;
+        }
+        
+        if (!context.getConfig().isInPackageScope(currentClassName)) {
+            return false;
+        }
+        
+        return !context.getConfig().shouldKeepMethod(currentClassName, name, descriptor);
+    }
+
+    protected boolean shouldProcessField(String name, int access, String descriptor)
+    {
+        if (BytecodeUtils.isFieldSkippable(name, access)) {
+            return false;
+        }
+        
+        if (!context.getConfig().isInPackageScope(currentClassName)) {
+            return false;
+        }
+        
+        return !context.getConfig().shouldKeepField(currentClassName, name);
+    }
+
+    protected boolean shouldProcessClass()
+    {
+        return context.getConfig().isInPackageScope(currentClassName) &&
+               !context.getConfig().shouldKeepClass(currentClassName);
+    }
+
+    protected void logTransformation(String message)
+    {
+        if (context.getConfig().isVerbose()) {
+            System.out.println("[" + getTransformerName() + "] " + message + " in " + currentClassName);
+        }
+    }
+
+    protected abstract String getTransformerName();
+
+    protected MethodVisitor createMethodVisitor(MethodVisitor mv, int access, String name, 
+                                              String descriptor, String signature, String[] exceptions)
+    {
+        return mv;
+    }
+
+    protected FieldVisitor createFieldVisitor(FieldVisitor fv, int access, String name, 
+                                            String descriptor, String signature, Object value)
+    {
+        return fv;
+    }
+}