fix(js): make it work to some extent

build-logic/src/main/kotlin/poke.base-conventions.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 group = "run.slicer"
-version = "1.0.0"
+version = "1.0.1"
 description = "A Java library for performing bytecode normalization and generic deobfuscation."
 
 repositories {

core/src/main/java/run/slicer/poke/AnalyzerImpl.java

@@ -16,6 +16,7 @@
 import proguard.preverify.SubroutineInliner;
 
 import java.io.*;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -79,6 +80,13 @@ private void optimize(AppView view) {
     }
 
     static final class Builder implements Analyzer.Builder {
+        private static final boolean PEEPHOLE = Boolean.parseBoolean(
+                System.getProperty("run.slicer.poke.peephole", "true")
+        );
+        private static final boolean EVALUATION = Boolean.parseBoolean(
+                System.getProperty("run.slicer.poke.evaluation", "true")
+        );
+
         private int passes = 1;
         private boolean verify = false;
         private boolean optimize = false;
@@ -116,7 +124,29 @@ public Analyzer build() {
             config.preverify = this.verify;
             config.keep = List.of();
             config.optimizationPasses = this.passes;
-            config.optimizations = List.of("method/propagation/*", "method/inlining/*", "code/*");
+
+            final List<String> optimizations = new ArrayList<>(List.of(
+                    "method/propagation/*",
+                    "method/inlining/*",
+                    "code/merging",
+                    "code/removal/*",
+                    "code/allocation/*"
+            ));
+
+            if (PEEPHOLE) {
+                optimizations.add("code/simplification/variable");
+                optimizations.add("code/simplification/arithmetic");
+                optimizations.add("code/simplification/cast");
+                optimizations.add("code/simplification/field");
+                optimizations.add("code/simplification/branch");
+                optimizations.add("code/simplification/object");
+                optimizations.add("code/simplification/string");
+                optimizations.add("code/simplification/math");
+            }
+            if (EVALUATION) {
+                optimizations.add("code/simplification/advanced");
+            }
+            config.optimizations = optimizations;
 
             return new AnalyzerImpl(config);
         }

js/poke.d.ts

@@ -5,5 +5,5 @@ declare module "@run-slicer/poke" {
         verify?: boolean;
     }
 
-    export function analyze(data: Uint8Array, config?: Config): Uint8Array;
+    export function analyze(data: Uint8Array, config?: Config): Promise<Uint8Array>;
 }

js/src/main/java/run/slicer/poke/js/Main.java

@@ -1,23 +1,43 @@
 package run.slicer.poke.js;
 
+import org.teavm.jso.JSBody;
 import org.teavm.jso.JSByRef;
 import org.teavm.jso.JSExport;
 import org.teavm.jso.core.JSObjects;
+import org.teavm.jso.core.JSPromise;
+import org.teavm.jso.typedarrays.Uint8Array;
 import run.slicer.poke.Analyzer;
 
 public class Main {
+    static {
+        // effectively disable parallel processing support
+        // the proper fix would be to stop proguard-core from casting threads to its own objects,
+        // but I really can't be bothered to stub that all out
+        System.setProperty("parallel.threads", "1");
+
+        // FIXME: InstructionSequencesReplacer breaks TeaVM
+        System.setProperty("run.slicer.poke.peephole", "false");
+    }
+
     @JSExport
-    public static @JSByRef byte[] analyze(@JSByRef byte[] data, Options options) {
+    public static JSPromise<Uint8Array> analyze(@JSByRef byte[] data, Options options) {
         return analyze0(data, options == null || JSObjects.isUndefined(options) ? JSObjects.create() : options);
     }
 
-    private static byte[] analyze0(byte[] data, Options options) {
-        final Analyzer analyzer = Analyzer.builder()
-                .passes(options.passes())
-                .optimize(options.optimize())
-                .verify(options.verify())
-                .build();
+    private static JSPromise<Uint8Array> analyze0(byte[] data, Options options) {
+        return new JSPromise<>((resolve, reject) -> {
+            new Thread(() -> {
+                final Analyzer analyzer = Analyzer.builder()
+                        .passes(options.passes())
+                        .optimize(options.optimize())
+                        .verify(options.verify())
+                        .build();
 
-        return analyzer.analyze(data);
+                resolve.accept(wrapByteArray(analyzer.analyze(data)));
+            }).start();
+        });
     }
+
+    @JSBody(params = {"data"}, script = "return data;")
+    private static native Uint8Array wrapByteArray(@JSByRef byte[] data);
 }

js/src/teavm/java/run/slicer/poke/js/teavm/classlib/java/util/concurrent/TThreadFactory.java

@@ -0,0 +1,4 @@
+package run.slicer.poke.js.teavm.classlib.java.util.concurrent;
+
+public interface TThreadFactory {
+}

js/src/teavm/resources/META-INF/teavm.properties

@@ -1,3 +1,4 @@
 mapClass|run.slicer.poke.js.teavm.classlib.java.util.concurrent.TExecutors=java.util.concurrent.Executors
 mapClass|run.slicer.poke.js.teavm.classlib.java.util.concurrent.TExecutorService=java.util.concurrent.ExecutorService
-mapClass|run.slicer.poke.js.teavm.classlib.java.util.concurrent.TFuture=java.util.concurrent.Future
+mapClass|run.slicer.poke.js.teavm.classlib.java.util.concurrent.TFuture=java.util.concurrent.Future
+mapClass|run.slicer.poke.js.teavm.classlib.java.util.concurrent.TThreadFactory=java.util.concurrent.ThreadFactory