Merge pull request #10 from TopchetoEU/TopchetoEU/mapping

Add support for source mappings
feat: make environment hidable from stack trace
2023-12-18 22:42:38 +02:00 · 2023-12-18 22:38:26 +02:00 · 2023-12-18 22:30:14 +02:00 · 2023-12-18 22:11:08 +02:00 · 2023-12-14 21:07:16 +02:00 · 2023-12-14 21:06:23 +02:00
172 changed files with 8987 additions and 4815 deletions
--- a/.github/workflows/tagged-release.yml
+++ b/.github/workflows/tagged-release.yml
@@ -11,6 +11,11 @@ jobs:
    runs-on: "ubuntu-latest"

    steps:
+      - name: Setup Java
+        uses: actions/setup-java@v3
+        with:
+          distribution: 'adopt'
+          java-version: '11'
      - name: Clone repository
        uses: GuillaumeFalourd/clone-github-repo-action@main
        with:
--- a/README.md
+++ b/README.md
@@ -4,31 +4,42 @@

 **WARNING: Currently, this code is mostly undocumented. Proceed with caution and a psychiatrist.**

-JScript is an engine, capable of running EcmaScript 5, written entirely in Java. This engine has been developed with the goal of being easy to integrate with your preexisting codebase, **THE GOAL OF THIS ENGINE IS NOT PERFORMANCE**. My crude experiments show that this engine is 50x-100x slower than V8, which, although bad, is acceptable for most simple scripting purposes.
+JScript is an engine, capable of running EcmaScript 5, written entirely in Java. This engine has been developed with the goal of being easy to integrate with your preexisting codebase, **THE GOAL OF THIS ENGINE IS NOT PERFORMANCE**. My crude experiments show that this engine is 50x-100x slower than V8, which, although bad, is acceptable for most simple scripting purposes. Note that although the codebase has a Main class, this isn't meant to be a standalone program, but instead a library for running JavaScript code.

 ## Example

 The following will create a REPL using the engine as a backend. Not that this won't properly log errors. I recommend checking out the implementation in `Main.main`:

 ```java
-var engine = new PolyfillEngine(new File("."));
-var in = new BufferedReader(new InputStreamReader(System.in));
+var engine = new Engine(true /* false if you dont want debugging */);
+var env = new Environment(null, null, null);
+var debugger = new DebugServer();
+
+// Create one target for the engine and start debugging server
+debugger.targets.put("target", (socket, req) -> new SimpleDebugger(socket, engine));
+debugger.start(new InetSocketAddress("127.0.0.1", 9229), true);
+
+// Queue code to load internal libraries and start engine
+engine.pushMsg(false, null, new Internals().getApplier(env));
 engine.start();

 while (true) {
    try {
-        var raw = in.readLine();
+        var raw = Reading.read();
+        if (raw == null) break;

-        var res = engine.pushMsg(false, engine.global(), Map.of(), "<stdio>", raw, null).await();
-        Values.printValue(engine.context(), res);
-        System.out.println();
+        // Push a message to the engine with the raw REPL code
+        var res = engine.pushMsg(
+            false, new Context(engine).pushEnv(env),
+            new Filename("jscript", "repl.js"), raw, null
+        ).await();
+
+        Values.printValue(null, res);
    }
-    catch (EngineException e) {
-        try {
-            System.out.println("Uncaught " + e.toString(engine.context()));
-        }
-        catch (InterruptedException _e) {  return; }
+    catch (EngineException e) { Values.printError(e, ""); }
+    catch (SyntaxException ex) {
+        System.out.println("Syntax error:" + ex.msg);
    }
-    catch (IOException | InterruptedException e) { return; }
+    catch (IOException e) { }
 }
 ```
--- a/build.js
+++ b/build.js
@@ -1,7 +1,7 @@
 const { spawn } = require('child_process');
 const fs = require('fs/promises');
 const pt = require('path');
-const { argv } = require('process');
+const { argv, exit } = require('process');

 const conf = {
    name: "java-jscript",
@@ -74,6 +74,7 @@ async function compileJava() {
    }
    catch (e) {
        if (argv[2] === 'debug') throw e;
-        else console.log(e.toString());
+        console.log(e.toString());
+        exit(-1);
    }
 })();
--- a/src/assets/debugger/favicon.png
+++ b/src/assets/debugger/favicon.png
--- a/src/assets/debugger/index.html
+++ b/src/assets/debugger/index.html
@@ -0,0 +1,30 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>JScript Debugger</title>
+</head>
+<body>
+    <p>
+        This is the debugger of JScript. It implement the <a href="https://chromedevtools.github.io/devtools-protocol/1-2/">V8 Debugging protocol</a>,
+        so you can use the devtools in chrome. <br>
+        The debugger is still in early development, so please report any issues to
+        <a href="https://github.com/TopchetoEU/java-jscript/issues">the github repo</a>.
+    </p>
+
+    <p>
+        Here are the available entrypoints:
+        <ul>
+            <li><a href="json/version">/json/version</a> - version and other stuff about the JScript engine</li>
+            <li><a href="json/list">/json/list</a> - a list of all entrypoints</li>
+            <li><a href="json/protocol">/json/protocol</a> - documentation of the implemented V8 protocol</li>
+            <li>/(any target) - websocket entrypoints for debugging</li>
+        </ul>
+    </p>
+
+    <p>
+        Running ${NAME} v${VERSION} by ${AUTHOR}
+    </p>
+</body>
+</html>
--- a/src/assets/debugger/protocol.json
+++ b/src/assets/debugger/protocol.json
--- a/src/assets/js/bootstrap.js
+++ b/src/assets/js/bootstrap.js
@@ -0,0 +1,113 @@
+(function (ts, env, libs) {
+    var src = '', version = 0;
+    var lib = libs.concat([
+        'declare function exit(): never;',
+        'declare function go(): any;',
+        'declare function getTsDeclarations(): string[];'
+    ]).join('');
+    var libSnapshot = ts.ScriptSnapshot.fromString(lib);
+    var environments = {};
+    var declSnapshots = [];
+
+    var settings = {
+        outDir: "/out",
+        declarationDir: "/out",
+        target: ts.ScriptTarget.ES5,
+        lib: [ ],
+        module: ts.ModuleKind.None,
+        declaration: true,
+        stripInternal: true,
+        downlevelIteration: true,
+        forceConsistentCasingInFileNames: true,
+        experimentalDecorators: true,
+        strict: true,
+        sourceMap: true,
+    };
+
+    var reg = ts.createDocumentRegistry();
+    var service = ts.createLanguageService({
+        getCurrentDirectory: function() { return "/"; },
+        getDefaultLibFileName: function() { return "/lib.d.ts"; },
+        getScriptFileNames: function() {
+            var res = [ "/src.ts", "/lib.d.ts" ];
+            for (var i = 0; i < declSnapshots.length; i++) res.push("/glob." + (i + 1) + ".d.ts");
+            return res;
+        },
+        getCompilationSettings: function () { return settings; },
+        fileExists: function(filename) { return filename === "/lib.d.ts" || filename === "/src.ts" || filename === "/glob.d.ts"; },
+
+        getScriptSnapshot: function(filename) {
+            if (filename === "/lib.d.ts") return libSnapshot;
+            if (filename === "/src.ts") return ts.ScriptSnapshot.fromString(src);
+
+            var index = /\/glob\.(\d+)\.d\.ts/g.exec(filename);
+            if (index && index[1] && (index = Number(index[1])) && index > 0 && index <= declSnapshots.length) {
+                return declSnapshots[index - 1];
+            }
+
+            throw new Error("File '" + filename + "' doesn't exist.");
+        },
+        getScriptVersion: function (filename) {
+            if (filename === "/lib.d.ts" || filename.startsWith("/glob.")) return 0;
+            else return version;
+        },
+    }, reg);
+
+    service.getEmitOutput("/lib.d.ts");
+    log("Loaded libraries!");
+
+    var oldCompile = env.compile;
+
+    function compile(code, filename, env) {
+        src = code;
+        version++;
+
+        if (!environments[env.id]) environments[env.id] = []
+        declSnapshots = environments[env.id];
+        var emit = service.getEmitOutput("/src.ts");
+
+        var diagnostics = []
+            .concat(service.getCompilerOptionsDiagnostics())
+            .concat(service.getSyntacticDiagnostics("/src.ts"))
+            .concat(service.getSemanticDiagnostics("/src.ts"))
+            .map(function (diagnostic) {
+                var message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                if (diagnostic.file) {
+                    var pos = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+                    var file = diagnostic.file.fileName.substring(1);
+                    if (file === "src.ts") file = filename;
+                    return file + ":" + (pos.line + 1) + ":" + (pos.character + 1) + ": " + message;
+                }
+                else return message;
+            });
+
+        if (diagnostics.length > 0) {
+            throw new SyntaxError(diagnostics.join("\n"));
+        }
+
+        var map = JSON.parse(emit.outputFiles[0].text);
+        var result = emit.outputFiles[1].text;
+        var declaration = emit.outputFiles[2].text;
+
+        var compiled = oldCompile(result, filename, env);
+
+        return {
+            function: function () {
+                var val = compiled.function.apply(this, arguments);
+                if (declaration !== '') declSnapshots.push(ts.ScriptSnapshot.fromString(declaration));
+                return val;
+            },
+            breakpoints: compiled.breakpoints,
+            mapChain: compiled.mapChain.concat(map.mappings),
+        };
+    }
+
+    function apply(env) {
+        env.compile = compile;
+        env.global.getTsDeclarations = function() {
+            return environments[env.id];
+        }
+    }
+
+    apply(env);
+})(arguments[0], arguments[1], arguments[2]);
--- a/src/me/topchetoeu/jscript/js/lib.d.ts
+++ b/src/me/topchetoeu/jscript/js/lib.d.ts
--- a/src/assets/js/ts.js
+++ b/src/assets/js/ts.js
--- a/src/me/topchetoeu/jscript/Buffer.java
+++ b/src/me/topchetoeu/jscript/Buffer.java
@@ -0,0 +1,53 @@
+package me.topchetoeu.jscript;
+
+public class Buffer {
+    private byte[] data;
+    private int length;
+
+    public void write(int i, byte[] val) {
+        if (i + val.length > data.length) {
+            var newCap = i + val.length + 1;
+            if (newCap < data.length * 2) newCap = data.length * 2;
+
+            var tmp = new byte[newCap];
+            System.arraycopy(this.data, 0, tmp, 0, length);
+            this.data = tmp;
+        }
+
+        System.arraycopy(val, 0, data, i, val.length);
+        if (i + val.length > length) length = i + val.length;
+    }
+    public int read(int i, byte[] buff) {
+        int n = buff.length;
+        if (i + n > length) n = length - i;
+        System.arraycopy(data, i, buff, 0, n);
+        return n;
+    }
+
+    public void append(byte b) {
+        write(length, new byte[] { b });
+    }
+
+    public byte[] data() {
+        var res = new byte[length];
+        System.arraycopy(this.data, 0, res, 0, length);
+        return res;
+    }
+    public int length() {
+        return length;
+    }
+
+    public Buffer(byte[] data) {
+        this.data = new byte[data.length];
+        this.length = data.length;
+        System.arraycopy(data, 0, this.data, 0, data.length);
+    }
+    public Buffer(int capacity) {
+        this.data = new byte[capacity];
+        this.length = 0;
+    }
+    public Buffer() {
+        this.data = new byte[128];
+        this.length = 0;
+    }
+}
--- a/src/me/topchetoeu/jscript/Filename.java
+++ b/src/me/topchetoeu/jscript/Filename.java
@@ -0,0 +1,60 @@
+package me.topchetoeu.jscript;
+
+import java.io.File;
+
+public class Filename {
+    public final String protocol;
+    public final String path;
+
+    public String toString() {
+        return protocol + "://" + path;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + protocol.hashCode();
+        result = prime * result + path.hashCode();
+        return result;
+    }
+
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj) return true;
+        if (obj == null) return false;
+        if (getClass() != obj.getClass()) return false;
+
+        var other = (Filename) obj;
+
+        if (protocol == null) {
+            if (other.protocol != null) return false;
+        }
+        else if (!protocol.equals(other.protocol)) return false;
+
+        if (path == null) {
+            if (other.path != null) return false;
+        }
+        else if (!path.equals(other.path)) return false;
+        return true;
+    }
+
+    public static Filename fromFile(File file) {
+        return new Filename("file", file.getAbsolutePath());
+    }
+
+
+    public Filename(String protocol, String path) {
+        path = path.trim();
+        protocol = protocol.trim();
+        this.protocol = protocol;
+        this.path = path;
+    }
+
+    public static Filename parse(String val) {
+        var i = val.indexOf("://");
+        if (i >= 0) return new Filename(val.substring(0, i).trim(), val.substring(i + 3).trim());
+        else return new Filename("file", val.trim());
+    }
+}
--- a/src/me/topchetoeu/jscript/Location.java
+++ b/src/me/topchetoeu/jscript/Location.java
@@ -1,18 +1,18 @@
 package me.topchetoeu.jscript;

-public class Location {
-    public static final Location INTERNAL = new Location(0, 0, "<internal>");
+public class Location implements Comparable<Location> {
+    public static final Location INTERNAL = new Location(0, 0, new Filename("jscript", "native"));
    private int line;
    private int start;
-    private String filename;
+    private Filename filename;

    public int line() { return line; }
    public int start() { return start; }
-    public String filename() { return filename; }
+    public Filename filename() { return filename; }

    @Override
    public String toString() {
-        return filename + ":" + line + ":" + start;
+        return filename.toString() + ":" + line + ":" + start;
    }

    public Location add(int n, boolean clone) {
@@ -55,9 +55,39 @@ public class Location {
        return true;
    }

-    public Location(int line, int start, String filename) {
+    @Override
+    public int compareTo(Location other) {
+        int a = filename.toString().compareTo(other.filename.toString());
+        int b = Integer.compare(line, other.line);
+        int c = Integer.compare(start, other.start);
+
+        if (a != 0) return a;
+        if (b != 0) return b;
+        return c;
+    }
+
+    public Location(int line, int start, Filename filename) {
        this.line = line;
        this.start = start;
        this.filename = filename;
    }
+
+    public static Location parse(String raw) {
+        int i0 = -1, i1 = -1;
+        for (var i = raw.length() - 1; i >= 0; i--) {
+            if (raw.charAt(i) == ':') {
+                if (i1 == -1) i1 = i;
+                else if (i0 == -1) {
+                    i0 = i;
+                    break;
+                }
+            }
+        }
+
+        return new Location(
+            Integer.parseInt(raw.substring(i0 + 1, i1)),
+            Integer.parseInt(raw.substring(i1 + 1)),
+            Filename.parse(raw.substring(0, i0))
+        );
+    }
 }
--- a/src/me/topchetoeu/jscript/Main.java
+++ b/src/me/topchetoeu/jscript/Main.java
@@ -1,127 +1,168 @@
 package me.topchetoeu.jscript;

-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
+import java.net.InetSocketAddress;
 import java.nio.file.Files;
 import java.nio.file.Path;

-import me.topchetoeu.jscript.engine.Message;
+import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.Engine;
 import me.topchetoeu.jscript.engine.Environment;
+import me.topchetoeu.jscript.engine.debug.DebugServer;
+import me.topchetoeu.jscript.engine.debug.SimpleDebugger;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
 import me.topchetoeu.jscript.engine.values.NativeFunction;
+import me.topchetoeu.jscript.engine.values.ObjectValue;
 import me.topchetoeu.jscript.engine.values.Values;
 import me.topchetoeu.jscript.events.Observer;
 import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.exceptions.InterruptException;
 import me.topchetoeu.jscript.exceptions.SyntaxException;
-import me.topchetoeu.jscript.polyfills.Internals;
+import me.topchetoeu.jscript.filesystem.MemoryFilesystem;
+import me.topchetoeu.jscript.filesystem.Mode;
+import me.topchetoeu.jscript.filesystem.PhysicalFilesystem;
+import me.topchetoeu.jscript.lib.Internals;

-public class Main {
-    static Thread task;
-    static Engine engine;
-    static Environment env;
-
-    public static String streamToString(InputStream in) {
-        try {
-            StringBuilder out = new StringBuilder();
-            BufferedReader br = new BufferedReader(new InputStreamReader(in));
-
-            for(var line = br.readLine(); line != null; line = br.readLine()) {
-                out.append(line).append('\n');
-            }
-
-            br.close();
-            return out.toString();
-        }
-        catch (IOException e) {
-            return null;
-        }
-    }
-    public static String resourceToString(String name) {
-        var str = Main.class.getResourceAsStream("/me/topchetoeu/jscript/" + name);
-        if (str == null) return null;
-        return streamToString(str);
-    }
-
-    private static Observer<Object> valuePrinter = new Observer<Object>() {
+public class Main {   
+    public static class Printer implements Observer<Object> {
        public void next(Object data) {
-            try { Values.printValue(null, data); }
-            catch (InterruptedException e) { }
+            Values.printValue(null, data);
            System.out.println();
        }

        public void error(RuntimeException err) {
-            try { Values.printError(err, null); }
-            catch (InterruptedException ex) { return; }
+            Values.printError(err, null);
        }
-    };

-    public static void main(String args[]) {
-        System.out.println(String.format("Running %s v%s by %s", Metadata.NAME, Metadata.VERSION, Metadata.AUTHOR));
-        var in = new BufferedReader(new InputStreamReader(System.in));
-        engine = new Engine();
+        public void finish() {
+            engineTask.interrupt();
+        }
+    }

-        env = new Environment(null, null, null);
-        var exited = new boolean[1];
+    static Thread engineTask, debugTask;
+    static Engine engine = new Engine(true);
+    static DebugServer debugServer = new DebugServer();
+    static Environment environment = new Environment(null, null, null);

-        engine.pushMsg(false, new Message(engine), new NativeFunction((ctx, thisArg, _a) -> {
-            new Internals().apply(env);
+    static int j = 0;
+    static boolean exited = false;
+    static String[] args;

-            env.global.define("exit", _ctx -> {
-                exited[0] = true;
-                task.interrupt();
-                throw new InterruptedException();
-            });
-            env.global.define("go", _ctx -> {
+    private static void reader() {
+        try {
+            for (var arg : args) {
                try {
-                    var func = _ctx.compile("do.js", new String(Files.readAllBytes(Path.of("do.js"))));
-                    return func.call(_ctx);
-                }
-                catch (IOException e) {
-                    throw new EngineException("Couldn't open do.js");
-                }
-            });
-
-            return null;
-        }), null);
-
-        task = engine.start();
-        var reader = new Thread(() -> {
-            try {
-                while (true) {
-                    try {
-                        var raw = in.readLine();
-
-                        if (raw == null) break;
-                        engine.pushMsg(false, env.context(new Message(engine)), "<stdio>", raw, null).toObservable().once(valuePrinter);
-                    }
-                    catch (EngineException e) {
-                        try {
-                            System.out.println("Uncaught " + e.toString(null));
-                        }
-                        catch (EngineException ex) {
-                            System.out.println("Uncaught [error while converting to string]");
-                        }
+                    if (arg.equals("--ts")) initTypescript();
+                    else {
+                        var file = Path.of(arg);
+                        var raw = Files.readString(file);
+                        var res = engine.pushMsg(
+                            false, new Context(engine, environment),
+                            Filename.fromFile(file.toFile()),
+                            raw, null
+                        ).await();
+                        Values.printValue(null, res);
+                        System.out.println();
                    }
                }
+                catch (EngineException e) { Values.printError(e, null); }
            }
-            catch (IOException e) {
-                e.printStackTrace();
-                return;
+            for (var i = 0; ; i++) {
+                try {
+                    var raw = Reading.read();
+
+                    if (raw == null) break;
+                    var res = engine.pushMsg(
+                        false, new Context(engine, environment),
+                        new Filename("jscript", "repl/" + i + ".js"),
+                        raw, null
+                    ).await();
+                    Values.printValue(null, res);
+                    System.out.println();
+                }
+                catch (EngineException e) { Values.printError(e, null); }
+                catch (SyntaxException e) { Values.printError(e, null); }
            }
-            catch (SyntaxException ex) {
-                if (exited[0]) return;
-                System.out.println("Syntax error:" + ex.msg);
-            }
-            catch (RuntimeException ex) {
-                if (exited[0]) return;
+        }
+        catch (IOException e) {
+            System.out.println(e.toString());
+            exited = true;
+        }
+        catch (RuntimeException ex) {
+            if (!exited) {
                System.out.println("Internal error ocurred:");
                ex.printStackTrace();
            }
-            catch (InterruptedException e) { return; }
-            if (exited[0]) return;
-        });
+        }
+        if (exited) {
+            debugTask.interrupt();
+            engineTask.interrupt();
+        }
+    }
+
+    private static void initEnv() {
+        environment = Internals.apply(environment);
+
+        environment.global.define(false, new NativeFunction("exit", (_ctx, th, args) -> {
+            exited = true;
+            throw new InterruptException();
+        }));
+        environment.global.define(false, new NativeFunction("go", (_ctx, th, args) -> {
+            try {
+                var f = Path.of("do.js");
+                var func = _ctx.compile(new Filename("do", "do/" + j++ + ".js"), new String(Files.readAllBytes(f)));
+                return func.call(_ctx);
+            }
+            catch (IOException e) {
+                throw new EngineException("Couldn't open do.js");
+            }
+        }));
+
+        environment.filesystem.protocols.put("temp", new MemoryFilesystem(Mode.READ_WRITE));
+        environment.filesystem.protocols.put("file", new PhysicalFilesystem(Path.of(".").toAbsolutePath()));
+    }
+    private static void initEngine() {
+        debugServer.targets.put("target", (ws, req) -> new SimpleDebugger(ws, engine));
+        engineTask = engine.start();
+        debugTask = debugServer.start(new InetSocketAddress("127.0.0.1", 9229), true);
+    }
+    private static void initTypescript() {
+        try {
+            var tsEnv = Internals.apply(new Environment(null, null, null));
+            tsEnv.stackVisible = false;
+            tsEnv.global.define(null, "module", false, new ObjectValue());
+            var bsEnv = Internals.apply(new Environment(null, null, null));
+            bsEnv.stackVisible = false;
+
+            engine.pushMsg(
+                false, new Context(engine, tsEnv),
+                new Filename("jscript", "ts.js"),
+                Reading.resourceToString("js/ts.js"), null
+            ).await();
+            System.out.println("Loaded typescript!");
+
+            var ctx = new Context(engine, bsEnv);
+
+            engine.pushMsg(
+                false, ctx,
+                new Filename("jscript", "bootstrap.js"), Reading.resourceToString("js/bootstrap.js"), null,
+                tsEnv.global.get(ctx, "ts"), environment, new ArrayValue(null, Reading.resourceToString("js/lib.d.ts"))
+            ).await();
+        }
+        catch (EngineException e) {
+            Values.printError(e, "(while initializing TS)");
+        }
+    }
+
+    public static void main(String args[]) {
+        System.out.println(String.format("Running %s v%s by %s", Metadata.name(), Metadata.version(), Metadata.author()));
+
+        Main.args = args;
+        var reader = new Thread(Main::reader);
+
+        initEnv();
+        initEngine();
+
        reader.setDaemon(true);
        reader.setName("STD Reader");
        reader.start();
--- a/src/me/topchetoeu/jscript/Metadata.java
+++ b/src/me/topchetoeu/jscript/Metadata.java
@@ -1,7 +1,20 @@
 package me.topchetoeu.jscript;

 public class Metadata {
-    public static final String VERSION = "${VERSION}";
-    public static final String AUTHOR = "${AUTHOR}";
-    public static final String NAME = "${NAME}";
+    private static final String VERSION = "${VERSION}";
+    private static final String AUTHOR = "${AUTHOR}";
+    private static final String NAME = "${NAME}";
+
+    public static String version() {
+        if (VERSION.equals("$" + "{VERSION}")) return "1337-devel";
+        else return VERSION;
+    }
+    public static String author() {
+        if (AUTHOR.equals("$" + "{AUTHOR}")) return "anonymous";
+        else return AUTHOR;
+    }
+    public static String name() {
+        if (NAME.equals("$" + "{NAME}")) return "some-product";
+        else return NAME;
+    }
 }
--- a/src/me/topchetoeu/jscript/Reading.java
+++ b/src/me/topchetoeu/jscript/Reading.java
@@ -0,0 +1,27 @@
+package me.topchetoeu.jscript;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import me.topchetoeu.jscript.exceptions.UncheckedException;
+
+public class Reading {
+    private static final BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
+
+    public static synchronized String read() throws IOException {
+        return reader.readLine();
+    }
+
+    public static String streamToString(InputStream in) {
+        try { return new String(in.readAllBytes()); }
+        catch (Throwable e) { throw new UncheckedException(e); }
+    }
+    public static InputStream resourceToStream(String name) {
+        return Reading.class.getResourceAsStream("/assets/" + name);
+    }
+    public static String resourceToString(String name) {
+        return streamToString(resourceToStream(name));
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/AssignStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/AssignStatement.java
@@ -1,19 +0,0 @@
-package me.topchetoeu.jscript.compilation;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public abstract class AssignStatement extends Statement {
-    public abstract void compile(List<Instruction> target, ScopeRecord scope, boolean retPrevValue);
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        compile(target, scope, false);
-    }
-
-    protected AssignStatement(Location loc) {
-        super(loc);
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/AssignableStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/AssignableStatement.java
@@ -4,7 +4,7 @@ import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.engine.Operation;

 public abstract class AssignableStatement extends Statement {
-    public abstract AssignStatement toAssign(Statement val, Operation operation);
+    public abstract Statement toAssign(Statement val, Operation operation);

    protected AssignableStatement(Location loc) {
        super(loc);
--- a/src/me/topchetoeu/jscript/compilation/CalculateResult.java
+++ b/src/me/topchetoeu/jscript/compilation/CalculateResult.java
@@ -0,0 +1,21 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.engine.values.Values;
+
+public final class CalculateResult {
+    public final boolean exists;
+    public final Object value;
+
+    public final boolean isTruthy() {
+        return exists && Values.toBoolean(value);
+    }
+
+    public CalculateResult(Object value) {
+        this.exists = true;
+        this.value = value;
+    }
+    public CalculateResult() {
+        this.exists = false;
+        this.value = null;
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/CompileOptions.java
+++ b/src/me/topchetoeu/jscript/compilation/CompileOptions.java
@@ -1,11 +0,0 @@
-package me.topchetoeu.jscript.compilation;
-
-public class CompileOptions {
-    public final boolean emitBpMap;
-    public final boolean emitVarNames;
-
-    public CompileOptions(boolean emitBpMap, boolean emitVarNames) {
-        this.emitBpMap = emitBpMap;
-        this.emitVarNames = emitVarNames;
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/CompileTarget.java
+++ b/src/me/topchetoeu/jscript/compilation/CompileTarget.java
@@ -0,0 +1,66 @@
+package me.topchetoeu.jscript.compilation;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.Vector;
+
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
+import me.topchetoeu.jscript.engine.Environment;
+import me.topchetoeu.jscript.engine.values.CodeFunction;
+
+public class CompileTarget {
+    public final Vector<Instruction> target = new Vector<>();
+    public final Map<Long, FunctionBody> functions;
+    public final TreeSet<Location> breakpoints;
+    private final HashMap<Location, Instruction> bpToInstr = new HashMap<>();
+
+    public Instruction add(Instruction instr) {
+        target.add(instr);
+        return instr;
+    }
+    public Instruction set(int i, Instruction instr) {
+        return target.set(i, instr);
+    }
+    public void setDebug(int i, BreakpointType type) {
+        var instr = target.get(i);
+        instr.breakpoint = type;
+
+        if (type == BreakpointType.NONE) {
+            breakpoints.remove(target.get(i).location);
+            bpToInstr.remove(instr.location, instr);
+        }
+        else {
+            breakpoints.add(target.get(i).location);
+
+            var old = bpToInstr.put(instr.location, instr);
+            if (old != null) old.breakpoint = BreakpointType.NONE;
+        }
+    }
+    public void setDebug(BreakpointType type) {
+        setDebug(target.size() - 1, type);
+    }
+    public Instruction get(int i) {
+        return target.get(i);
+    }
+    public int size() { return target.size(); }
+    public Location lastLoc(Location fallback) {
+        if (target.size() == 0) return fallback;
+        else return target.get(target.size() - 1).location;
+    }
+
+    public Instruction[] array() { return target.toArray(Instruction[]::new); }
+
+    public FunctionBody body() {
+        return functions.get(0l);
+    }
+    public CodeFunction func(Environment env) {
+        return new CodeFunction(env, "", body());
+    }
+
+    public CompileTarget(Map<Long, FunctionBody> functions, TreeSet<Location> breakpoints) {
+        this.functions = functions;
+        this.breakpoints = breakpoints;
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/CompoundStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/CompoundStatement.java
@@ -1,77 +1,64 @@
 package me.topchetoeu.jscript.compilation;

-import java.util.ArrayList;
 import java.util.List;
+import java.util.Vector;

 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.control.ContinueStatement;
-import me.topchetoeu.jscript.compilation.control.ReturnStatement;
-import me.topchetoeu.jscript.compilation.control.ThrowStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.values.FunctionStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public class CompoundStatement extends Statement {
    public final Statement[] statements;
+    public final boolean separateFuncs;
+    public Location end;

-    @Override
-    public boolean pollutesStack() {
+    @Override public boolean pure() {
        for (var stm : statements) {
-            if (stm instanceof FunctionStatement) continue;
-            return true;
+            if (!stm.pure()) return false;
        }

-        return false;
+        return true;
    }

    @Override
    public void declare(ScopeRecord varsScope) {
-        for (var stm : statements) {
-            stm.declare(varsScope);
-        }
+        for (var stm : statements) stm.declare(varsScope);
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        for (var stm : statements) {
-            if (stm instanceof FunctionStatement) {
-                int start = target.size();
-                ((FunctionStatement)stm).compile(target, scope, null, true);
-                target.get(start).setDebug(true);
-                target.add(Instruction.discard());
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
+        List<Statement> statements = new Vector<Statement>();
+        if (separateFuncs) for (var stm : this.statements) {
+            if (stm instanceof FunctionStatement && ((FunctionStatement)stm).statement) {
+                stm.compile(target, scope, false);
            }
+            else statements.add(stm);
+        }
+        else statements = List.of(this.statements);
+
+        var polluted = false;
+
+        for (var i = 0; i < statements.size(); i++) {
+            var stm = statements.get(i);
+
+            if (i != statements.size() - 1) stm.compile(target, scope, false, BreakpointType.STEP_OVER);
+            else stm.compile(target, scope, polluted = pollute, BreakpointType.STEP_OVER);
        }

-        for (var i = 0; i < statements.length; i++) {
-            var stm = statements[i];
-            
-            if (stm instanceof FunctionStatement) continue;
-            if (i != statements.length - 1) stm.compileNoPollution(target, scope, true);
-            else stm.compileWithPollution(target, scope);
+        if (!polluted && pollute) {
+            target.add(Instruction.loadValue(loc(), null));
        }
    }

-    @Override
-    public Statement optimize() {
-        var res = new ArrayList<Statement>();
-
-        for (var i = 0; i < statements.length; i++) {
-            var stm = statements[i].optimize();
-            if (i < statements.length - 1 && stm.pure()) continue;
-            res.add(stm);
-            if (
-                stm instanceof ContinueStatement ||
-                stm instanceof ReturnStatement ||
-                stm instanceof ThrowStatement ||
-                stm instanceof ContinueStatement
-            ) break;
-        }
-
-        if (res.size() == 1) return res.get(0);
-        else return new CompoundStatement(loc(), res.toArray(Statement[]::new));
+    public CompoundStatement setEnd(Location loc) {
+        this.end = loc;
+        return this;
    }

-    public CompoundStatement(Location loc, Statement ...statements) {
+    public CompoundStatement(Location loc, boolean separateFuncs, Statement ...statements) {
        super(loc);
+        this.separateFuncs = separateFuncs;
        this.statements = statements;
    }
 }
--- a/src/me/topchetoeu/jscript/compilation/DiscardStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/DiscardStatement.java
@@ -1,33 +0,0 @@
-package me.topchetoeu.jscript.compilation;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public class DiscardStatement extends Statement {
-    public final Statement value;
-
-    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (value == null) return;
-        value.compile(target, scope);
-        if (value.pollutesStack()) target.add(Instruction.discard());
-    }
-    @Override
-    public Statement optimize() {
-        if (value == null) return this;
-        var val = value.optimize();
-        if (val.pure()) return new ConstantStatement(loc(), null);
-        else return new DiscardStatement(loc(), val);
-    }
-
-    public DiscardStatement(Location loc, Statement val) {
-        super(loc);
-        this.value = val;
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/FunctionBody.java
+++ b/src/me/topchetoeu/jscript/compilation/FunctionBody.java
@@ -0,0 +1,29 @@
+package me.topchetoeu.jscript.compilation;
+
+public class FunctionBody {
+    public final Instruction[] instructions;
+    public final String[] captureNames, localNames;
+    public final int localsN, argsN;
+
+    public FunctionBody(int localsN, int argsN, Instruction[] instructions, String[] captureNames, String[] localNames) {
+        this.argsN = argsN;
+        this.localsN = localsN;
+        this.instructions = instructions;
+        this.captureNames = captureNames;
+        this.localNames = localNames;
+    }
+    public FunctionBody(int localsN, int argsN, Instruction[] instructions) {
+        this.argsN = argsN;
+        this.localsN = localsN;
+        this.instructions = instructions;
+        this.captureNames = new String[0];
+        this.localNames = new String[0];
+    }
+    public FunctionBody(Instruction... instructions) {
+        this.argsN = 0;
+        this.localsN = 2;
+        this.instructions = instructions;
+        this.captureNames = new String[0];
+        this.localNames = new String[0];
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/Instruction.java
+++ b/src/me/topchetoeu/jscript/compilation/Instruction.java
@@ -7,11 +7,11 @@ import me.topchetoeu.jscript.exceptions.SyntaxException;
 public class Instruction {
    public static enum Type {
        RETURN,
-        SIGNAL,
        THROW,
        THROW_SYNTAX,
        DELETE,
-        TRY,
+        TRY_START,
+        TRY_END,
        NOP,

        CALL,
@@ -34,7 +34,6 @@ public class Instruction {
        LOAD_REGEX,

        DUP,
-        MOVE,

        STORE_VAR,
        STORE_MEMBER,
@@ -46,61 +45,35 @@ public class Instruction {

        TYPEOF,
        OPERATION;
-        // TYPEOF,
-        // INSTANCEOF(true),
-        // IN(true),
+    }
+    public static enum BreakpointType {
+        NONE,
+        STEP_OVER,
+        STEP_IN;

-        // MULTIPLY(true),
-        // DIVIDE(true),
-        // MODULO(true),
-        // ADD(true),
-        // SUBTRACT(true),
-
-        // USHIFT_RIGHT(true),
-        // SHIFT_RIGHT(true),
-        // SHIFT_LEFT(true),
-
-        // GREATER(true),
-        // LESS(true),
-        // GREATER_EQUALS(true),
-        // LESS_EQUALS(true),
-        // LOOSE_EQUALS(true),
-        // LOOSE_NOT_EQUALS(true),
-        // EQUALS(true),
-        // NOT_EQUALS(true),
-
-        // AND(true),
-        // OR(true),
-        // XOR(true),
-
-        // NEG(true),
-        // POS(true),
-        // NOT(true),
-        // INVERSE(true);
-
-        // final boolean isOperation;
-
-        // private Type(boolean isOperation) {
-        //     this.isOperation = isOperation;
-        // }
-        // private Type() {
-        //     this(false);
-        // }
+        public boolean shouldStepIn() {
+            return this != NONE;
+        }
+        public boolean shouldStepOver() {
+            return this == STEP_OVER;
+        }
    }

    public final Type type;
    public final Object[] params;
    public Location location;
-    public boolean debugged;
+    public BreakpointType breakpoint = BreakpointType.NONE;
+
+    public Instruction setDbgData(Instruction other) {
+        this.location = other.location;
+        this.breakpoint = other.breakpoint;
+        return this;
+    }

    public Instruction locate(Location loc) {
        this.location = loc;
        return this;
    }
-    public Instruction setDebug(boolean debug) {
-        debugged = debug;
-        return this;
-    }

    @SuppressWarnings("unchecked")
    public <T> T get(int i) {
@@ -135,40 +108,32 @@ public class Instruction {
        this.params = params;
    }

-    public static Instruction tryInstr(int n, int catchN, int finallyN) {
-        return new Instruction(null, Type.TRY, n, catchN, finallyN);
+    public static Instruction tryStart(Location loc, int catchStart, int finallyStart, int end) {
+        return new Instruction(loc, Type.TRY_START, catchStart, finallyStart, end);
    }
-    public static Instruction throwInstr() {
-        return new Instruction(null, Type.THROW);
+    public static Instruction tryEnd(Location loc) {
+        return new Instruction(loc, Type.TRY_END);
    }
-    public static Instruction throwSyntax(SyntaxException err) {
-        return new Instruction(null, Type.THROW_SYNTAX, err.getMessage());
+    public static Instruction throwInstr(Location loc) {
+        return new Instruction(loc, Type.THROW);
    }
-    public static Instruction delete() {
-        return new Instruction(null, Type.DELETE);
+    public static Instruction throwSyntax(Location loc, SyntaxException err) {
+        return new Instruction(loc, Type.THROW_SYNTAX, err.getMessage());
    }
-    public static Instruction ret() {
-        return new Instruction(null, Type.RETURN);
+    public static Instruction throwSyntax(Location loc, String err) {
+        return new Instruction(loc, Type.THROW_SYNTAX, err);
    }
-    public static Instruction debug() {
-        return new Instruction(null, Type.NOP, "debug");
+    public static Instruction delete(Location loc) {
+        return new Instruction(loc, Type.DELETE);
    }
-    public static Instruction debugVarNames(String[] names) {
-        var args = new Object[names.length + 1];
-        args[0] = "dbg_vars";
-
-        System.arraycopy(names, 0, args, 1, names.length);
-
-        return new Instruction(null, Type.NOP, args);
+    public static Instruction ret(Location loc) {
+        return new Instruction(loc, Type.RETURN);
+    }
+    public static Instruction debug(Location loc) {
+        return new Instruction(loc, Type.NOP, "debug");
    }

-    /**
-     * ATTENTION: Usage outside of try/catch is broken af
-     */
-    public static Instruction signal(String name) {
-        return new Instruction(null, Type.SIGNAL, name);
-    }
-    public static Instruction nop(Object ...params) {
+    public static Instruction nop(Location loc, Object ...params) {
        for (var param : params) {
            if (param instanceof String) continue;
            if (param instanceof Boolean) continue;
@@ -178,109 +143,104 @@ public class Instruction {

            throw new RuntimeException("NOP params may contain only strings, booleans, doubles, integers and nulls.");
        }
-        return new Instruction(null, Type.NOP, params);
+        return new Instruction(loc, Type.NOP, params);
    }

-    public static Instruction call(int argn) {
-        return new Instruction(null, Type.CALL, argn);
+    public static Instruction call(Location loc, int argn) {
+        return new Instruction(loc, Type.CALL, argn);
    }
-    public static Instruction callNew(int argn) {
-        return new Instruction(null, Type.CALL_NEW, argn);
+    public static Instruction callNew(Location loc, int argn) {
+        return new Instruction(loc, Type.CALL_NEW, argn);
    }
-    public static Instruction jmp(int offset) {
-        return new Instruction(null, Type.JMP, offset);
+    public static Instruction jmp(Location loc, int offset) {
+        return new Instruction(loc, Type.JMP, offset);
    }
-    public static Instruction jmpIf(int offset) {
-        return new Instruction(null, Type.JMP_IF, offset);
+    public static Instruction jmpIf(Location loc, int offset) {
+        return new Instruction(loc, Type.JMP_IF, offset);
    }
-    public static Instruction jmpIfNot(int offset) {
-        return new Instruction(null, Type.JMP_IFN, offset);
+    public static Instruction jmpIfNot(Location loc, int offset) {
+        return new Instruction(loc, Type.JMP_IFN, offset);
    }

-    public static Instruction loadValue(Object val) {
-        return new Instruction(null, Type.LOAD_VALUE, val);
+    public static Instruction loadValue(Location loc, Object val) {
+        return new Instruction(loc, Type.LOAD_VALUE, val);
    }

-    public static Instruction makeVar(String name) {
-        return new Instruction(null, Type.MAKE_VAR, name);
+    public static Instruction makeVar(Location loc, String name) {
+        return new Instruction(loc, Type.MAKE_VAR, name);
    }
-    public static Instruction loadVar(Object i) {
-        return new Instruction(null, Type.LOAD_VAR, i);
+    public static Instruction loadVar(Location loc, Object i) {
+        return new Instruction(loc, Type.LOAD_VAR, i);
    }
-    public static Instruction loadGlob() {
-        return new Instruction(null, Type.LOAD_GLOB);
+    public static Instruction loadGlob(Location loc) {
+        return new Instruction(loc, Type.LOAD_GLOB);
    }
-    public static Instruction loadMember() {
-        return new Instruction(null, Type.LOAD_MEMBER);
+    public static Instruction loadMember(Location loc) {
+        return new Instruction(loc, Type.LOAD_MEMBER);
    }
-    public static Instruction loadMember(Object key) {
+    public static Instruction loadMember(Location loc, Object key) {
        if (key instanceof Number) key = ((Number)key).doubleValue();
-        return new Instruction(null, Type.LOAD_VAL_MEMBER, key);
+        return new Instruction(loc, Type.LOAD_VAL_MEMBER, key);
    }

-    public static Instruction loadRegex(String pattern, String flags) {
-        return new Instruction(null, Type.LOAD_REGEX, pattern, flags);
+    public static Instruction loadRegex(Location loc, String pattern, String flags) {
+        return new Instruction(loc, Type.LOAD_REGEX, pattern, flags);
    }
-    public static Instruction loadFunc(int instrN, int varN, int len, int[] captures) {
-        var args = new Object[3 + captures.length];
-        args[0] = instrN;
-        args[1] = varN;
-        args[2] = len;
-        for (var i = 0; i < captures.length; i++) args[i + 3] = captures[i];
-        return new Instruction(null, Type.LOAD_FUNC, args);
+    public static Instruction loadFunc(Location loc, long id, int[] captures) {
+        var args = new Object[1 + captures.length];
+        args[0] = id;
+        for (var i = 0; i < captures.length; i++) args[i + 1] = captures[i];
+        return new Instruction(loc, Type.LOAD_FUNC, args);
    }
-    public static Instruction loadObj() {
-        return new Instruction(null, Type.LOAD_OBJ);
+    public static Instruction loadObj(Location loc) {
+        return new Instruction(loc, Type.LOAD_OBJ);
    }
-    public static Instruction loadArr(int count) {
-        return new Instruction(null, Type.LOAD_ARR, count);
+    public static Instruction loadArr(Location loc, int count) {
+        return new Instruction(loc, Type.LOAD_ARR, count);
    }
-    public static Instruction dup() {
-        return new Instruction(null, Type.DUP, 0, 1);
+    public static Instruction dup(Location loc) {
+        return new Instruction(loc, Type.DUP, 1);
    }
-    public static Instruction dup(int count, int offset) {
-        return new Instruction(null, Type.DUP, offset, count);
-    }
-    public static Instruction move(int count, int offset) {
-        return new Instruction(null, Type.MOVE, offset, count);
+    public static Instruction dup(Location loc, int count) {
+        return new Instruction(loc, Type.DUP, count);
    }

-    public static Instruction storeSelfFunc(int i) {
-        return new Instruction(null, Type.STORE_SELF_FUNC, i);
+    public static Instruction storeSelfFunc(Location loc, int i) {
+        return new Instruction(loc, Type.STORE_SELF_FUNC, i);
    }
-    public static Instruction storeVar(Object i) {
-        return new Instruction(null, Type.STORE_VAR, i, false);
+    public static Instruction storeVar(Location loc, Object i) {
+        return new Instruction(loc, Type.STORE_VAR, i, false);
    }
-    public static Instruction storeVar(Object i, boolean keep) {
-        return new Instruction(null, Type.STORE_VAR, i, keep);
+    public static Instruction storeVar(Location loc, Object i, boolean keep) {
+        return new Instruction(loc, Type.STORE_VAR, i, keep);
    }
-    public static Instruction storeMember() {
-        return new Instruction(null, Type.STORE_MEMBER, false);
+    public static Instruction storeMember(Location loc) {
+        return new Instruction(loc, Type.STORE_MEMBER, false);
    }
-    public static Instruction storeMember(boolean keep) {
-        return new Instruction(null, Type.STORE_MEMBER, keep);
+    public static Instruction storeMember(Location loc, boolean keep) {
+        return new Instruction(loc, Type.STORE_MEMBER, keep);
    }
-    public static Instruction discard() {
-        return new Instruction(null, Type.DISCARD);
+    public static Instruction discard(Location loc) {
+        return new Instruction(loc, Type.DISCARD);
    }

-    public static Instruction typeof() {
-        return new Instruction(null, Type.TYPEOF);
+    public static Instruction typeof(Location loc) {
+        return new Instruction(loc, Type.TYPEOF);
    }
-    public static Instruction typeof(Object varName) {
-        return new Instruction(null, Type.TYPEOF, varName);
+    public static Instruction typeof(Location loc, Object varName) {
+        return new Instruction(loc, Type.TYPEOF, varName);
    }

-    public static Instruction keys() {
-        return new Instruction(null, Type.KEYS);
+    public static Instruction keys(Location loc, boolean forInFormat) {
+        return new Instruction(loc, Type.KEYS, forInFormat);
    }

-    public static Instruction defProp() {
-        return new Instruction(null, Type.DEF_PROP);
+    public static Instruction defProp(Location loc) {
+        return new Instruction(loc, Type.DEF_PROP);
    }

-    public static Instruction operation(Operation op) {
-        return new Instruction(null, Type.OPERATION, op);
+    public static Instruction operation(Location loc, Operation op) {
+        return new Instruction(loc, Type.OPERATION, op);
    }

    @Override
--- a/src/me/topchetoeu/jscript/compilation/Statement.java
+++ b/src/me/topchetoeu/jscript/compilation/Statement.java
@@ -1,36 +1,26 @@
 package me.topchetoeu.jscript.compilation;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public abstract class Statement {
    private Location _loc;

-    public abstract boolean pollutesStack();
    public boolean pure() { return false; }
-    public abstract void compile(List<Instruction> target, ScopeRecord scope);
    public void declare(ScopeRecord varsScope) { }
-    public Statement optimize() { return this; }

-    public void compileNoPollution(List<Instruction> target, ScopeRecord scope, boolean debug) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
        int start = target.size();
-        compile(target, scope);
-        if (debug && target.size() != start) target.get(start).setDebug(true);
-        if (pollutesStack()) target.add(Instruction.discard().locate(loc()));
+        compile(target, scope, pollute);
+
+        if (target.size() != start) {
+            target.get(start).locate(loc());
+            target.setDebug(start, type);
+        }
    }
-    public void compileWithPollution(List<Instruction> target, ScopeRecord scope, boolean debug) {
-        int start = target.size();
-        compile(target, scope);
-        if (debug && target.size() != start) target.get(start).setDebug(true);
-        if (!pollutesStack()) target.add(Instruction.loadValue(null).locate(loc()));
-    }
-    public void compileNoPollution(List<Instruction> target, ScopeRecord scope) {
-        compileNoPollution(target, scope, false);
-    }
-    public void compileWithPollution(List<Instruction> target, ScopeRecord scope) {
-        compileWithPollution(target, scope, false);
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, BreakpointType.NONE);
    }

    public Location loc() { return _loc; }
--- a/src/me/topchetoeu/jscript/compilation/ThrowSyntaxStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/ThrowSyntaxStatement.java
@@ -0,0 +1,18 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.engine.scope.ScopeRecord;
+import me.topchetoeu.jscript.exceptions.SyntaxException;
+
+public class ThrowSyntaxStatement extends Statement {
+    public final String name;
+
+    @Override
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.throwSyntax(loc(), name));
+    }
+
+    public ThrowSyntaxStatement(SyntaxException e) {
+        super(e.loc);
+        this.name = e.msg;
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/VariableDeclareStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/VariableDeclareStatement.java
@@ -3,6 +3,7 @@ package me.topchetoeu.jscript.compilation;
 import java.util.List;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.values.FunctionStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

@@ -10,17 +11,17 @@ public class VariableDeclareStatement extends Statement {
    public static class Pair {
        public final String name;
        public final Statement value;
+        public final Location location;

-        public Pair(String name, Statement value) {
+        public Pair(String name, Statement value, Location location) {
            this.name = name;
            this.value = value;
+            this.location = location;
        }
    }

    public final List<Pair> values;

-    @Override
-    public boolean pollutesStack() { return false; }
    @Override
    public void declare(ScopeRecord varsScope) {
        for (var key : values) {
@@ -28,21 +29,20 @@ public class VariableDeclareStatement extends Statement {
        }
    }
    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        for (var entry : values) {
            if (entry.name == null) continue;
            var key = scope.getKey(entry.name);
-            if (key instanceof String) target.add(Instruction.makeVar((String)key).locate(loc()));

-            if (entry.value instanceof FunctionStatement) {
-                ((FunctionStatement)entry.value).compile(target, scope, entry.name, false);
-                target.add(Instruction.storeVar(key).locate(loc()));
-            }
-            else if (entry.value != null) {
-                entry.value.compileWithPollution(target, scope);
-                target.add(Instruction.storeVar(key).locate(loc()));
+            if (key instanceof String) target.add(Instruction.makeVar(entry.location, (String)key));
+
+            if (entry.value != null) {
+                FunctionStatement.compileWithName(entry.value, target, scope, true, entry.name, BreakpointType.STEP_OVER);
+                target.add(Instruction.storeVar(entry.location, key));
            }
        }
+
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public VariableDeclareStatement(Location loc, List<Pair> values) {
--- a/src/me/topchetoeu/jscript/compilation/control/BreakStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/BreakStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,11 +10,9 @@ public class BreakStatement extends Statement {
    public final String label;

    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.nop("break", label).locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.nop(loc(), "break", label));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public BreakStatement(Location loc, String label) {
--- a/src/me/topchetoeu/jscript/compilation/control/ContinueStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/ContinueStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,11 +10,9 @@ public class ContinueStatement extends Statement {
    public final String label;

    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.nop("cont", label).locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.nop(loc(), "cont", label));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public ContinueStatement(Location loc, String label) {
--- a/src/me/topchetoeu/jscript/compilation/control/DebugStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/DebugStatement.java
@@ -1,19 +1,16 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public class DebugStatement extends Statement {
    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.debug().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.debug(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public DebugStatement(Location loc) {
--- a/src/me/topchetoeu/jscript/compilation/control/DeleteStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/DeleteStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -12,13 +11,12 @@ public class DeleteStatement extends Statement {
    public final Statement value;

    @Override
-    public boolean pollutesStack() { return true; }
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        value.compile(target, scope, true);
+        key.compile(target, scope, true);

-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        value.compile(target, scope);
-        key.compile(target, scope);
-        target.add(Instruction.delete().locate(loc()));
+        target.add(Instruction.delete(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), true));
    }

    public DeleteStatement(Location loc, Statement key, Statement value) {
--- a/src/me/topchetoeu/jscript/compilation/control/DoWhileStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/DoWhileStatement.java
@@ -1,76 +1,31 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;

 public class DoWhileStatement extends Statement {
    public final Statement condition, body;
    public final String label;

-    @Override
-    public boolean pollutesStack() { return false; }
-
    @Override
    public void declare(ScopeRecord globScope) {
        body.declare(globScope);
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (condition instanceof ConstantStatement) {
-            int start = target.size();
-            body.compileNoPollution(target, scope);
-            int end = target.size();
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                WhileStatement.replaceBreaks(target, label, start, end, end + 1, end + 1);
-            }
-            else {
-                target.add(Instruction.jmp(start - end).locate(loc()));
-                WhileStatement.replaceBreaks(target, label, start, end, start, end + 1);
-            }
-            return;
-        }
-
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        int start = target.size();
-        body.compileNoPollution(target, scope, true);
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
        int mid = target.size();
-        condition.compileWithPollution(target, scope);
+        condition.compile(target, scope, true, BreakpointType.STEP_OVER);
        int end = target.size();

        WhileStatement.replaceBreaks(target, label, start, mid - 1, mid, end + 1);
-        target.add(Instruction.jmpIf(start - end).locate(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (b instanceof CompoundStatement) {
-            var comp = (CompoundStatement)b;
-            if (comp.statements.length > 0) {
-                var last = comp.statements[comp.statements.length - 1];
-                if (last instanceof ContinueStatement) comp.statements[comp.statements.length - 1] = new CompoundStatement(loc());
-                if (last instanceof BreakStatement) {
-                    comp.statements[comp.statements.length - 1] = new CompoundStatement(loc());
-                    return new CompoundStatement(loc());
-                }
-            }
-        }
-        else if (b instanceof ContinueStatement) {
-            b = new CompoundStatement(loc());
-        }
-        else if (b instanceof BreakStatement) return new CompoundStatement(loc());
-
-        if (b.pure()) return new DoWhileStatement(loc(), label, cond, new CompoundStatement(loc()));
-        else return new DoWhileStatement(loc(), label, cond, b);
+        target.add(Instruction.jmpIf(loc(), start - end));
    }

    public DoWhileStatement(Location loc, String label, Statement condition, Statement body) {
--- a/src/me/topchetoeu/jscript/compilation/control/ForInStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/ForInStatement.java
@@ -1,10 +1,10 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

@@ -13,9 +13,7 @@ public class ForInStatement extends Statement {
    public final boolean isDeclaration;
    public final Statement varValue, object, body;
    public final String label;
-
-    @Override
-    public boolean pollutesStack() { return false; }
+    public final Location varLocation;

    @Override
    public void declare(ScopeRecord globScope) {
@@ -24,54 +22,47 @@ public class ForInStatement extends Statement {
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        var key = scope.getKey(varName);
-        if (key instanceof String) target.add(Instruction.makeVar((String)key));
+
+        int first = target.size();
+        if (key instanceof String) target.add(Instruction.makeVar(loc(), (String)key));

        if (varValue != null) {
-            varValue.compileWithPollution(target, scope);
-            target.add(Instruction.storeVar(scope.getKey(varName)));
+            varValue.compile(target, scope, true);
+            target.add(Instruction.storeVar(loc(), scope.getKey(varName)));
        }

-        object.compileWithPollution(target, scope);
-        target.add(Instruction.keys());
-        
+        object.compile(target, scope, true, BreakpointType.STEP_OVER);
+        target.add(Instruction.keys(loc(), true));
+
        int start = target.size();
-        target.add(Instruction.dup());
-        target.add(Instruction.loadMember("length"));
-        target.add(Instruction.loadValue(0));
-        target.add(Instruction.operation(Operation.LESS_EQUALS));
+        target.add(Instruction.dup(loc()));
+        target.add(Instruction.loadValue(loc(), null));
+        target.add(Instruction.operation(loc(), Operation.EQUALS));
        int mid = target.size();
-        target.add(Instruction.nop());
+        target.add(Instruction.nop(loc()));

-        target.add(Instruction.dup());
-        target.add(Instruction.dup());
-        target.add(Instruction.loadMember("length"));
-        target.add(Instruction.loadValue(1));
-        target.add(Instruction.operation(Operation.SUBTRACT));
-        target.add(Instruction.dup(1, 2));
-        target.add(Instruction.loadValue("length"));
-        target.add(Instruction.dup(1, 2));
-        target.add(Instruction.storeMember());
-        target.add(Instruction.loadMember());
-        target.add(Instruction.storeVar(key));
-
-        for (var i = start; i < target.size(); i++) target.get(i).locate(loc());
-
-        body.compileNoPollution(target, scope, true);
+        target.add(Instruction.loadMember(varLocation, "value"));
+        target.add(Instruction.storeVar(object.loc(), key));
+        target.setDebug(BreakpointType.STEP_OVER);

+        body.compile(target, scope, false, BreakpointType.STEP_OVER);

        int end = target.size();

        WhileStatement.replaceBreaks(target, label, mid + 1, end, start, end + 1);

-        target.add(Instruction.jmp(start - end).locate(loc()));
-        target.add(Instruction.discard().locate(loc()));
-        target.set(mid, Instruction.jmpIf(end - mid + 1).locate(loc()));
+        target.add(Instruction.jmp(loc(), start - end));
+        target.add(Instruction.discard(loc()));
+        target.set(mid, Instruction.jmpIf(loc(), end - mid + 1));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
+        target.get(first).locate(loc());
    }

-    public ForInStatement(Location loc, String label, boolean isDecl, String varName, Statement varValue, Statement object, Statement body) {
+    public ForInStatement(Location loc, Location varLocation, String label, boolean isDecl, String varName, Statement varValue, Statement object, Statement body) {
        super(loc);
+        this.varLocation = varLocation;
        this.label = label;
        this.isDeclaration = isDecl;
        this.varName = varName;
--- a/src/me/topchetoeu/jscript/compilation/control/ForStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/ForStatement.java
@@ -1,79 +1,39 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;

 public class ForStatement extends Statement {
    public final Statement declaration, assignment, condition, body;
    public final String label;

-    @Override
-    public boolean pollutesStack() { return false; }
-
    @Override
    public void declare(ScopeRecord globScope) {
        declaration.declare(globScope);
        body.declare(globScope);
    }
    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        declaration.compile(target, scope);
-
-        if (condition instanceof ConstantStatement) {
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                int start = target.size();
-                body.compileNoPollution(target, scope);
-                int mid = target.size();
-                assignment.compileNoPollution(target, scope, true);
-                int end = target.size();
-                WhileStatement.replaceBreaks(target, label, start, mid, mid, end + 1);
-                target.add(Instruction.jmp(start - target.size()).locate(loc()));
-                return;
-            }
-        }
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        declaration.compile(target, scope, false, BreakpointType.STEP_OVER);

        int start = target.size();
-        condition.compileWithPollution(target, scope);
+        condition.compile(target, scope, true, BreakpointType.STEP_OVER);
        int mid = target.size();
-        target.add(Instruction.nop());
-        body.compileNoPollution(target, scope);
+        target.add(Instruction.nop(null));
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);
        int beforeAssign = target.size();
-        assignment.compile(target, scope);
+        assignment.compile(target, scope, false, BreakpointType.STEP_OVER);
        int end = target.size();

        WhileStatement.replaceBreaks(target, label, mid + 1, end, beforeAssign, end + 1);

-        target.add(Instruction.jmp(start - end).locate(loc()));
-        target.set(mid, Instruction.jmpIfNot(end - mid + 1).locate(loc()));
-    }
-    @Override
-    public Statement optimize() {
-        var decl = declaration.optimize();
-        var asgn = assignment.optimize();
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (asgn.pure()) {
-            if (decl.pure()) return new WhileStatement(loc(), label, cond, b).optimize();
-            else return new CompoundStatement(loc(),
-                decl, new WhileStatement(loc(), label, cond, b)
-            ).optimize();
-        }
-
-        else if (b instanceof ContinueStatement) return new CompoundStatement(loc(),
-            decl, new WhileStatement(loc(), label, cond, new CompoundStatement(loc(), b, asgn))
-        );
-        else if (b instanceof BreakStatement) return decl;
-
-        if (b.pure()) return new ForStatement(loc(), label, decl, cond, asgn, new CompoundStatement(null));
-        else return new ForStatement(loc(), label, decl, cond, asgn, b);
+        target.add(Instruction.jmp(loc(), start - end));
+        target.set(mid, Instruction.jmpIfNot(loc(), end - mid + 1));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public ForStatement(Location loc, String label, Statement declaration, Statement condition, Statement assignment, Statement body) {
@@ -84,14 +44,4 @@ public class ForStatement extends Statement {
        this.assignment = assignment;
        this.body = body;
    }
-
-    public static CompoundStatement ofFor(Location loc, String label, Statement declaration, Statement condition, Statement increment, Statement body) {
-        return new CompoundStatement(loc,
-            declaration,
-            new WhileStatement(loc, label, condition, new CompoundStatement(loc,
-                body,
-                increment
-            ))
-        );
-    }
 }
--- a/src/me/topchetoeu/jscript/compilation/control/IfStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/IfStatement.java
@@ -1,74 +1,46 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
-import me.topchetoeu.jscript.compilation.DiscardStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;

 public class IfStatement extends Statement {
    public final Statement condition, body, elseBody;

-    @Override
-    public boolean pollutesStack() { return false; }
-
    @Override
    public void declare(ScopeRecord globScope) {
        body.declare(globScope);
        if (elseBody != null) elseBody.declare(globScope);
    }

-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (condition instanceof ConstantStatement) {
-            if (Values.not(((ConstantStatement)condition).value)) {
-                if (elseBody != null) elseBody.compileNoPollution(target, scope, true);
-            }
-            else {
-                body.compileNoPollution(target, scope, true);
-            }
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType breakpoint) {
+        condition.compile(target, scope, true, breakpoint);

-            return;
-        }
-
-        condition.compileWithPollution(target, scope);
        if (elseBody == null) {
            int i = target.size();
-            target.add(Instruction.nop());
-            body.compileNoPollution(target, scope, true);
+            target.add(Instruction.nop(null));
+            body.compile(target, scope, pollute, breakpoint);
            int endI = target.size();
-            target.set(i, Instruction.jmpIfNot(endI - i).locate(loc()));
+            target.set(i, Instruction.jmpIfNot(loc(), endI - i));
        }
        else {
            int start = target.size();
-            target.add(Instruction.nop());
-            body.compileNoPollution(target, scope, true);
-            target.add(Instruction.nop());
+            target.add(Instruction.nop(null));
+            body.compile(target, scope, pollute, breakpoint);
+            target.add(Instruction.nop(null));
            int mid = target.size();
-            elseBody.compileNoPollution(target, scope, true);
+            elseBody.compile(target, scope, pollute, breakpoint);
            int end = target.size();

-            target.set(start, Instruction.jmpIfNot(mid - start).locate(loc()));
-            target.set(mid - 1, Instruction.jmp(end - mid + 1).locate(loc()));
+            target.set(start, Instruction.jmpIfNot(loc(), mid - start));
+            target.set(mid - 1, Instruction.jmp(loc(), end - mid + 1));
        }
    }
-    
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-        var e = elseBody == null ? null : elseBody.optimize();
-
-        if (b.pure()) b = new CompoundStatement(null);
-        if (e != null && e.pure()) e = null;
-
-        if (b.pure() && e == null) return new DiscardStatement(loc(), cond).optimize();
-        else return new IfStatement(loc(), cond, b, e);
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, BreakpointType.STEP_IN);
    }

    public IfStatement(Location loc, Statement condition, Statement body, Statement elseBody) {
--- a/src/me/topchetoeu/jscript/compilation/control/ReturnStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/ReturnStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,13 +10,10 @@ public class ReturnStatement extends Statement {
    public final Statement value;

    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (value == null) target.add(Instruction.loadValue(null).locate(loc()));
-        else value.compileWithPollution(target, scope);
-        target.add(Instruction.ret().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        if (value == null) target.add(Instruction.loadValue(loc(), null));
+        else value.compile(target, scope, true);
+        target.add(Instruction.ret(loc()));
    }

    public ReturnStatement(Location loc, Statement value) {
--- a/src/me/topchetoeu/jscript/compilation/control/SwitchStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/SwitchStatement.java
@@ -1,11 +1,12 @@
 package me.topchetoeu.jscript.compilation.control;

 import java.util.HashMap;
-import java.util.List;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -21,9 +22,6 @@ public class SwitchStatement extends Statement {
        }
    }

-    @Override
-    public boolean pollutesStack() { return false; }
-
    public final Statement value;
    public final SwitchCase[] cases;
    public final Statement[] body;
@@ -35,46 +33,48 @@ public class SwitchStatement extends Statement {
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        var caseMap = new HashMap<Integer, Integer>();
-        var stmIndexMap = new HashMap<Integer, Integer>();
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        var caseToStatement = new HashMap<Integer, Integer>();
+        var statementToIndex = new HashMap<Integer, Integer>();

-        value.compile(target, scope);
+        value.compile(target, scope, true, BreakpointType.STEP_OVER);

        for (var ccase : cases) {
-            target.add(Instruction.dup().locate(loc()));
-            ccase.value.compileWithPollution(target, scope);
-            target.add(Instruction.operation(Operation.EQUALS).locate(loc()));
-            caseMap.put(target.size(), ccase.statementI);
-            target.add(Instruction.nop());
+            target.add(Instruction.dup(loc()));
+            ccase.value.compile(target, scope, true);
+            target.add(Instruction.operation(loc(), Operation.EQUALS));
+            caseToStatement.put(target.size(), ccase.statementI);
+            target.add(Instruction.nop(null));
        }

        int start = target.size();

-        target.add(Instruction.nop());
+        target.add(Instruction.nop(null));

        for (var stm : body) {
-            stmIndexMap.put(stmIndexMap.size(), target.size());
-            stm.compileNoPollution(target, scope, true);
+            statementToIndex.put(statementToIndex.size(), target.size());
+            stm.compile(target, scope, false, BreakpointType.STEP_OVER);
        }

-        if (defaultI < 0 || defaultI >= body.length) target.set(start, Instruction.jmp(target.size() - start).locate(loc()));
-        else target.set(start, Instruction.jmp(stmIndexMap.get(defaultI) - start)).locate(loc());
+        int end = target.size();
+        target.add(Instruction.discard(loc()));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));

-        for (int i = start; i < target.size(); i++) {
+        if (defaultI < 0 || defaultI >= body.length) target.set(start, Instruction.jmp(loc(), end - start));
+        else target.set(start, Instruction.jmp(loc(), statementToIndex.get(defaultI) - start));
+
+        for (int i = start; i < end; i++) {
            var instr = target.get(i);
            if (instr.type == Type.NOP && instr.is(0, "break") && instr.get(1) == null) {
-                target.set(i, Instruction.jmp(target.size() - i).locate(instr.location));
+                target.set(i, Instruction.jmp(loc(), end - i).locate(instr.location));
            }
        }
-        for (var el : caseMap.entrySet()) {
-            var loc = target.get(el.getKey()).location;
-            var i = stmIndexMap.get(el.getValue());
-            if (i == null) i = target.size();
-            target.set(el.getKey(), Instruction.jmpIf(i - el.getKey()).locate(loc).setDebug(true));
+        for (var el : caseToStatement.entrySet()) {
+            var i = statementToIndex.get(el.getValue());
+            if (i == null) i = end;
+            target.set(el.getKey(), Instruction.jmpIf(loc(), i - el.getKey()));
        }

-        target.add(Instruction.discard().locate(loc()));
    }

    public SwitchStatement(Location loc, Statement value, int defaultI, SwitchCase[] cases, Statement[] body) {
--- a/src/me/topchetoeu/jscript/compilation/control/ThrowStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/ThrowStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,12 +10,9 @@ public class ThrowStatement extends Statement {
    public final Statement value;

    @Override
-    public boolean pollutesStack() { return false; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        value.compileWithPollution(target, scope);
-        target.add(Instruction.throwInstr().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        value.compile(target, scope, true);
+        target.add(Instruction.throwInstr(loc()));
    }

    public ThrowStatement(Location loc, Statement value) {
--- a/src/me/topchetoeu/jscript/compilation/control/TryStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/TryStatement.java
@@ -1,10 +1,10 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.GlobalScope;
 import me.topchetoeu.jscript.engine.scope.LocalScopeRecord;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -15,9 +15,6 @@ public class TryStatement extends Statement {
    public final Statement finallyBody;
    public final String name;

-    @Override
-    public boolean pollutesStack() { return false; }
-
    @Override
    public void declare(ScopeRecord globScope) {
        tryBody.declare(globScope);
@@ -26,30 +23,32 @@ public class TryStatement extends Statement {
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.nop());
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType bpt) {
+        target.add(Instruction.nop(null));

-        int start = target.size(), tryN, catchN = -1, finN = -1;
+        int start = target.size(), catchStart = -1, finallyStart = -1;

-        tryBody.compileNoPollution(target, scope);
-        tryN = target.size() - start;
+        tryBody.compile(target, scope, false);
+        target.add(Instruction.tryEnd(loc()));

        if (catchBody != null) {
-            int tmp = target.size();
+            catchStart = target.size() - start;
            var local = scope instanceof GlobalScope ? scope.child() : (LocalScopeRecord)scope;
            local.define(name, true);
-            catchBody.compileNoPollution(target, scope);
+            catchBody.compile(target, scope, false);
            local.undefine();
-            catchN = target.size() - tmp;
+            target.add(Instruction.tryEnd(loc()));
        }

        if (finallyBody != null) {
-            int tmp = target.size();
-            finallyBody.compileNoPollution(target, scope);
-            finN = target.size() - tmp;
+            finallyStart = target.size() - start;
+            finallyBody.compile(target, scope, false);
+            target.add(Instruction.tryEnd(loc()));
        }

-        target.set(start - 1, Instruction.tryInstr(tryN, catchN, finN).locate(loc()));
+        target.set(start - 1, Instruction.tryStart(loc(), catchStart, finallyStart, target.size() - start));
+        target.setDebug(start - 1, BreakpointType.STEP_OVER);
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public TryStatement(Location loc, Statement tryBody, Statement catchBody, Statement finallyBody, String name) {
--- a/src/me/topchetoeu/jscript/compilation/control/WhileStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/control/WhileStatement.java
@@ -1,66 +1,36 @@
 package me.topchetoeu.jscript.compilation.control;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.CompoundStatement;
-import me.topchetoeu.jscript.compilation.DiscardStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
-import me.topchetoeu.jscript.compilation.values.ConstantStatement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;

 public class WhileStatement extends Statement {
    public final Statement condition, body;
    public final String label;

-    @Override
-    public boolean pollutesStack() { return false; }
-
    @Override
    public void declare(ScopeRecord globScope) {
        body.declare(globScope);
    }
    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (condition instanceof ConstantStatement) {
-            if (Values.toBoolean(((ConstantStatement)condition).value)) {
-                int start = target.size();
-                body.compileNoPollution(target, scope);
-                int end = target.size();
-                replaceBreaks(target, label, start, end, start, end + 1);
-                target.add(Instruction.jmp(start - target.size()).locate(loc()));
-                return;
-            }
-        }
-
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        int start = target.size();
-        condition.compileWithPollution(target, scope);
+        condition.compile(target, scope, true);
        int mid = target.size();
-        target.add(Instruction.nop());
-        body.compileNoPollution(target, scope);
+        target.add(Instruction.nop(null));
+        body.compile(target, scope, false, BreakpointType.STEP_OVER);

        int end = target.size();

        replaceBreaks(target, label, mid + 1, end, start, end + 1);

-        target.add(Instruction.jmp(start - end).locate(loc()));
-        target.set(mid, Instruction.jmpIfNot(end - mid + 1).locate(loc()));
-    }
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var b = body.optimize();
-
-        if (b instanceof ContinueStatement) {
-            b = new CompoundStatement(loc());
-        }
-        else if (b instanceof BreakStatement) return new DiscardStatement(loc(), cond).optimize();
-
-        if (b.pure()) return new WhileStatement(loc(), label, cond, new CompoundStatement(null));
-        else return new WhileStatement(loc(), label, cond, b);
+        target.add(Instruction.jmp(loc(), start - end));
+        target.set(mid, Instruction.jmpIfNot(loc(), end - mid + 1));
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
    }

    public WhileStatement(Location loc, String label, Statement condition, Statement body) {
@@ -70,27 +40,15 @@ public class WhileStatement extends Statement {
        this.body = body;
    }

-    public static void replaceBreaks(List<Instruction> target, String label, int start, int end, int continuePoint, int breakPoint) {
+    public static void replaceBreaks(CompileTarget target, String label, int start, int end, int continuePoint, int breakPoint) {
        for (int i = start; i < end; i++) {
            var instr = target.get(i);
            if (instr.type == Type.NOP && instr.is(0, "cont") && (instr.get(1) == null || instr.is(1, label))) {
-                target.set(i, Instruction.jmp(continuePoint - i));
-                target.get(i).location = instr.location;
+                target.set(i, Instruction.jmp(instr.location, continuePoint - i).setDbgData(target.get(i)));
            }
            if (instr.type == Type.NOP && instr.is(0, "break") && (instr.get(1) == null || instr.is(1, label))) {
-                target.set(i, Instruction.jmp(breakPoint - i));
-                target.get(i).location = instr.location;
+                target.set(i, Instruction.jmp(instr.location, breakPoint - i).setDbgData(target.get(i)));
            }
        }
    }
-
-    // public static CompoundStatement ofFor(Location loc, String label, Statement declaration, Statement condition, Statement increment, Statement body) {
-    //     return new CompoundStatement(loc,
-    //         declaration,
-    //         new WhileStatement(loc, label, condition, new CompoundStatement(loc,
-    //             body,
-    //             increment
-    //         ))
-    //     );
-    // }
 }
--- a/src/me/topchetoeu/jscript/compilation/values/ArrayStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/ArrayStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -10,24 +9,29 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class ArrayStatement extends Statement {
    public final Statement[] statements;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    @Override public boolean pure() {
+        for (var stm : statements) {
+            if (!stm.pure()) return false;
+        }
+
+        return true;
+    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadArr(statements.length).locate(loc()));
-        var i = 0;
-        for (var el : statements) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.loadArr(loc(), statements.length));
+
+        for (var i = 0; i < statements.length; i++) {
+            var el = statements[i];
            if (el != null) {
-                target.add(Instruction.dup().locate(loc()));
-                target.add(Instruction.loadValue(i).locate(loc()));
-                el.compileWithPollution(target, scope);
-                target.add(Instruction.storeMember().locate(loc()));
+                target.add(Instruction.dup(loc()));
+                target.add(Instruction.loadValue(loc(), i));
+                el.compile(target, scope, true);
+                target.add(Instruction.storeMember(loc()));
            }
-            i++;
        }
+
+        if (!pollute) target.add(Instruction.discard(loc()));
    }

    public ArrayStatement(Location loc, Statement[] statements) {
--- a/src/me/topchetoeu/jscript/compilation/values/CallStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/CallStatement.java
@@ -1,43 +1,50 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public class CallStatement extends Statement {
    public final Statement func;
    public final Statement[] args;
+    public final boolean isNew;

    @Override
-    public boolean pollutesStack() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (func instanceof IndexStatement) {
-            ((IndexStatement)func).compile(target, scope, true);
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
+        if (isNew) func.compile(target, scope, true);
+        else if (func instanceof IndexStatement) {
+            ((IndexStatement)func).compile(target, scope, true, true);
        }
        else {
-            target.add(Instruction.loadValue(null).locate(loc()));
-            func.compileWithPollution(target, scope);
+            target.add(Instruction.loadValue(loc(), null));
+            func.compile(target, scope, true);
        }

-        for (var arg : args) {
-            arg.compileWithPollution(target, scope);
-        }
+        for (var arg : args) arg.compile(target, scope, true);

-        target.add(Instruction.call(args.length).locate(loc()).setDebug(true));
+        if (isNew) target.add(Instruction.callNew(loc(), args.length));
+        else target.add(Instruction.call(loc(), args.length));
+        target.setDebug(type);
+
+        if (!pollute) target.add(Instruction.discard(loc()));
+    }
+    @Override
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, BreakpointType.STEP_IN);
    }

-    public CallStatement(Location loc, Statement func, Statement ...args) {
+    public CallStatement(Location loc, boolean isNew, Statement func, Statement ...args) {
        super(loc);
+        this.isNew = isNew;
        this.func = func;
        this.args = args;
    }
-    public CallStatement(Location loc, Statement obj, Object key, Statement ...args) {
+    public CallStatement(Location loc, boolean isNew, Statement obj, Object key, Statement ...args) {
        super(loc);
+        this.isNew = isNew;
        this.func = new IndexStatement(loc, obj, new ConstantStatement(loc, key));
        this.args = args;
    }
--- a/src/me/topchetoeu/jscript/compilation/values/ChangeStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/ChangeStatement.java
@@ -1,9 +1,8 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.Operation;
@@ -15,11 +14,13 @@ public class ChangeStatement extends Statement {
    public final boolean postfix;

    @Override
-    public boolean pollutesStack() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        value.toAssign(new ConstantStatement(loc(), -addAmount), Operation.SUBTRACT).compile(target, scope, postfix);
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        value.toAssign(new ConstantStatement(loc(), -addAmount), Operation.SUBTRACT).compile(target, scope, true);
+        if (!pollute) target.add(Instruction.discard(loc()));
+        else if (postfix) {
+            target.add(Instruction.loadValue(loc(), addAmount));
+            target.add(Instruction.operation(loc(), Operation.SUBTRACT));
+        }
    }

    public ChangeStatement(Location loc, AssignableStatement value, double addAmount, boolean postfix) {
--- a/src/me/topchetoeu/jscript/compilation/values/CommaStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/CommaStatement.java
@@ -1,38 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public class CommaStatement extends Statement {
-    public final Statement first;
-    public final Statement second;
-
-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return first.pure() && second.pure(); }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        first.compileNoPollution(target, scope);
-        second.compileWithPollution(target, scope);
-    }
-
-    @Override
-    public Statement optimize() {
-        var f = first.optimize();
-        var s = second.optimize();
-        if (f.pure()) return s;
-        else return new CommaStatement(loc(), f, s);
-    }
-
-    public CommaStatement(Location loc, Statement first, Statement second) {
-        super(loc);
-        this.first = first;
-        this.second = second;
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/values/ConstantStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/ConstantStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -10,14 +9,11 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class ConstantStatement extends Statement {
    public final Object value;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    @Override public boolean pure() { return true; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadValue(value).locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        if (pollute) target.add(Instruction.loadValue(loc(), value));
    }

    public ConstantStatement(Location loc, Object val) {
--- a/src/me/topchetoeu/jscript/compilation/values/DiscardStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/DiscardStatement.java
@@ -0,0 +1,24 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
+import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.engine.scope.ScopeRecord;
+
+public class DiscardStatement extends Statement {
+    public final Statement value;
+
+    @Override public boolean pure() { return value.pure(); }
+
+    @Override
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        value.compile(target, scope, false);
+        if (pollute) target.add(Instruction.loadValue(loc(), null));
+    }
+
+    public DiscardStatement(Location loc, Statement val) {
+        super(loc);
+        this.value = val;
+    }
+}
--- a/src/me/topchetoeu/jscript/compilation/values/FunctionStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/FunctionStatement.java
@@ -1,31 +1,35 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
+import java.util.Random;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.CompoundStatement;
+import me.topchetoeu.jscript.compilation.FunctionBody;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.compilation.Instruction.Type;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 import me.topchetoeu.jscript.exceptions.SyntaxException;

 public class FunctionStatement extends Statement {
    public final CompoundStatement body;
-    public final String name;
+    public final String varName;
    public final String[] args;
+    public final boolean statement;
+    public final Location end;

-    @Override
-    public boolean pure() { return name == null; }
-    @Override
-    public boolean pollutesStack() { return true; }
+    private static Random rand = new Random();
+
+    @Override public boolean pure() { return varName == null && statement; }

    @Override
    public void declare(ScopeRecord scope) {
-        if (name != null) scope.define(name);
+        if (varName != null && statement) scope.define(varName);
    }

-    public static void checkBreakAndCont(List<Instruction> target, int start) {
+    public static void checkBreakAndCont(CompileTarget target, int start) {
        for (int i = start; i < target.size(); i++) {
            if (target.get(i).type == Type.NOP) {
                if (target.get(i).is(0, "break") ) {
@@ -38,71 +42,98 @@ public class FunctionStatement extends Statement {
        }
    }

-    public void compile(List<Instruction> target, ScopeRecord scope, String name, boolean isStatement) {
+    private long compileBody(CompileTarget target, ScopeRecord scope, boolean polute, BreakpointType bp) {
        for (var i = 0; i < args.length; i++) {
            for (var j = 0; j < i; j++) {
-                if (args[i].equals(args[j])){
-                    target.add(Instruction.throwSyntax(new SyntaxException(loc(), "Duplicate parameter '" + args[i] + "'.")));
-                    return;
+                if (args[i].equals(args[j])) {
+                    throw new SyntaxException(loc(), "Duplicate parameter '" + args[i] + "'.");
                }
            }
        }
+
+        var id = rand.nextLong();
        var subscope = scope.child();
+        var subtarget = new CompileTarget(target.functions, target.breakpoints);

-        int start = target.size();
-
-        target.add(Instruction.nop());
        subscope.define("this");
        var argsVar = subscope.define("arguments");

        if (args.length > 0) {
            for (var i = 0; i < args.length; i++) {
-                target.add(Instruction.loadVar(argsVar).locate(loc()));
-                target.add(Instruction.loadMember(i).locate(loc()));
-                target.add(Instruction.storeVar(subscope.define(args[i])).locate(loc()));
+                subtarget.add(Instruction.loadVar(loc(), argsVar));
+                subtarget.add(Instruction.loadMember(loc(), i));
+                subtarget.add(Instruction.storeVar(loc(), subscope.define(args[i])));
            }
        }

-        if (!isStatement && this.name != null) {
-            target.add(Instruction.storeSelfFunc((int)subscope.define(this.name)));
+        if (!statement && this.varName != null) {
+            subtarget.add(Instruction.storeSelfFunc(loc(), (int)subscope.define(this.varName)));
+            subtarget.setDebug(bp);
        }

        body.declare(subscope);
-        target.add(Instruction.debugVarNames(subscope.locals()));
-        body.compile(target, subscope);
+        body.compile(subtarget, subscope, false);
+        subtarget.add(Instruction.ret(end));
+        checkBreakAndCont(subtarget, 0);

-        checkBreakAndCont(target, start);
+        if (polute) target.add(Instruction.loadFunc(loc(), id, subscope.getCaptures()));
+        target.functions.put(id, new FunctionBody(
+            subscope.localsCount(), args.length,
+            subtarget.array(), subscope.captures(), subscope.locals()
+        ));

-        if (!(body instanceof CompoundStatement)) target.add(Instruction.ret().locate(loc()));
-
-        target.set(start, Instruction.loadFunc(target.size() - start, subscope.localsCount(), args.length, subscope.getCaptures()).locate(loc()));
-
-        if (name == null) name = this.name;
-
-        if (name != null) {
-            target.add(Instruction.dup().locate(loc()));
-            target.add(Instruction.loadValue("name").locate(loc()));
-            target.add(Instruction.loadValue(name).locate(loc()));
-            target.add(Instruction.storeMember().locate(loc()));
-        }
-
-        if (this.name != null && isStatement) {
-            var key = scope.getKey(this.name);
-
-            if (key instanceof String) target.add(Instruction.makeVar((String)key).locate(loc()));
-            target.add(Instruction.storeVar(scope.getKey(this.name), true).locate(loc()));
-        }
-    }
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        compile(target, scope, null, false);
+        return id;
    }

-    public FunctionStatement(Location loc, String name, String[] args, CompoundStatement body) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, String name, BreakpointType bp) {
+        if (this.varName != null) name = this.varName;
+
+        var hasVar = this.varName != null && statement;
+        var hasName = name != null;
+
+        compileBody(target, scope, pollute || hasVar || hasName, bp);
+
+        if (hasName) {
+            if (pollute || hasVar) target.add(Instruction.dup(loc()));
+            target.add(Instruction.loadValue(loc(), "name"));
+            target.add(Instruction.loadValue(loc(), name));
+            target.add(Instruction.storeMember(loc()));
+        }
+
+        if (hasVar) {
+            var key = scope.getKey(this.varName);
+
+            if (key instanceof String) target.add(Instruction.makeVar(loc(), (String)key));
+            target.add(Instruction.storeVar(loc(), scope.getKey(this.varName), false));
+        }
+    }
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, String name) {
+        compile(target, scope, pollute, name, BreakpointType.NONE);
+    }
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType bp) {
+        compile(target, scope, pollute, (String)null, bp);
+    }
+    @Override public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, pollute, (String)null, BreakpointType.NONE);
+    }
+
+    public FunctionStatement(Location loc, Location end, String varName, String[] args, boolean statement, CompoundStatement body) {
        super(loc);
-        this.name = name;
+
+        this.end = end;
+        this.varName = varName;
+        this.statement = statement;

        this.args = args;
        this.body = body;
    }
+
+    public static void compileWithName(Statement stm, CompileTarget target, ScopeRecord scope, boolean pollute, String name) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, scope, pollute, name);
+        else stm.compile(target, scope, pollute);
+    }
+    public static void compileWithName(Statement stm, CompileTarget target, ScopeRecord scope, boolean pollute, String name, BreakpointType bp) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, scope, pollute, name, bp);
+        else stm.compile(target, scope, pollute, bp);
+    }
 }
--- a/src/me/topchetoeu/jscript/compilation/values/GlobalThisStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/GlobalThisStatement.java
@@ -1,21 +1,17 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public class GlobalThisStatement extends Statement {
-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    @Override public boolean pure() { return true; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadGlob().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        if (pollute) target.add(Instruction.loadGlob(loc()));
    }

    public GlobalThisStatement(Location loc) {
--- a/src/me/topchetoeu/jscript/compilation/values/IndexAssignStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/IndexAssignStatement.java
@@ -1,51 +1,41 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.AssignStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

-public class IndexAssignStatement extends AssignStatement {
+public class IndexAssignStatement extends Statement {
    public final Statement object;
    public final Statement index;
    public final Statement value;
    public final Operation operation;

    @Override
-    public boolean pollutesStack() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope, boolean retPrevValue) {
-        int start = 0;
-
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        if (operation != null) {
-            object.compileWithPollution(target, scope);
-            index.compileWithPollution(target, scope);
-            target.add(Instruction.dup(2, 0).locate(loc()));
+            object.compile(target, scope, true);
+            index.compile(target, scope, true);
+            target.add(Instruction.dup(loc(), 2));

-            target.add(Instruction.loadMember().locate(loc()));
-            if (retPrevValue) {
-                target.add(Instruction.dup().locate(loc()));
-                target.add(Instruction.move(3, 1).locate(loc()));
-            }
-            value.compileWithPollution(target, scope);
-            target.add(Instruction.operation(operation).locate(loc()));
+            target.add(Instruction.loadMember(loc()));
+            value.compile(target, scope, true);
+            target.add(Instruction.operation(loc(), operation));

-            target.add(Instruction.storeMember(!retPrevValue).locate(loc()).setDebug(true));
+            target.add(Instruction.storeMember(loc(), pollute));
+            target.setDebug(BreakpointType.STEP_IN);
        }
        else {
-            object.compileWithPollution(target, scope);
-            if (retPrevValue) target.add(Instruction.dup().locate(loc()));
-            index.compileWithPollution(target, scope);
-            value.compileWithPollution(target, scope);
+            object.compile(target, scope, true);
+            index.compile(target, scope, true);
+            value.compile(target, scope, true);

-            target.add(Instruction.storeMember(!retPrevValue).locate(loc()).setDebug(true));
+            target.add(Instruction.storeMember(loc(), pollute));
+            target.setDebug(BreakpointType.STEP_IN);
        }
-        target.get(start);
    }

    public IndexAssignStatement(Location loc, Statement object, Statement index, Statement value, Operation operation) {
--- a/src/me/topchetoeu/jscript/compilation/values/IndexStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/IndexStatement.java
@@ -1,12 +1,11 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.AssignStatement;
 import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.Instruction.BreakpointType;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

@@ -15,30 +14,26 @@ public class IndexStatement extends AssignableStatement {
    public final Statement index;

    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
-
-    @Override
-    public AssignStatement toAssign(Statement val, Operation operation) {
+    public Statement toAssign(Statement val, Operation operation) {
        return new IndexAssignStatement(loc(), object, index, val, operation);
    }
-    public void compile(List<Instruction> target, ScopeRecord scope, boolean dupObj) {
-        int start = 0;
-        object.compileWithPollution(target, scope);
-        if (dupObj) target.add(Instruction.dup().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean dupObj, boolean pollute) {
+        object.compile(target, scope, true);
+        if (dupObj) target.add(Instruction.dup(loc()));
        if (index instanceof ConstantStatement) {
-            target.add(Instruction.loadMember(((ConstantStatement)index).value).locate(loc()));
+            target.add(Instruction.loadMember(loc(), ((ConstantStatement)index).value));
+            target.setDebug(BreakpointType.STEP_IN);
            return;
        }

-        index.compileWithPollution(target, scope);
-        target.add(Instruction.loadMember().locate(loc()));
-        target.get(start).setDebug(true);
+        index.compile(target, scope, true);
+        target.add(Instruction.loadMember(loc()));
+        target.setDebug(BreakpointType.STEP_IN);
+        if (!pollute) target.add(Instruction.discard(loc()));
    }
    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        compile(target, scope, false);
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        compile(target, scope, false, pollute);
    }

    public IndexStatement(Location loc, Statement object, Statement index) {
--- a/src/me/topchetoeu/jscript/compilation/values/LazyAndStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/LazyAndStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,30 +10,25 @@ import me.topchetoeu.jscript.engine.values.Values;
 public class LazyAndStatement extends Statement {
    public final Statement first, second;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() {
-        return first.pure() && second.pure();
-    }
+    @Override public boolean pure() { return first.pure() && second.pure(); }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        if (first instanceof ConstantStatement) {
            if (Values.not(((ConstantStatement)first).value)) {
-                first.compileWithPollution(target, scope);
+                first.compile(target, scope, pollute);
            }
-            else second.compileWithPollution(target, scope);
+            else second.compile(target, scope, pollute);
            return;
        }

-        first.compileWithPollution(target, scope);
-        target.add(Instruction.dup().locate(loc()));
+        first.compile(target, scope, true);
+        if (pollute) target.add(Instruction.dup(loc()));
        int start = target.size();
-        target.add(Instruction.nop());
-        target.add(Instruction.discard().locate(loc()));
-        second.compileWithPollution(target, scope);
-        target.set(start, Instruction.jmpIfNot(target.size() - start).locate(loc()));
+        target.add(Instruction.nop(null));
+        if (pollute) target.add(Instruction.discard(loc()));
+        second.compile(target, scope, pollute);
+        target.set(start, Instruction.jmpIfNot(loc(), target.size() - start));
    }

    public LazyAndStatement(Location loc, Statement first, Statement second) {
--- a/src/me/topchetoeu/jscript/compilation/values/LazyOrStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/LazyOrStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -11,30 +10,25 @@ import me.topchetoeu.jscript.engine.values.Values;
 public class LazyOrStatement extends Statement {
    public final Statement first, second;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() {
-        return first.pure() && second.pure();
-    }
+    @Override public boolean pure() { return first.pure() && second.pure(); }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        if (first instanceof ConstantStatement) {
            if (Values.not(((ConstantStatement)first).value)) {
-                second.compileWithPollution(target, scope);
+                second.compile(target, scope, pollute);
            }
-            else first.compileWithPollution(target, scope);
+            else first.compile(target, scope, pollute);
            return;
        }

-        first.compileWithPollution(target, scope);
-        target.add(Instruction.dup().locate(loc()));
+        first.compile(target, scope, true);
+        if (pollute) target.add(Instruction.dup(loc()));
        int start = target.size();
-        target.add(Instruction.nop());
-        target.add(Instruction.discard().locate(loc()));
-        second.compileWithPollution(target, scope);
-        target.set(start, Instruction.jmpIf(target.size() - start).locate(loc()));
+        target.add(Instruction.nop(null));
+        if (pollute) target.add(Instruction.discard(loc()));
+        second.compile(target, scope, pollute);
+        target.set(start, Instruction.jmpIf(loc(), target.size() - start));
    }

    public LazyOrStatement(Location loc, Statement first, Statement second) {
--- a/src/me/topchetoeu/jscript/compilation/values/NewStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/NewStatement.java
@@ -1,32 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-
-public class NewStatement extends Statement {
-    public final Statement func;
-    public final Statement[] args;
-
-    @Override
-    public boolean pollutesStack() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        func.compileWithPollution(target, scope);
-        for (var arg : args) {
-            arg.compileWithPollution(target, scope);
-        }
-
-        target.add(Instruction.callNew(args.length).locate(loc()).setDebug(true));
-    }
-
-    public NewStatement(Location loc, Statement func, Statement ...args) {
-        super(loc);
-        this.func = func;
-        this.args = args;
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/values/ObjectStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/ObjectStatement.java
@@ -1,10 +1,10 @@
 package me.topchetoeu.jscript.compilation.values;

 import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -14,20 +14,24 @@ public class ObjectStatement extends Statement {
    public final Map<Object, FunctionStatement> getters;
    public final Map<Object, FunctionStatement> setters;

-    @Override
-    public boolean pollutesStack() { return true; }
+    @Override public boolean pure() {
+        for (var el : map.values()) {
+            if (!el.pure()) return false;
+        }
+
+        return true;
+    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadObj().locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.loadObj(loc()));

        for (var el : map.entrySet()) {
-            target.add(Instruction.dup().locate(loc()));
-            target.add(Instruction.loadValue(el.getKey()).locate(loc()));
+            target.add(Instruction.dup(loc()));
+            target.add(Instruction.loadValue(loc(), el.getKey()));
            var val = el.getValue();
-            if (val instanceof FunctionStatement) ((FunctionStatement)val).compile(target, scope, el.getKey().toString(), false);
-            else val.compileWithPollution(target, scope);
-            target.add(Instruction.storeMember().locate(loc()));
+            FunctionStatement.compileWithName(val, target, scope, true, el.getKey().toString());
+            target.add(Instruction.storeMember(loc()));
        }

        var keys = new ArrayList<Object>();
@@ -35,17 +39,19 @@ public class ObjectStatement extends Statement {
        keys.addAll(setters.keySet());

        for (var key : keys) {
-            if (key instanceof String) target.add(Instruction.loadValue((String)key).locate(loc()));
-            else target.add(Instruction.loadValue((Double)key).locate(loc()));
+            if (key instanceof String) target.add(Instruction.loadValue(loc(), (String)key));
+            else target.add(Instruction.loadValue(loc(), (Double)key));

-            if (getters.containsKey(key)) getters.get(key).compileWithPollution(target, scope);
-            else target.add(Instruction.loadValue(null).locate(loc()));
+            if (getters.containsKey(key)) getters.get(key).compile(target, scope, true);
+            else target.add(Instruction.loadValue(loc(), null));

-            if (setters.containsKey(key)) setters.get(key).compileWithPollution(target, scope);
-            else target.add(Instruction.loadValue(null).locate(loc()));
+            if (setters.containsKey(key)) setters.get(key).compile(target, scope, true);
+            else target.add(Instruction.loadValue(loc(), null));

-            target.add(Instruction.defProp().locate(loc()));
+            target.add(Instruction.defProp(loc()));
        }
+
+        if (!pollute) target.add(Instruction.discard(loc()));
    }

    public ObjectStatement(Location loc, Map<Object, Statement> map, Map<Object, FunctionStatement> getters, Map<Object, FunctionStatement> setters) {
--- a/src/me/topchetoeu/jscript/compilation/values/OperationStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/OperationStatement.java
@@ -1,66 +1,32 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.control.ThrowStatement;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
-import me.topchetoeu.jscript.exceptions.EngineException;

 public class OperationStatement extends Statement {
    public final Statement[] args;
    public final Operation operation;

-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        for (var arg : args) {
-            arg.compileWithPollution(target, scope);
+    @Override public boolean pure() {
+        for (var el : args) {
+            if (!el.pure()) return false;
        }
-        target.add(Instruction.operation(operation).locate(loc()));
-    }

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() {
-        for (var arg : args) {
-            if (!arg.pure()) return false;
-        }
        return true;
    }

    @Override
-    public Statement optimize() {
-        var args = new Statement[this.args.length];
-        var allConst = true;
-
-        for (var i = 0; i < this.args.length; i++) {
-            args[i] = this.args[i].optimize();
-            if (!(args[i] instanceof ConstantStatement)) allConst = false;
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        for (var arg : args) {
+            arg.compile(target, scope, true);
        }

-        if (allConst) {
-            var vals = new Object[this.args.length];
-
-            for (var i = 0; i < args.length; i++) {
-                vals[i] = ((ConstantStatement)args[i]).value;
-            }
-
-            try {
-                return new ConstantStatement(loc(), Values.operation(null, operation, vals));
-            }
-            catch (EngineException e) {
-                return new ThrowStatement(loc(), new ConstantStatement(loc(), e.value));
-            }
-            catch (InterruptedException e) { return null; }
-        }
-
-        return new OperationStatement(loc(), operation, args);
-
+        if (pollute) target.add(Instruction.operation(loc(), operation));
+        else target.add(Instruction.discard(loc()));
    }

    public OperationStatement(Location loc, Operation operation, Statement ...args) {
--- a/src/me/topchetoeu/jscript/compilation/values/RegexStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/RegexStatement.java
@@ -1,8 +1,7 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
@@ -10,14 +9,13 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class RegexStatement extends Statement {
    public final String pattern, flags;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    // Not really pure, since a function is called, but can be ignored.
+    @Override public boolean pure() { return true; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadRegex(pattern, flags).locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        target.add(Instruction.loadRegex(loc(), pattern, flags));
+        if (!pollute) target.add(Instruction.discard(loc()));
    }

    public RegexStatement(Location loc, String pattern, String flags) {
--- a/src/me/topchetoeu/jscript/compilation/values/TernaryStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/TernaryStatement.java
@@ -1,58 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Instruction;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;
-
-public class TernaryStatement extends Statement {
-    public final Statement condition;
-    public final Statement first;
-    public final Statement second;
-
-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (condition instanceof ConstantStatement) {
-            if (!Values.toBoolean(((ConstantStatement)condition).value)) {
-                second.compileWithPollution(target, scope);
-            }
-            else first.compileWithPollution(target, scope);
-            return;
-        }
-
-        condition.compileWithPollution(target, scope);
-        int start = target.size();
-        target.add(Instruction.nop());
-        first.compileWithPollution(target, scope);
-        int mid = target.size();
-        target.add(Instruction.nop());
-        second.compileWithPollution(target, scope);
-        int end = target.size();
-
-        target.set(start, Instruction.jmpIfNot(mid - start + 1).locate(loc()));
-        target.set(mid, Instruction.jmp(end - mid).locate(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        var cond = condition.optimize();
-        var f = first.optimize();
-        var s = second.optimize();
-        return new TernaryStatement(loc(), cond, f, s);
-    }
-
-    public TernaryStatement(Location loc, Statement condition, Statement first, Statement second) {
-        super(loc);
-        this.condition = condition;
-        this.first = first;
-        this.second = second;
-    }
-}
--- a/src/me/topchetoeu/jscript/compilation/values/TypeofStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/TypeofStatement.java
@@ -1,49 +1,29 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.engine.values.Values;

 public class TypeofStatement extends Statement {
    public final Statement value;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    // Not really pure, since a variable from the global scope could be accessed,
+    // which could lead to code execution, that would get omitted
+    @Override public boolean pure() { return true; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        if (value instanceof VariableStatement) {
            var i = scope.getKey(((VariableStatement)value).name);
            if (i instanceof String) {
-                target.add(Instruction.typeof((String)i).locate(loc()));
+                target.add(Instruction.typeof(loc(), (String)i));
                return;
            }
        }
-        value.compileWithPollution(target, scope);
-        target.add(Instruction.typeof().locate(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        var val = value.optimize();
-
-        if (val instanceof ConstantStatement) {
-            return new ConstantStatement(loc(), Values.type(((ConstantStatement)val).value));
-        }
-        else if (
-            val instanceof ObjectStatement ||
-            val instanceof ArrayStatement ||
-            val instanceof GlobalThisStatement
-        ) return new ConstantStatement(loc(), "object");
-        else if(val instanceof FunctionStatement) return new ConstantStatement(loc(), "function");
-
-        return new TypeofStatement(loc(), val);
+        value.compile(target, scope, pollute);
+        target.add(Instruction.typeof(loc()));
    }

    public TypeofStatement(Location loc, Statement value) {
--- a/src/me/topchetoeu/jscript/compilation/values/VariableAssignStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/VariableAssignStatement.java
@@ -1,38 +1,31 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.compilation.AssignStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

-public class VariableAssignStatement extends AssignStatement {
+public class VariableAssignStatement extends Statement {
    public final String name;
    public final Statement value;
    public final Operation operation;

-    @Override
-    public boolean pollutesStack() { return true; }
+    @Override public boolean pure() { return false; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope, boolean retPrevValue) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        var i = scope.getKey(name);
        if (operation != null) {
-            target.add(Instruction.loadVar(i).locate(loc()));
-            if (retPrevValue) target.add(Instruction.dup().locate(loc()));
-            if (value instanceof FunctionStatement) ((FunctionStatement)value).compile(target, scope, name, false);
-            else value.compileWithPollution(target, scope);
-            target.add(Instruction.operation(operation).locate(loc()));
-            target.add(Instruction.storeVar(i, !retPrevValue).locate(loc()));
+            target.add(Instruction.loadVar(loc(), i));
+            FunctionStatement.compileWithName(value, target, scope, true, name);
+            target.add(Instruction.operation(loc(), operation));
+            target.add(Instruction.storeVar(loc(), i, pollute));
        }
        else {
-            if (retPrevValue) target.add(Instruction.loadVar(i).locate(loc()));
-            if (value instanceof FunctionStatement) ((FunctionStatement)value).compile(target, scope, name, false);
-            else value.compileWithPollution(target, scope);
-            target.add(Instruction.storeVar(i, !retPrevValue).locate(loc()));
+            FunctionStatement.compileWithName(value, target, scope, true, name);
+            target.add(Instruction.storeVar(loc(), i, pollute));
        }
    }

--- a/src/me/topchetoeu/jscript/compilation/values/VariableIndexStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/VariableIndexStatement.java
@@ -1,23 +1,19 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
 import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.scope.ScopeRecord;

 public class VariableIndexStatement extends Statement {
    public final int index;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    @Override public boolean pure() { return true; }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        target.add(Instruction.loadVar(index).locate(loc()));
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+        if (pollute) target.add(Instruction.loadVar(loc(), index));
    }

    public VariableIndexStatement(Location loc, int i) {
--- a/src/me/topchetoeu/jscript/compilation/values/VariableStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/VariableStatement.java
@@ -1,10 +1,8 @@
 package me.topchetoeu.jscript.compilation.values;

-import java.util.List;
-
 import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.AssignStatement;
 import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileTarget;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.compilation.Statement;
 import me.topchetoeu.jscript.engine.Operation;
@@ -13,20 +11,18 @@ import me.topchetoeu.jscript.engine.scope.ScopeRecord;
 public class VariableStatement extends AssignableStatement {
    public final String name;

-    @Override
-    public boolean pollutesStack() { return true; }
-    @Override
-    public boolean pure() { return true; }
+    @Override public boolean pure() { return false; }

    @Override
-    public AssignStatement toAssign(Statement val, Operation operation) {
+    public Statement toAssign(Statement val, Operation operation) {
        return new VariableAssignStatement(loc(), name, val, operation);
    }

    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
+    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
        var i = scope.getKey(name);
-        target.add(Instruction.loadVar(i).locate(loc()));
+        target.add(Instruction.loadVar(loc(), i));
+        if (!pollute) target.add(Instruction.discard(loc()));
    }

    public VariableStatement(Location loc, String name) {
--- a/src/me/topchetoeu/jscript/compilation/values/VoidStatement.java
+++ b/src/me/topchetoeu/jscript/compilation/values/VoidStatement.java
@@ -1,34 +0,0 @@
-package me.topchetoeu.jscript.compilation.values;
-
-import java.util.List;
-
-import me.topchetoeu.jscript.Location;
-import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.engine.scope.ScopeRecord;
-import me.topchetoeu.jscript.compilation.Instruction;
-
-public class VoidStatement extends Statement {
-    public final Statement value;
-
-    @Override
-    public boolean pollutesStack() { return true; }
-
-    @Override
-    public void compile(List<Instruction> target, ScopeRecord scope) {
-        if (value != null) value.compileNoPollution(target, scope);
-        target.add(Instruction.loadValue(null).locate(loc()));
-    }
-
-    @Override
-    public Statement optimize() {
-        if (value == null) return this;
-        var val = value.optimize();
-        if (val.pure()) return new ConstantStatement(loc(), null);
-        else return new VoidStatement(loc(), val);
-    }
-
-    public VoidStatement(Location loc, Statement value) {
-        super(loc);
-        this.value = value;
-    }
-}
--- a/src/me/topchetoeu/jscript/engine/Context.java
+++ b/src/me/topchetoeu/jscript/engine/Context.java
@@ -1,27 +1,125 @@
-package me.topchetoeu.jscript.engine;
-
-import me.topchetoeu.jscript.engine.values.FunctionValue;
-import me.topchetoeu.jscript.engine.values.Values;
-import me.topchetoeu.jscript.parsing.Parsing;
-
-public class Context {
-    public final Environment env;
-    public final Message message;
-
-    public FunctionValue compile(String filename, String raw) throws InterruptedException {
-        var res = Values.toString(this, env.compile.call(this, null, raw, filename));
-        return Parsing.compile(env, filename, res);
-    }
-
-    public Context setEnv(Environment env) {
-        return new Context(env, message);
-    }
-    public Context setMsg(Message msg) {
-        return new Context(env, msg);
-    }
-
-    public Context(Environment env, Message msg) {
-        this.env = env;
-        this.message = msg;
-    }
-}
+package me.topchetoeu.jscript.engine;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Stack;
+import java.util.TreeSet;
+import java.util.stream.Collectors;
+
+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
+import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.engine.values.Values;
+import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.mapping.SourceMap;
+
+public class Context {
+    private final Stack<Environment> env = new Stack<>();
+    private final ArrayList<CodeFrame> frames = new ArrayList<>();
+    public final Engine engine;
+
+    public Environment environment() {
+        return env.empty() ? null : env.peek();
+    }
+
+    public Context pushEnv(Environment env) {
+        this.env.push(env);
+        return this;
+    }
+    public void popEnv() {
+        if (!env.empty()) this.env.pop();
+    }
+
+    public FunctionValue compile(Filename filename, String raw) {
+        var env = environment();
+        var result = env.compile.call(this, null, raw, filename.toString(), env);
+
+        var function = (FunctionValue)Values.getMember(this, result, "function");
+        if (!engine.debugging) return function;
+
+        var rawMapChain = ((ArrayValue)Values.getMember(this, result, "mapChain")).toArray();
+        var breakpoints = new TreeSet<>(
+            Arrays.stream(((ArrayValue)Values.getMember(this, result, "breakpoints")).toArray())
+                .map(v -> Location.parse(Values.toString(this, v)))
+                .collect(Collectors.toList())
+        );
+        var maps = new SourceMap[rawMapChain.length];
+
+        for (var i = 0; i < maps.length; i++) maps[i] = SourceMap.parse(Values.toString(this, (String)rawMapChain[i]));
+
+        var map = SourceMap.chain(maps);
+
+        if (map != null) {
+            var newBreakpoints = new TreeSet<Location>();
+            for (var bp : breakpoints) {
+                bp = map.toCompiled(bp);
+                if (bp != null) newBreakpoints.add(bp);
+            }
+            breakpoints = newBreakpoints;
+        }
+
+        engine.onSource(filename, raw, breakpoints, map);
+
+        return function;
+    }
+
+
+    public void pushFrame(CodeFrame frame) {
+        frames.add(frame);
+        if (frames.size() > engine.maxStackFrames) throw EngineException.ofRange("Stack overflow!");
+        pushEnv(frame.function.environment);
+        engine.onFramePush(this, frame);
+    }
+    public boolean popFrame(CodeFrame frame) {
+        if (frames.size() == 0) return false;
+        if (frames.get(frames.size() - 1) != frame) return false;
+        frames.remove(frames.size() - 1);
+        popEnv();
+        engine.onFramePop(this, frame);
+        return true;
+    }
+    public CodeFrame peekFrame() {
+        if (frames.size() == 0) return null;
+        return frames.get(frames.size() - 1);
+    }
+
+    public List<CodeFrame> frames() {
+        return Collections.unmodifiableList(frames);
+    }
+    public List<String> stackTrace() {
+        var res = new ArrayList<String>();
+
+        for (var i = frames.size() - 1; i >= 0; i--) {
+            var el = frames.get(i);
+            var name = el.function.name;
+            Location loc = null;
+
+            for (var j = el.codePtr; j >= 0 && loc == null; j--) loc = el.function.body[j].location;
+            if (loc == null) loc = el.function.loc();
+
+            var trace = "";
+
+            if (loc != null) trace += "at " + loc.toString() + " ";
+            if (name != null && !name.equals("")) trace += "in " + name + " ";
+
+            trace = trace.trim();
+
+            if (!trace.equals("")) res.add(trace);
+        }
+
+        return res;
+    }
+
+    public Context(Engine engine) {
+        this.engine = engine;
+    }
+    public Context(Engine engine, Environment env) {
+        this(engine);
+        this.pushEnv(env);
+        
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/Data.java
+++ b/src/me/topchetoeu/jscript/engine/Data.java
@@ -1,43 +1,44 @@
 package me.topchetoeu.jscript.engine;

 import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map.Entry;
+import java.util.Map;

@SuppressWarnings("unchecked")
-public class Data implements Iterable<Entry<DataKey<?>, ?>> {
+public class Data {
    private HashMap<DataKey<Object>, Object> data = new HashMap<>();

    public Data copy() {
        return new Data().addAll(this);
    }

-    public Data addAll(Iterable<Entry<DataKey<?>, ?>> data) {
-        for (var el : data) {
-            add((DataKey<Object>)el.getKey(), (Object)el.getValue());
+    public Data addAll(Map<DataKey<?>, ?> data) {
+        for (var el : data.entrySet()) {
+            get((DataKey<Object>)el.getKey(), (Object)el.getValue());
+        }
+        return this;
+    }
+    public Data addAll(Data data) {
+        for (var el : data.data.entrySet()) {
+            get((DataKey<Object>)el.getKey(), (Object)el.getValue());
        }
        return this;
    }

+    public <T> T remove(DataKey<T> key) {
+        return (T)data.remove(key);
+    }
    public <T> Data set(DataKey<T> key, T val) {
-        if (val == null) data.remove(key);
-        else data.put((DataKey<Object>)key, (Object)val);
+        data.put((DataKey<Object>)key, (Object)val);
        return this;
    }
-    public <T> T add(DataKey<T> key, T val) {
-        if (data.containsKey(key)) return (T)data.get(key);
-        else {
-            if (val == null) data.remove(key);
-            else data.put((DataKey<Object>)key, (Object)val);
-            return val;
-        }
+    public <T> T get(DataKey<T> key, T val) {
+        if (data.containsKey(key)) return (T)data.get((DataKey<Object>)key);
+        set(key, val);
+        return val;
    }
    public <T> T get(DataKey<T> key) {
-        return get(key, null);
-    }
-    public <T> T get(DataKey<T> key, T defaultVal) {
-        if (!has(key)) return defaultVal;
-        else return (T)data.get(key);
+        if (data.containsKey(key)) return (T)data.get((DataKey<Object>)key);
+        return null;
    }
    public boolean has(DataKey<?> key) { return data.containsKey(key); }

@@ -52,9 +53,4 @@ public class Data implements Iterable<Entry<DataKey<?>, ?>> {
    public int increase(DataKey<Integer> key) {
        return increase(key, 1, 0);
    }
-
-    @Override
-    public Iterator<Entry<DataKey<?>, ?>> iterator() {
-        return (Iterator<Entry<DataKey<?>, ?>>)data.entrySet();
-    }
 }
--- a/src/me/topchetoeu/jscript/engine/Engine.java
+++ b/src/me/topchetoeu/jscript/engine/Engine.java
@@ -1,84 +1,123 @@
 package me.topchetoeu.jscript.engine;

-import java.util.concurrent.LinkedBlockingDeque;
+import java.util.HashMap;
+import java.util.TreeSet;
+import java.util.concurrent.PriorityBlockingQueue;

+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.FunctionBody;
+import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.engine.debug.DebugController;
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
 import me.topchetoeu.jscript.engine.values.FunctionValue;
 import me.topchetoeu.jscript.events.Awaitable;
 import me.topchetoeu.jscript.events.DataNotifier;
 import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.exceptions.InterruptException;
+import me.topchetoeu.jscript.mapping.SourceMap;

-public class Engine {
+public class Engine implements DebugController {
    private class UncompiledFunction extends FunctionValue {
-        public final String filename;
+        public final Filename filename;
        public final String raw;
-        public final Environment env;
+        private FunctionValue compiled = null;

        @Override
-        public Object call(Context ctx, Object thisArg, Object ...args) throws InterruptedException {
-            ctx = ctx.setEnv(env);
-            return ctx.compile(filename, raw).call(ctx, thisArg, args);
+        public Object call(Context ctx, Object thisArg, Object ...args) {
+            if (compiled == null) compiled = ctx.compile(filename, raw);
+            return compiled.call(ctx, thisArg, args);
        }

-        public UncompiledFunction(Environment env, String filename, String raw) {
-            super(filename, 0);
+        public UncompiledFunction(Filename filename, String raw) {
+            super(filename + "", 0);
            this.filename = filename;
            this.raw = raw;
-            this.env = env; 
        }
    }

-    private static class Task {
+    private static class Task implements Comparable<Task> {
        public final FunctionValue func;
        public final Object thisArg;
        public final Object[] args;
        public final DataNotifier<Object> notifier = new DataNotifier<>();
-        public final Message msg;
+        public final Context ctx;
+        public final boolean micro;

-        public Task(Message ctx, FunctionValue func, Object thisArg, Object[] args) {
-            this.msg = ctx;
+        public Task(Context ctx, FunctionValue func, Object thisArg, Object[] args, boolean micro) {
+            this.ctx = ctx;
            this.func = func;
            this.thisArg = thisArg;
            this.args = args;
+            this.micro = micro;
+        }
+
+        @Override
+        public int compareTo(Task other) {
+            return Integer.compare(this.micro ? 0 : 1, other.micro ? 0 : 1);
        }
    }

    private static int nextId = 0;
-
-    private Thread thread;
-    private LinkedBlockingDeque<Task> macroTasks = new LinkedBlockingDeque<>();
-    private LinkedBlockingDeque<Task> microTasks = new LinkedBlockingDeque<>();
+    public static final HashMap<Long, FunctionBody> functions = new HashMap<>();

    public final int id = ++nextId;
+    public final boolean debugging;
+    public int maxStackFrames = 10000;

-    private void runTask(Task task) throws InterruptedException {
+    private final HashMap<Filename, String> sources = new HashMap<>();
+    private final HashMap<Filename, TreeSet<Location>> bpts = new HashMap<>();
+    private final HashMap<Filename, SourceMap> maps = new HashMap<>();
+
+    public Location mapToCompiled(Location location) {
+        var map = maps.get(location.filename());
+        if (map == null) return location;
+        return map.toCompiled(location);
+    }
+    public Location mapToOriginal(Location location) {
+        var map = maps.get(location.filename());
+        if (map == null) return location;
+        return map.toOriginal(location);
+    }
+
+    private DebugController debugger;
+    private Thread thread;
+    private PriorityBlockingQueue<Task> tasks = new PriorityBlockingQueue<>();
+
+    public synchronized boolean attachDebugger(DebugController debugger) {
+        if (!debugging || this.debugger != null) return false;
+
+        for (var source : sources.entrySet()) debugger.onSource(
+            source.getKey(), source.getValue(),
+            bpts.get(source.getKey()),
+            maps.get(source.getKey())
+        );
+
+        this.debugger = debugger;
+        return true;
+    }
+    public synchronized boolean detachDebugger() {
+        if (!debugging || this.debugger == null) return false;
+        this.debugger = null;
+        return true;
+    }
+
+    private void runTask(Task task) {
        try {
-            task.notifier.next(task.func.call(task.msg.context(null), task.thisArg, task.args));
-        }
-        catch (InterruptedException e) {
-            task.notifier.error(new RuntimeException(e));
-            throw e;
-        }
-        catch (EngineException e) {
-            task.notifier.error(e);
+            task.notifier.next(task.func.call(task.ctx, task.thisArg, task.args));
        }
        catch (RuntimeException e) {
+            if (e instanceof InterruptException) throw e;
            task.notifier.error(e);
-            e.printStackTrace();
        }
    }
-    private void run() {
-        while (true) {
+    public void run(boolean untilEmpty) {
+        while (!untilEmpty || !tasks.isEmpty()) {
            try {
-                runTask(macroTasks.take());
-
-                while (!microTasks.isEmpty()) {
-                    runTask(microTasks.take());
-                }
+                runTask(tasks.take());
            }
-            catch (InterruptedException e) {
-                for (var msg : macroTasks) {
-                    msg.notifier.error(new RuntimeException(e));
-                }
+            catch (InterruptedException | InterruptException e) {
+                for (var msg : tasks) msg.notifier.error(new InterruptException(e));
                break;
            }
        }
@@ -86,7 +125,7 @@ public class Engine {

    public Thread start() {
        if (this.thread == null) {
-            this.thread = new Thread(this::run, "JavaScript Runner #" + id);
+            this.thread = new Thread(() -> run(false), "JavaScript Runner #" + id);
            this.thread.start();
        }
        return this.thread;
@@ -98,21 +137,39 @@ public class Engine {
    public boolean inExecThread() {
        return Thread.currentThread() == thread;
    }
-    public boolean isRunning() {
+    public synchronized boolean isRunning() {
        return this.thread != null;
    }

-    public Awaitable<Object> pushMsg(boolean micro, Message ctx, FunctionValue func, Object thisArg, Object ...args) {
-        var msg = new Task(ctx, func, thisArg, args);
-        if (micro) microTasks.addLast(msg);
-        else macroTasks.addLast(msg);
+    public Awaitable<Object> pushMsg(boolean micro, Context ctx, FunctionValue func, Object thisArg, Object ...args) {
+        var msg = new Task(ctx == null ? new Context(this) : ctx, func, thisArg, args, micro);
+        tasks.add(msg);
        return msg.notifier;
    }
-    public Awaitable<Object> pushMsg(boolean micro, Context ctx, String filename, String raw, Object thisArg, Object ...args) {
-        return pushMsg(micro, ctx.message, new UncompiledFunction(ctx.env, filename, raw), thisArg, args);
+    public Awaitable<Object> pushMsg(boolean micro, Context ctx, Filename filename, String raw, Object thisArg, Object ...args) {
+        return pushMsg(micro, ctx, new UncompiledFunction(filename, raw), thisArg, args);
    }

-    // public Engine() {
-    //     this.typeRegister = new NativeTypeRegister();
-    // }
+    @Override
+    public void onFramePush(Context ctx, CodeFrame frame) {
+        if (debugging && debugger != null) debugger.onFramePush(ctx, frame);
+    }
+    @Override public void onFramePop(Context ctx, CodeFrame frame) {
+        if (debugging && debugger != null) debugger.onFramePop(ctx, frame);
+    }
+    @Override public boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught) {
+        if (debugging && debugger != null) return debugger.onInstruction(ctx, frame, instruction, returnVal, error, caught);
+        else return false;
+    }
+    @Override public void onSource(Filename filename, String source, TreeSet<Location> breakpoints, SourceMap map) {
+        if (!debugging) return;
+        if (debugger != null) debugger.onSource(filename, source, breakpoints, map);
+        sources.put(filename, source);
+        bpts.put(filename, breakpoints);
+        maps.put(filename, map);
+    }
+
+    public Engine(boolean debugging) {
+        this.debugging = debugging;
+    }
 }
--- a/src/me/topchetoeu/jscript/engine/Environment.java
+++ b/src/me/topchetoeu/jscript/engine/Environment.java
@@ -1,84 +1,131 @@
-package me.topchetoeu.jscript.engine;
-
-import java.util.HashMap;
-
-import me.topchetoeu.jscript.engine.scope.GlobalScope;
-import me.topchetoeu.jscript.engine.values.FunctionValue;
-import me.topchetoeu.jscript.engine.values.NativeFunction;
-import me.topchetoeu.jscript.engine.values.ObjectValue;
-import me.topchetoeu.jscript.engine.values.Symbol;
-import me.topchetoeu.jscript.exceptions.EngineException;
-import me.topchetoeu.jscript.interop.Native;
-import me.topchetoeu.jscript.interop.NativeGetter;
-import me.topchetoeu.jscript.interop.NativeSetter;
-import me.topchetoeu.jscript.interop.NativeWrapperProvider;
-
-public class Environment {
-    private HashMap<String, ObjectValue> prototypes = new HashMap<>();
-
-    public final Data data = new Data();
-    public final HashMap<String, Symbol> symbols = new HashMap<>();
-
-    public GlobalScope global;
-    public WrappersProvider wrappersProvider;
-
-    @Native public FunctionValue compile;
-    @Native public FunctionValue regexConstructor = new NativeFunction("RegExp", (ctx, thisArg, args) -> {
-        throw EngineException.ofError("Regular expressions not supported.").setContext(ctx);
-    });
-
-    public Environment addData(Data data) {
-        this.data.addAll(data);
-        return this;
-    }
-
-    @Native public ObjectValue proto(String name) {
-        return prototypes.get(name);
-    }
-    @Native public void setProto(String name, ObjectValue val) {
-        prototypes.put(name, val);
-    }
-
-    @Native public Symbol symbol(String name) {
-        if (symbols.containsKey(name))
-            return symbols.get(name);
-        else {
-            var res = new Symbol(name);
-            symbols.put(name, res);
-            return res;
-        }
-    }
-
-    @NativeGetter("global") public ObjectValue getGlobal() {
-        return global.obj;
-    }
-    @NativeSetter("global") public void setGlobal(ObjectValue val) {
-        global = new GlobalScope(val);
-    }
-
-    @Native public Environment fork() {
-        var res = new Environment(compile, wrappersProvider, global);
-        res.regexConstructor = regexConstructor;
-        res.prototypes = new HashMap<>(prototypes);
-        return res;
-    }
-    @Native public Environment child() {
-        var res = fork();
-        res.global = res.global.globalChild();
-        return res;
-    }
-
-    public Context context(Message msg) {
-        return new Context(this, msg);
-    }
-
-    public Environment(FunctionValue compile, WrappersProvider nativeConverter, GlobalScope global) {
-        if (compile == null) compile = new NativeFunction("compile", (ctx, thisArg, args) -> args.length == 0 ? "" : args[0]);
-        if (nativeConverter == null) nativeConverter = new NativeWrapperProvider(this);
-        if (global == null) global = new GlobalScope();
-
-        this.wrappersProvider = nativeConverter;
-        this.compile = compile;
-        this.global = global;
-    }
-}
+package me.topchetoeu.jscript.engine;
+
+import java.util.HashMap;
+import java.util.stream.Collectors;
+
+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.engine.scope.GlobalScope;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
+import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.engine.values.NativeFunction;
+import me.topchetoeu.jscript.engine.values.ObjectValue;
+import me.topchetoeu.jscript.engine.values.Symbol;
+import me.topchetoeu.jscript.engine.values.Values;
+import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.filesystem.RootFilesystem;
+import me.topchetoeu.jscript.interop.Native;
+import me.topchetoeu.jscript.interop.NativeGetter;
+import me.topchetoeu.jscript.interop.NativeSetter;
+import me.topchetoeu.jscript.interop.NativeWrapperProvider;
+import me.topchetoeu.jscript.parsing.Parsing;
+import me.topchetoeu.jscript.permissions.Permission;
+import me.topchetoeu.jscript.permissions.PermissionsProvider;
+
+public class Environment implements PermissionsProvider {
+    private HashMap<String, ObjectValue> prototypes = new HashMap<>();
+
+    public final Data data = new Data();
+    public static final HashMap<String, Symbol> symbols = new HashMap<>();
+
+    public GlobalScope global;
+    public WrappersProvider wrappers;
+    public PermissionsProvider permissions = null;
+    public final RootFilesystem filesystem = new RootFilesystem(this);
+
+    private static int nextId = 0;
+
+    @Native public boolean stackVisible = true;
+    @Native public int id = ++nextId;
+
+    @Native public FunctionValue compile = new NativeFunction("compile", (ctx, thisArg, args) -> {
+        var source = Values.toString(ctx, args[0]);
+        var filename = Values.toString(ctx, args[1]);
+        var isDebug = Values.toBoolean(args[2]);
+
+        var env = Values.wrapper(args[2], Environment.class);
+        var res = new ObjectValue();
+
+        var target = Parsing.compile(env, Filename.parse(filename), source);
+        Engine.functions.putAll(target.functions);
+        Engine.functions.remove(0l);
+
+        res.defineProperty(ctx, "function", target.func(env));
+        res.defineProperty(ctx, "mapChain", new ArrayValue());
+
+
+        if (isDebug) {
+            res.defineProperty(ctx, "breakpoints", ArrayValue.of(ctx, target.breakpoints.stream().map(Location::toString).collect(Collectors.toList())));
+        }
+
+        return res;
+    });
+    @Native public FunctionValue regexConstructor = new NativeFunction("RegExp", (ctx, thisArg, args) -> {
+        throw EngineException.ofError("Regular expressions not supported.").setCtx(ctx.environment(), ctx.engine);
+    });
+
+    public Environment addData(Data data) {
+        this.data.addAll(data);
+        return this;
+    }
+
+    @Native public ObjectValue proto(String name) {
+        return prototypes.get(name);
+    }
+    @Native public void setProto(String name, ObjectValue val) {
+        prototypes.put(name, val);
+    }
+
+    @Native public Symbol symbol(String name) {
+        return getSymbol(name);
+    }
+
+    @NativeGetter("global") public ObjectValue getGlobal() {
+        return global.obj;
+    }
+    @NativeSetter("global") public void setGlobal(ObjectValue val) {
+        global = new GlobalScope(val);
+    }
+
+    @Native public Environment fork() {
+        var res = new Environment(compile, null, global);
+        res.wrappers = wrappers.fork(res);
+        res.regexConstructor = regexConstructor;
+        res.prototypes = new HashMap<>(prototypes);
+        return res;
+    }
+    @Native public Environment child() {
+        var res = fork();
+        res.global = res.global.globalChild();
+        return res;
+    }
+
+    @Override public boolean hasPermission(Permission perm, char delim) {
+        return permissions == null || permissions.hasPermission(perm, delim);
+    }
+    @Override public boolean hasPermission(Permission perm) {
+        return permissions == null || permissions.hasPermission(perm);
+    }
+
+    public Context context(Engine engine) {
+        return new Context(engine).pushEnv(this);
+    }
+
+    public static Symbol getSymbol(String name) {
+        if (symbols.containsKey(name)) return symbols.get(name);
+        else {
+            var res = new Symbol(name);
+            symbols.put(name, res);
+            return res;
+        }
+    }
+
+    public Environment(FunctionValue compile, WrappersProvider nativeConverter, GlobalScope global) {
+        if (compile != null) this.compile = compile;
+        if (nativeConverter == null) nativeConverter = new NativeWrapperProvider(this);
+        if (global == null) global = new GlobalScope();
+
+        this.wrappers = nativeConverter;
+        this.global = global;
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/Message.java
+++ b/src/me/topchetoeu/jscript/engine/Message.java
@@ -1,63 +0,0 @@
-package me.topchetoeu.jscript.engine;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-import me.topchetoeu.jscript.engine.frame.CodeFrame;
-import me.topchetoeu.jscript.exceptions.EngineException;
-
-public class Message {
-    public final Engine engine;
-
-    private final ArrayList<CodeFrame> frames = new ArrayList<>();
-    public int maxStackFrames = 1000;
-
-    public final Data data = new Data();
-
-    public List<CodeFrame> frames() { return Collections.unmodifiableList(frames); }
-
-    public Message addData(Data data) {
-        this.data.addAll(data);
-        return this;
-    }
-
-    public Message pushFrame(Context ctx, CodeFrame frame) throws InterruptedException {
-        this.frames.add(frame);
-        if (this.frames.size() > maxStackFrames) throw EngineException.ofRange("Stack overflow!");
-        return this;
-    }
-    public boolean popFrame(CodeFrame frame) {
-        if (this.frames.size() == 0) return false;
-        if (this.frames.get(this.frames.size() - 1) != frame) return false;
-        this.frames.remove(this.frames.size() - 1);
-        return true;
-    }
-
-    public List<String> stackTrace() {
-        var res = new ArrayList<String>();
-
-        for (var el : frames) {
-            var name = el.function.name;
-            var loc = el.function.loc();
-            var trace = "";
-
-            if (loc != null) trace += "at " + loc.toString() + " ";
-            if (name != null && !name.equals("")) trace += "in " + name + " ";
-
-            trace = trace.trim();
-
-            if (!res.equals("")) res.add(trace);
-        }
-
-        return res;
-    }
-
-    public Context context(Environment env) {
-        return new Context(env, this);
-    }
-
-    public Message(Engine engine) {
-        this.engine = engine;
-    }
-}
--- a/src/me/topchetoeu/jscript/engine/WrappersProvider.java
+++ b/src/me/topchetoeu/jscript/engine/WrappersProvider.java
@@ -5,5 +5,8 @@ import me.topchetoeu.jscript.engine.values.ObjectValue;

 public interface WrappersProvider {
    public ObjectValue getProto(Class<?> obj);
+    public ObjectValue getNamespace(Class<?> obj);
    public FunctionValue getConstr(Class<?> obj);
+
+    public WrappersProvider fork(Environment env);
 }
--- a/src/me/topchetoeu/jscript/engine/debug/DebugController.java
+++ b/src/me/topchetoeu/jscript/engine/debug/DebugController.java
@@ -0,0 +1,51 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.util.TreeSet;
+
+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.mapping.SourceMap;
+
+public interface DebugController {
+    /**
+     * Called when a script has been loaded
+     * @param filename The name of the source
+     * @param source The name of the source
+     * @param breakpoints A set of all the breakpointable locations in this source
+     * @param map The source map associated with this file. null if this source map isn't mapped
+     */
+    void onSource(Filename filename, String source, TreeSet<Location> breakpoints, SourceMap map);
+
+    /**
+     * Called immediatly before an instruction is executed, as well as after an instruction, if it has threw or returned.
+     * This function might pause in order to await debugging commands.
+     * @param ctx The context of execution
+     * @param frame The frame in which execution is occuring
+     * @param instruction The instruction which was or will be executed
+     * @param loc The most recent location the code frame has been at
+     * @param returnVal The return value of the instruction, Runners.NO_RETURN if none
+     * @param error The error that the instruction threw, null if none
+     * @param caught Whether or not the error has been caught
+     * @return Whether or not the frame should restart
+     */
+    boolean onInstruction(Context ctx, CodeFrame frame, Instruction instruction, Object returnVal, EngineException error, boolean caught);
+
+    /**
+     * Called immediatly before a frame has been pushed on the frame stack.
+     * This function might pause in order to await debugging commands.
+     * @param ctx The context of execution
+     * @param frame The code frame which was pushed
+     */
+    void onFramePush(Context ctx, CodeFrame frame);
+    /**
+     * Called immediatly after a frame has been popped out of the frame stack.
+     * This function might pause in order to await debugging commands.
+     * @param ctx The context of execution
+     * @param frame The code frame which was popped out
+     */
+    void onFramePop(Context ctx, CodeFrame frame);
+}
--- a/src/me/topchetoeu/jscript/engine/debug/DebugHandler.java
+++ b/src/me/topchetoeu/jscript/engine/debug/DebugHandler.java
@@ -0,0 +1,34 @@
+package me.topchetoeu.jscript.engine.debug;
+
+public interface DebugHandler {
+    void enable(V8Message msg);
+    void disable(V8Message msg);
+
+    void setBreakpointByUrl(V8Message msg);
+    void removeBreakpoint(V8Message msg);
+    void continueToLocation(V8Message msg);
+
+    void getScriptSource(V8Message msg);
+    void getPossibleBreakpoints(V8Message msg);
+
+    void resume(V8Message msg);
+    void pause(V8Message msg);
+
+    void stepInto(V8Message msg);
+    void stepOut(V8Message msg);
+    void stepOver(V8Message msg);
+
+    void setPauseOnExceptions(V8Message msg);
+
+    void evaluateOnCallFrame(V8Message msg);
+
+    void getProperties(V8Message msg);
+    void releaseObjectGroup(V8Message msg);
+    void releaseObject(V8Message msg);
+    /**
+     * This method might not execute the actual code for well-known requests
+     */
+    void callFunctionOn(V8Message msg);
+
+    void runtimeEnable(V8Message msg);
+}
--- a/src/me/topchetoeu/jscript/engine/debug/DebugServer.java
+++ b/src/me/topchetoeu/jscript/engine/debug/DebugServer.java
@@ -0,0 +1,245 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.security.MessageDigest;
+import java.util.Base64;
+import java.util.HashMap;
+
+import me.topchetoeu.jscript.Metadata;
+import me.topchetoeu.jscript.Reading;
+import me.topchetoeu.jscript.engine.debug.WebSocketMessage.Type;
+import me.topchetoeu.jscript.events.Notifier;
+import me.topchetoeu.jscript.exceptions.SyntaxException;
+import me.topchetoeu.jscript.exceptions.UncheckedException;
+import me.topchetoeu.jscript.exceptions.UncheckedIOException;
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONList;
+import me.topchetoeu.jscript.json.JSONMap;
+
+public class DebugServer {
+    public static String browserDisplayName = Metadata.name() + "/" + Metadata.version();
+
+    public final HashMap<String, DebuggerProvider> targets = new HashMap<>();
+
+    private final byte[] favicon, index, protocol;
+    private final Notifier connNotifier = new Notifier();
+
+    private static void send(HttpRequest req, String val) throws IOException {
+        req.writeResponse(200, "OK", "application/json", val.getBytes());
+    }
+
+    // SILENCE JAVA
+    private MessageDigest getDigestInstance() {
+        try {
+            return MessageDigest.getInstance("sha1");
+        }
+        catch (Throwable e) { throw new UncheckedException(e); }
+
+    }
+
+    private static Thread runAsync(Runnable func, String name) {
+        var res = new Thread(func);
+        res.setName(name);
+        res.start();
+        return res;
+    }
+
+    private void handle(WebSocket ws, Debugger debugger) {
+        WebSocketMessage raw;
+
+        debugger.connect();
+
+        while ((raw = ws.receive()) != null) {
+            if (raw.type != Type.Text) {
+                ws.send(new V8Error("Expected a text message."));
+                continue;
+            }
+
+            V8Message msg;
+
+            try {
+                msg = new V8Message(raw.textData());
+            }
+            catch (SyntaxException e) {
+                ws.send(new V8Error(e.getMessage()));
+                return;
+            }
+
+            try {
+                switch (msg.name) {
+                    case "Debugger.enable":
+                        connNotifier.next();
+                        debugger.enable(msg); continue;
+                    case "Debugger.disable": debugger.disable(msg); continue;
+
+                    case "Debugger.setBreakpointByUrl": debugger.setBreakpointByUrl(msg); continue;
+                    case "Debugger.removeBreakpoint": debugger.removeBreakpoint(msg); continue;
+                    case "Debugger.continueToLocation": debugger.continueToLocation(msg); continue;
+
+                    case "Debugger.getScriptSource": debugger.getScriptSource(msg); continue;
+                    case "Debugger.getPossibleBreakpoints": debugger.getPossibleBreakpoints(msg); continue;
+
+                    case "Debugger.resume": debugger.resume(msg); continue;
+                    case "Debugger.pause": debugger.pause(msg); continue;
+
+                    case "Debugger.stepInto": debugger.stepInto(msg); continue;
+                    case "Debugger.stepOut": debugger.stepOut(msg); continue;
+                    case "Debugger.stepOver": debugger.stepOver(msg); continue;
+
+                    case "Debugger.setPauseOnExceptions": debugger.setPauseOnExceptions(msg); continue;
+                    case "Debugger.evaluateOnCallFrame": debugger.evaluateOnCallFrame(msg); continue;
+
+                    case "Runtime.releaseObjectGroup": debugger.releaseObjectGroup(msg); continue;
+                    case "Runtime.releaseObject": debugger.releaseObject(msg); continue;
+                    case "Runtime.getProperties": debugger.getProperties(msg); continue;
+                    case "Runtime.callFunctionOn": debugger.callFunctionOn(msg); continue;
+                    // case "NodeWorker.enable": debugger.nodeWorkerEnable(msg); continue;
+                    case "Runtime.enable": debugger.runtimeEnable(msg); continue;
+                }
+
+                if (
+                    msg.name.startsWith("DOM.") ||
+                    msg.name.startsWith("DOMDebugger.") ||
+                    msg.name.startsWith("Emulation.") ||
+                    msg.name.startsWith("Input.") ||
+                    msg.name.startsWith("Network.") ||
+                    msg.name.startsWith("Page.")
+                ) ws.send(new V8Error("This isn't a browser..."));
+                else ws.send(new V8Error("This API is not supported yet."));
+            }
+            catch (Throwable e) {
+                e.printStackTrace();
+                throw new UncheckedException(e);
+            }
+        }
+
+        debugger.disconnect();
+    }
+    private void onWsConnect(HttpRequest req, Socket socket, DebuggerProvider debuggerProvider) {
+        var key = req.headers.get("sec-websocket-key");
+
+        if (key == null) {
+            req.writeResponse(
+                426, "Upgrade Required", "text/txt",
+                "Expected a WS upgrade".getBytes()
+            );
+            return;
+        }
+
+        var resKey = Base64.getEncoder().encodeToString(getDigestInstance().digest(
+            (key + "258EAFA5-E914-47DA-95CA-C5AB0DC85B11").getBytes()
+        ));
+
+        req.writeCode(101, "Switching Protocols");
+        req.writeHeader("Connection", "Upgrade");
+        req.writeHeader("Sec-WebSocket-Accept", resKey);
+        req.writeLastHeader("Upgrade", "WebSocket");
+
+        var ws = new WebSocket(socket);
+        var debugger = debuggerProvider.getDebugger(ws, req);
+
+        if (debugger == null) {
+            ws.close();
+            return;
+        }
+
+        runAsync(() -> {
+            try { handle(ws, debugger); }
+            catch (RuntimeException e) {
+                ws.send(new V8Error(e.getMessage()));
+            }
+            finally { ws.close(); debugger.disconnect(); }
+        }, "Debug Handler");
+    }
+
+    public void awaitConnection() {
+        connNotifier.await();
+    }
+
+    public void run(InetSocketAddress address) {
+        try {
+            ServerSocket server = new ServerSocket();
+            server.bind(address);
+
+            try {
+                while (true) {
+                    var socket = server.accept();
+                    var req = HttpRequest.read(socket);
+
+                    if (req == null) continue;
+    
+                    switch (req.path) {
+                        case "/json/version":
+                            send(req, "{\"Browser\":\"" + browserDisplayName + "\",\"Protocol-Version\":\"1.1\"}");
+                            break;
+                        case "/json/list":
+                        case "/json": {
+                            var res = new JSONList();
+
+                            for (var el : targets.entrySet()) {
+                                res.add(new JSONMap()
+                                    .set("description", "JScript debugger")
+                                    .set("favicon", "/favicon.ico")
+                                    .set("id", el.getKey())
+                                    .set("type", "node")
+                                    .set("webSocketDebuggerUrl", "ws://" + address.getHostString() + ":" + address.getPort() + "/" + el.getKey())
+                                );
+                            }
+                            send(req, JSON.stringify(res));
+                            break;
+                        }
+                        case "/json/protocol":
+                            req.writeResponse(200, "OK", "application/json", protocol);
+                            break;
+                        case "/json/new":
+                        case "/json/activate":
+                        case "/json/close":
+                        case "/devtools/inspector.html":
+                            req.writeResponse(
+                                501, "Not Implemented", "text/txt",
+                                "This feature isn't (and probably won't be) implemented.".getBytes()
+                            );
+                            break;
+                        case "/":
+                        case "/index.html":
+                            req.writeResponse(200, "OK", "text/html", index);
+                            break;
+                        case "/favicon.ico":
+                            req.writeResponse(200, "OK", "image/png", favicon);
+                            break;
+                        default:
+                            if (req.path.length() > 1 && targets.containsKey(req.path.substring(1))) {
+                                onWsConnect(req, socket, targets.get(req.path.substring(1)));
+                            }
+                            break;
+                    }
+                }
+            }
+            finally { server.close(); }
+        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+
+    public Thread start(InetSocketAddress address, boolean daemon) {
+        var res = new Thread(() -> run(address), "Debug Server");
+        res.setDaemon(daemon);
+        res.start();
+        return res;
+    }
+
+    public DebugServer() {
+        try {
+            this.favicon = Reading.resourceToStream("debugger/favicon.png").readAllBytes();
+            this.protocol = Reading.resourceToStream("debugger/protocol.json").readAllBytes();
+            this.index = Reading.resourceToString("debugger/index.html")
+                .replace("${NAME}", Metadata.name())
+                .replace("${VERSION}", Metadata.version())
+                .replace("${AUTHOR}", Metadata.author())
+                .getBytes();
+        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/Debugger.java
+++ b/src/me/topchetoeu/jscript/engine/debug/Debugger.java
@@ -0,0 +1,6 @@
+package me.topchetoeu.jscript.engine.debug;
+
+public interface Debugger extends DebugHandler, DebugController {
+    void connect();
+    void disconnect();
+}
--- a/src/me/topchetoeu/jscript/engine/debug/DebuggerProvider.java
+++ b/src/me/topchetoeu/jscript/engine/debug/DebuggerProvider.java
@@ -0,0 +1,5 @@
+package me.topchetoeu.jscript.engine.debug;
+
+public interface DebuggerProvider {
+    Debugger getDebugger(WebSocket socket, HttpRequest req);
+}
--- a/src/me/topchetoeu/jscript/engine/debug/HttpRequest.java
+++ b/src/me/topchetoeu/jscript/engine/debug/HttpRequest.java
@@ -0,0 +1,102 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.net.Socket;
+import java.util.HashMap;
+import java.util.IllegalFormatException;
+import java.util.Map;
+
+public class HttpRequest {
+    public final String method;
+    public final String path;
+    public final Map<String, String> headers;
+    public final OutputStream out;
+
+
+    public void writeCode(int code, String name) {
+        try { out.write(("HTTP/1.1 " + code + " " + name + "\r\n").getBytes()); }
+        catch (IOException e) { }
+    }
+    public void writeHeader(String name, String value) {
+        try { out.write((name + ": " + value + "\r\n").getBytes()); }
+        catch (IOException e) { }
+    }
+    public void writeLastHeader(String name, String value) {
+        try { out.write((name + ": " + value + "\r\n\r\n").getBytes()); }
+        catch (IOException e) { }
+    }
+    public void writeHeadersEnd() {
+        try { out.write("\n".getBytes()); }
+        catch (IOException e) { }
+    }
+
+    public void writeResponse(int code, String name, String type, byte[] data) {
+        writeCode(code, name);
+        writeHeader("Content-Type", type);
+        writeLastHeader("Content-Length", data.length + "");
+        try {
+            out.write(data);
+            out.close();
+        }
+        catch (IOException e) { }
+    }
+    public void writeResponse(int code, String name, String type, InputStream data) {
+        try {
+            writeResponse(code, name, type, data.readAllBytes());
+        }
+        catch (IOException e) { }
+    }
+
+    public HttpRequest(String method, String path, Map<String, String> headers, OutputStream out) {
+        this.method = method;
+        this.path = path;
+        this.headers = headers;
+        this.out = out;
+    }
+
+    // We dont need no http library
+    public static HttpRequest read(Socket socket) {
+        try {
+            var str = socket.getInputStream();
+            var lines = new BufferedReader(new InputStreamReader(str));
+            var line = lines.readLine();
+            var i1 = line.indexOf(" ");
+            var i2 = line.indexOf(" ", i1 + 1);
+
+            if (i1 < 0 || i2 < 0) {
+                socket.close();
+                return null;
+            }
+
+            var method = line.substring(0, i1).trim().toUpperCase();
+            var path = line.substring(i1 + 1, i2).trim();
+            var headers = new HashMap<String, String>();
+
+            while (!(line = lines.readLine()).isEmpty()) {
+                var i = line.indexOf(":");
+                if (i < 0) continue;
+                var name = line.substring(0, i).trim().toLowerCase();
+                var value = line.substring(i + 1).trim();
+
+                if (name.length() == 0) continue;
+                headers.put(name, value);
+            }
+
+            if (headers.containsKey("content-length")) {
+                try {
+                    var i = Integer.parseInt(headers.get("content-length"));
+                    str.skip(i);
+                }
+                catch (IllegalFormatException e) { /* ¯\_(ツ)_/¯ */ }
+            }
+
+            return new HttpRequest(method, path, headers, socket.getOutputStream());
+        }
+        catch (IOException | NullPointerException e) { return null; }
+    }
+}
+
--- a/src/me/topchetoeu/jscript/engine/debug/SimpleDebugger.java
+++ b/src/me/topchetoeu/jscript/engine/debug/SimpleDebugger.java
@@ -0,0 +1,970 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import me.topchetoeu.jscript.Filename;
+import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Instruction.Type;
+import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.Engine;
+import me.topchetoeu.jscript.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.engine.frame.Runners;
+import me.topchetoeu.jscript.engine.scope.GlobalScope;
+import me.topchetoeu.jscript.engine.values.ArrayValue;
+import me.topchetoeu.jscript.engine.values.CodeFunction;
+import me.topchetoeu.jscript.engine.values.FunctionValue;
+import me.topchetoeu.jscript.engine.values.ObjectValue;
+import me.topchetoeu.jscript.engine.values.Symbol;
+import me.topchetoeu.jscript.engine.values.Values;
+import me.topchetoeu.jscript.events.Notifier;
+import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONElement;
+import me.topchetoeu.jscript.json.JSONList;
+import me.topchetoeu.jscript.json.JSONMap;
+import me.topchetoeu.jscript.mapping.SourceMap;
+import me.topchetoeu.jscript.parsing.Parsing;
+
+// very simple indeed
+public class SimpleDebugger implements Debugger {
+    public static final Set<String> VSCODE_EMPTY = Set.of(
+        "function(...runtimeArgs){\n    let t = 1024; let e = null;\n    if(e)try{let r=\"<<default preview>>\",i=e.call(this,r);if(i!==r)return String(i)}catch(r){return`<<indescribable>>${JSON.stringify([String(r),\"object\"])}`}if(typeof this==\"object\"&&this){let r;for(let i of[Symbol.for(\"debug.description\"),Symbol.for(\"nodejs.util.inspect.custom\")])try{r=this[i]();break}catch{}if(!r&&!String(this.toString).includes(\"[native code]\")&&(r=String(this)),r&&!r.startsWith(\"[object \"))return r.length>=t?r.slice(0,t)+\"\\u2026\":r}\n  ;\n\n}",
+        "function(...runtimeArgs){\n    let t = 1024; let e = null;\n    let r={},i=\"<<default preview>>\";if(typeof this!=\"object\"||!this)return r;for(let[n,s]of Object.entries(this)){if(e)try{let o=e.call(s,i);if(o!==i){r[n]=String(o);continue}}catch(o){r[n]=`<<indescribable>>${JSON.stringify([String(o),n])}`;continue}if(typeof s==\"object\"&&s){let o;for(let a of runtimeArgs[0])try{o=s[a]();break}catch{}!o&&!String(s.toString).includes(\"[native code]\")&&(o=String(s)),o&&!o.startsWith(\"[object \")&&(r[n]=o.length>=t?o.slice(0,t)+\"\\u2026\":o)}}return r\n  ;\n\n}",
+        "function(){let t={__proto__:this.__proto__\n},e=Object.getOwnPropertyNames(this);for(let r=0;r<e.length;++r){let i=e[r],n=i>>>0;if(String(n>>>0)===i&&n>>>0!==4294967295)continue;let s=Object.getOwnPropertyDescriptor(this,i);s&&Object.defineProperty(t,i,s)}return t}",
+        "function(){return[Symbol.for(\"debug.description\"),Symbol.for(\"nodejs.util.inspect.custom\")]\n}"
+    );
+    public static final Set<String> VSCODE_SELF = Set.of(
+        "function(t,e){let r={\n},i=t===-1?0:t,n=e===-1?this.length:t+e;for(let s=i;s<n&&s<this.length;++s){let o=Object.getOwnPropertyDescriptor(this,s);o&&Object.defineProperty(r,s,o)}return r}"
+    );
+
+    public static final String CHROME_GET_PROP_FUNC = "function s(e){let t=this;const n=JSON.parse(e);for(let e=0,i=n.length;e<i;++e)t=t[n[e]];return t}";
+    public static final String VSCODE_CALL = "function(t){return t.call(this)\n}";
+    public static final String VSCODE_AUTOCOMPLETE = "function(t,e,r){let n=r?\"variable\":\"property\",i=(l,p,f)=>{if(p!==\"function\")return n;if(l===\"constructor\")return\"class\";let m=String(f);return m.startsWith(\"class \")||m.includes(\"[native code]\")&&/^[A-Z]/.test(l)?\"class\":r?\"function\":\"method\"\n},o=l=>{switch(typeof l){case\"number\":case\"boolean\":return`${l}`;case\"object\":return l===null?\"null\":l.constructor.name||\"object\";case\"function\":return`fn(${new Array(l.length).fill(\"?\").join(\", \")})`;default:return typeof l}},s=[],a=new Set,u=\"~\",c=t===void 0?this:t;for(;c!=null;c=c.__proto__){u+=\"~\";let l=Object.getOwnPropertyNames(c).filter(p=>p.startsWith(e)&&!p.match(/^\\d+$/));for(let p of l){if(a.has(p))continue;a.add(p);let f=Object.getOwnPropertyDescriptor(c,p),m=n,h;try{let H=c[p];m=i(p,typeof f?.value,H),h=o(H)}catch{}s.push({label:p,sortText:u+p.replace(/^_+/,H=>\"{\".repeat(H.length)),type:m,detail:h})}r=!1}return{result:s,isArray:this instanceof Array}}";
+
+    private static enum State {
+        RESUMED,
+        STEPPING_IN,
+        STEPPING_OUT,
+        STEPPING_OVER,
+        PAUSED_NORMAL,
+        PAUSED_EXCEPTION,
+    }
+    private static enum CatchType {
+        NONE,
+        UNCAUGHT,
+        ALL,
+    }
+    private static class Source {
+        public final int id;
+        public final Filename filename;
+        public final String source;
+        public final TreeSet<Location> breakpoints;
+
+        public Source(int id, Filename filename, String source, TreeSet<Location> breakpoints) {
+            this.id = id;
+            this.filename = filename;
+            this.source = source;
+            this.breakpoints = breakpoints;
+        }
+    }
+    private static class Breakpoint {
+        public final int id;
+        public final Location location;
+        public final String condition;
+
+        public Breakpoint(int id, Location location, String condition) {
+            this.id = id;
+            this.location = location;
+            this.condition = condition;
+        }
+    }
+    private static class BreakpointCandidate {
+        public final int id;
+        public final String condition;
+        public final Pattern pattern;
+        public final int line, start;
+        public final HashSet<Breakpoint> resolvedBreakpoints = new HashSet<>();
+
+        public BreakpointCandidate(int id, Pattern pattern, int line, int start, String condition) {
+            this.id = id;
+            this.pattern = pattern;
+            this.line = line;
+            this.start = start;
+            if (condition != null && condition.trim().equals("")) condition = null;
+            this.condition = condition;
+        }
+    }
+    private class Frame {
+        public CodeFrame frame;
+        public CodeFunction func;
+        public int id;
+        public ObjectValue local, capture, global, valstack;
+        public JSONMap serialized;
+        public Location location;
+        public boolean debugData = false;
+
+        public void updateLoc(Location loc) {
+            if (loc == null) return;
+            this.location = loc;
+        }
+
+        public Frame(Context ctx, CodeFrame frame, int id) {
+            this.frame = frame;
+            this.func = frame.function;
+            this.id = id;
+
+            this.global = frame.function.environment.global.obj;
+            this.local = frame.getLocalScope(ctx, true);
+            this.capture = frame.getCaptureScope(ctx, true);
+            this.local.setPrototype(ctx, capture);
+            this.capture.setPrototype(ctx, global);
+            this.valstack = frame.getValStackScope(ctx);
+            debugData = true;
+
+            this.serialized = new JSONMap()
+                .set("callFrameId", id + "")
+                .set("functionName", func.name)
+                .set("scopeChain", new JSONList()
+                    .add(new JSONMap().set("type", "local").set("name", "Local Scope").set("object", serializeObj(ctx, local)))
+                    .add(new JSONMap().set("type", "closure").set("name", "Closure").set("object", serializeObj(ctx, capture)))
+                    .add(new JSONMap().set("type", "global").set("name", "Global Scope").set("object", serializeObj(ctx, global)))
+                    .add(new JSONMap().set("type", "other").set("name", "Value Stack").set("object", serializeObj(ctx, valstack)))
+                );
+        }
+    }
+    private class ObjRef {
+        public final ObjectValue obj;
+        public final Context ctx;
+        public final HashSet<String> heldGroups = new HashSet<>();
+        public boolean held = true;
+
+        public boolean shouldRelease() {
+            return !held && heldGroups.size() == 0;
+        }
+
+        public ObjRef(Context ctx, ObjectValue obj) {
+            this.ctx = ctx;
+            this.obj = obj;
+        }
+    }
+
+    private static class RunResult {
+        public final Context ctx;
+        public final Object result;
+        public final EngineException error;
+
+        public RunResult(Context ctx, Object result, EngineException error) {
+            this.ctx = ctx;
+            this.result = result;
+            this.error = error;
+        }
+    }
+
+    public boolean enabled = true;
+    public CatchType execptionType = CatchType.NONE;
+    public State state = State.RESUMED;
+
+    public final WebSocket ws;
+    public final Engine target;
+
+    private ObjectValue emptyObject = new ObjectValue();
+
+    private HashMap<Integer, BreakpointCandidate> idToBptCand = new HashMap<>();
+
+    private HashMap<Integer, Breakpoint> idToBreakpoint = new HashMap<>();
+    private HashMap<Location, Breakpoint> locToBreakpoint = new HashMap<>();
+    private HashSet<Location> tmpBreakpts = new HashSet<>();
+
+    private HashMap<Filename, Integer> filenameToId = new HashMap<>();
+    private HashMap<Integer, Source> idToSource = new HashMap<>();
+    private ArrayList<Source> pendingSources = new ArrayList<>();
+
+    private HashMap<Integer, Frame> idToFrame = new HashMap<>();
+    private HashMap<CodeFrame, Frame> codeFrameToFrame = new HashMap<>();
+
+    private HashMap<Integer, ObjRef> idToObject = new HashMap<>();
+    private HashMap<ObjectValue, Integer> objectToId = new HashMap<>();
+    private HashMap<String, ArrayList<ObjRef>> objectGroups = new HashMap<>();
+
+    private Notifier updateNotifier = new Notifier();
+    private boolean pendingPause = false;
+
+    private int nextId = 0;
+    private Frame stepOutFrame = null, currFrame = null;
+    private int stepOutPtr = 0;
+
+    private boolean compare(String src, String target) {
+        if (src.length() != target.length()) return false;
+        var diff = 0;
+        var all = 0;
+
+        for (var i = 0; i < src.length(); i++) {
+            var a = src.charAt(i);
+            var b = target.charAt(i);
+            var letter = Parsing.isLetter(a) && Parsing.isLetter(b);
+
+            if (a != b) {
+                if (letter) diff++;
+                else return false;
+            }
+
+            if (letter) all++;
+        }
+
+        return diff / (float)all < .5f;
+    }
+    private boolean compare(String src, Set<String> target) {
+        for (var el : target) {
+            if (compare(src, el)) return true;
+        }
+        return false;
+    }
+
+    private int nextId() {
+        return nextId++;
+    }
+
+    private synchronized void updateFrames(Context ctx) {
+        var frame = ctx.peekFrame();
+        if (frame == null) return;
+
+        if (!codeFrameToFrame.containsKey(frame)) {
+            var id = nextId();
+            var fr = new Frame(ctx, frame, id);
+
+            idToFrame.put(id, fr);
+            codeFrameToFrame.put(frame, fr);
+        }
+
+        currFrame = codeFrameToFrame.get(frame);
+    }
+    private JSONList serializeFrames(Context ctx) {
+        var res = new JSONList();
+        var frames = ctx.frames();
+
+        for (var i = frames.size() - 1; i >= 0; i--) {
+            var frame = codeFrameToFrame.get(frames.get(i));
+            if (frame.location == null) continue;
+            frame.serialized.set("location", serializeLocation(frame.location));
+            if (frame.location != null) res.add(frame.serialized);
+        }
+
+        return res;
+    }
+
+    private Location correctLocation(Source source, Location loc) {
+        var set = source.breakpoints;
+
+        if (set.contains(loc)) return loc;
+
+        var tail = set.tailSet(loc);
+        if (tail.isEmpty()) return null;
+
+        return tail.first();
+    }
+    private Location deserializeLocation(JSONElement el, boolean correct) {
+        if (!el.isMap()) throw new RuntimeException("Expected location to be a map.");
+        var id = Integer.parseInt(el.map().string("scriptId"));
+        var line = (int)el.map().number("lineNumber") + 1;
+        var column = (int)el.map().number("columnNumber") + 1;
+
+        if (!idToSource.containsKey(id)) throw new RuntimeException(String.format("The specified source %s doesn't exist.", id));
+
+        var res = new Location(line, column, idToSource.get(id).filename);
+        if (correct) res = correctLocation(idToSource.get(id), res);
+        return res;
+    }
+    private JSONMap serializeLocation(Location loc) {
+        var source = filenameToId.get(loc.filename());
+        return new JSONMap()
+            .set("scriptId", source + "")
+            .set("lineNumber", loc.line() - 1)
+            .set("columnNumber", loc.start() - 1);
+    }
+
+    private Integer objectId(Context ctx, ObjectValue obj) {
+        if (objectToId.containsKey(obj)) return objectToId.get(obj);
+        else {
+            int id = nextId();
+            var ref = new ObjRef(ctx, obj);
+            objectToId.put(obj, id);
+            idToObject.put(id, ref);
+            return id;
+        }
+    }
+    private JSONMap serializeObj(Context ctx, Object val, boolean byValue) {
+        val = Values.normalize(null, val);
+
+        if (val == Values.NULL) {
+            return new JSONMap()
+                .set("type", "object")
+                .set("subtype", "null")
+                .setNull("value")
+                .set("description", "null");
+        }
+
+        if (val instanceof ObjectValue) {
+            var obj = (ObjectValue)val;
+            var id = objectId(ctx, obj);
+            var type = "object";
+            String subtype = null;
+            String className = null;
+
+            if (obj instanceof FunctionValue) type = "function";
+            if (obj instanceof ArrayValue) subtype = "array";
+
+            try { className = Values.toString(ctx, Values.getMemberPath(ctx, obj, "constructor", "name")); }
+            catch (Exception e) { }
+
+            var res = new JSONMap()
+                .set("type", type)
+                .set("objectId", id + "");
+
+            if (subtype != null) res.set("subtype", subtype);
+            if (className != null) {
+                res.set("className", className);
+            }
+
+            if (obj instanceof ArrayValue) res.set("description", "Array(" + ((ArrayValue)obj).size() + ")");
+            else if (obj instanceof FunctionValue) res.set("description", obj.toString());
+            else {
+                var defaultToString = false;
+
+                try {
+                    defaultToString =
+                        Values.getMember(ctx, obj, "toString") ==
+                        Values.getMember(ctx, ctx.environment().proto("object"), "toString");
+                }
+                catch (Exception e) { }
+
+                try { res.set("description", className + (defaultToString ? "" : " { " + Values.toString(ctx, obj) + " }")); }
+                catch (EngineException e) { res.set("description", className); }
+            }
+
+
+            if (byValue) try { res.put("value", JSON.fromJs(ctx, obj)); }
+            catch (Exception e) { }
+
+            return res;
+        }
+
+        if (val == null) return new JSONMap().set("type", "undefined");
+        if (val instanceof String) return new JSONMap().set("type", "string").set("value", (String)val);
+        if (val instanceof Boolean) return new JSONMap().set("type", "boolean").set("value", (Boolean)val);
+        if (val instanceof Symbol) return new JSONMap().set("type", "symbol").set("description", val.toString());
+        if (val instanceof Number) {
+            var num = (double)(Number)val;
+            var res = new JSONMap().set("type", "number");
+
+            if (Double.POSITIVE_INFINITY == num) res.set("unserializableValue", "Infinity");
+            else if (Double.NEGATIVE_INFINITY == num) res.set("unserializableValue", "-Infinity");
+            else if (Double.doubleToRawLongBits(num) == Double.doubleToRawLongBits(-0d)) res.set("unserializableValue", "-0");
+            else if (Double.doubleToRawLongBits(num) == Double.doubleToRawLongBits(0d)) res.set("unserializableValue", "0");
+            else if (Double.isNaN(num)) res.set("unserializableValue", "NaN");
+            else res.set("value", num);
+
+            return res;
+        }
+
+        throw new IllegalArgumentException("Unexpected JS object.");
+    }
+    private JSONMap serializeObj(Context ctx, Object val) {
+        return serializeObj(ctx, val, false);
+    }
+    private void addObjectGroup(String name, Object val) {
+        if (val instanceof ObjectValue) {
+            var obj = (ObjectValue)val;
+            var id = objectToId.getOrDefault(obj, -1);
+            if (id < 0) return;
+
+            var ref = idToObject.get(id);
+
+            if (objectGroups.containsKey(name)) objectGroups.get(name).add(ref);
+            else objectGroups.put(name, new ArrayList<>(List.of(ref)));
+
+            ref.heldGroups.add(name);
+        }
+    }
+    private void releaseGroup(String name) {
+        var objs = objectGroups.remove(name);
+
+        if (objs != null) for (var obj : objs) {
+            if (obj.heldGroups.remove(name) && obj.shouldRelease()) {
+                var id = objectToId.remove(obj.obj);
+                if (id != null) idToObject.remove(id);
+            }
+        }
+    }
+    private Object deserializeArgument(JSONMap val) {
+        if (val.isString("objectId")) return idToObject.get(Integer.parseInt(val.string("objectId"))).obj;
+        else if (val.isString("unserializableValue")) switch (val.string("unserializableValue")) {
+            case "NaN": return Double.NaN;
+            case "-Infinity": return Double.NEGATIVE_INFINITY;
+            case "Infinity": return Double.POSITIVE_INFINITY;
+            case "-0": return -0.;
+        }
+        var res = val.get("value");
+        if (res == null) return null;
+        else return JSON.toJs(res);
+    }
+
+    private JSONMap serializeException(Context ctx, EngineException err) {
+        String text = null;
+
+        try {
+            text = Values.toString(ctx, err.value);
+        }
+        catch (EngineException e) {
+            text = "[error while stringifying]";
+        }
+
+        var res = new JSONMap()
+            .set("exceptionId", nextId())
+            .set("exception", serializeObj(ctx, err.value))
+            .set("text", text);
+
+        return res;
+    }
+
+    private void resume(State state) {
+        this.state = state;
+        ws.send(new V8Event("Debugger.resumed", new JSONMap()));
+        updateNotifier.next();
+    }
+    private void pauseDebug(Context ctx, Breakpoint bp) {
+        state = State.PAUSED_NORMAL;
+        var map = new JSONMap()
+            .set("callFrames", serializeFrames(ctx))
+            .set("reason", "debugCommand");
+
+        if (bp != null) map.set("hitBreakpoints", new JSONList().add(bp.id + ""));
+        ws.send(new V8Event("Debugger.paused", map));
+    }
+    private void pauseException(Context ctx) {
+        state = State.PAUSED_EXCEPTION;
+        var map = new JSONMap()
+            .set("callFrames", serializeFrames(ctx))
+            .set("reason", "exception");
+
+        ws.send(new V8Event("Debugger.paused", map));
+    }
+
+    private void sendSource(Source src) {
+        ws.send(new V8Event("Debugger.scriptParsed", new JSONMap()
+            .set("scriptId", src.id + "")
+            .set("hash", src.source.hashCode())
+            .set("url", src.filename + "")
+        ));
+    }
+
+    private void addBreakpoint(Breakpoint bpt) {
+        idToBreakpoint.put(bpt.id, bpt);
+        locToBreakpoint.put(bpt.location, bpt);
+
+        ws.send(new V8Event("Debugger.breakpointResolved", new JSONMap()
+            .set("breakpointId", bpt.id)
+            .set("location", serializeLocation(bpt.location))
+        ));
+    }
+
+    private RunResult run(Frame codeFrame, String code) {
+        if (codeFrame == null) return new RunResult(null, code, new EngineException("Invalid code frame!"));
+        var engine = new Engine(false);
+        var env = codeFrame.func.environment.fork();
+
+        env.global = new GlobalScope(codeFrame.local);
+
+        var ctx = new Context(engine).pushEnv(env);
+        var awaiter = engine.pushMsg(false, ctx, new Filename("jscript", "eval"), code, codeFrame.frame.thisArg, codeFrame.frame.args);
+
+        engine.run(true);
+
+        try { return new RunResult(ctx, awaiter.await(), null); }
+        catch (EngineException e) { return new RunResult(ctx, null, e); }
+    }
+
+    private ObjectValue vscodeAutoSuggest(Context ctx, Object target, String query, boolean variable) {
+        var res = new ArrayValue();
+        var passed = new HashSet<String>();
+        var tildas = "~";
+        if (target == null) target = ctx.environment().getGlobal();
+
+        for (var proto = target; proto != null && proto != Values.NULL; proto = Values.getPrototype(ctx, proto)) {
+            for (var el : Values.getMembers(ctx, proto, true, true)) {
+                var strKey = Values.toString(ctx, el);
+                if (passed.contains(strKey)) continue;
+                passed.add(strKey);
+
+                var val = Values.getMember(ctx, Values.getMemberDescriptor(ctx, proto, el), "value");
+                var desc = new ObjectValue();
+                var sortText = "";
+                if (strKey.startsWith(query)) sortText += "0@";
+                else if (strKey.toLowerCase().startsWith(query.toLowerCase())) sortText += "1@";
+                else if (strKey.contains(query)) sortText += "2@";
+                else if (strKey.toLowerCase().contains(query.toLowerCase())) sortText += "3@";
+                else sortText += "4@";
+                sortText += tildas + strKey;
+
+                desc.defineProperty(ctx, "label", strKey);
+                desc.defineProperty(ctx, "sortText", sortText);
+
+                if (val instanceof FunctionValue) {
+                    if (strKey.equals("constructor")) desc.defineProperty(ctx, "type", "name");
+                    else desc.defineProperty(ctx, "type", variable ? "function" : "method");
+                }
+                else desc.defineProperty(ctx, "type", variable ? "variable" : "property");
+
+                switch (Values.type(val)) {
+                    case "number":
+                    case "boolean":
+                        desc.defineProperty(ctx, "detail", Values.toString(ctx, val));
+                        break;
+                    case "object":
+                        if (val == Values.NULL) desc.defineProperty(ctx, "detail", "null");
+                        else try {
+                            desc.defineProperty(ctx, "detail", Values.getMemberPath(ctx, target, "constructor", "name"));
+                        }
+                        catch (IllegalArgumentException e) {
+                            desc.defineProperty(ctx, "detail", "object");
+                        }
+                        break;
+                    case "function": {
+                        var type = "fn(";
+                        for (var i = 0; i < ((FunctionValue)val).length; i++) {
+                            if (i != 0) type += ",";
+                            type += "?";
+                        }
+                        type += ")";
+                        desc.defineProperty(ctx, "detail", type);
+                        break;
+                    }
+                    default:
+                        desc.defineProperty(ctx, "type", Values.type(val));
+                        break;
+                }
+            
+                res.set(ctx, res.size(), desc);
+            }
+
+            tildas += "~";
+            variable = true;
+        }
+
+        var resObj = new ObjectValue();
+        resObj.defineProperty(ctx, "result", res);
+        resObj.defineProperty(ctx, "isArray", target instanceof ArrayValue);
+        return resObj;
+    }
+
+    @Override public synchronized void enable(V8Message msg) {
+        enabled = true;
+        ws.send(msg.respond());
+
+        for (var el : pendingSources) sendSource(el);
+        pendingSources.clear();
+
+        updateNotifier.next();
+    }
+    @Override public synchronized void disable(V8Message msg) {
+        enabled = false;
+        ws.send(msg.respond());
+        updateNotifier.next();
+    }
+
+    @Override public synchronized void getScriptSource(V8Message msg) {
+        int id = Integer.parseInt(msg.params.string("scriptId"));
+        ws.send(msg.respond(new JSONMap().set("scriptSource", idToSource.get(id).source)));
+    }
+    @Override public synchronized void getPossibleBreakpoints(V8Message msg) {
+        var src = idToSource.get(Integer.parseInt(msg.params.map("start").string("scriptId")));
+        var start = deserializeLocation(msg.params.get("start"), false);
+        var end = msg.params.isMap("end") ? deserializeLocation(msg.params.get("end"), false) : null;
+
+        var res = new JSONList();
+
+        for (var loc : src.breakpoints.tailSet(start, true)) {
+            if (end != null && loc.compareTo(end) > 0) break;
+            res.add(serializeLocation(loc));
+        }
+
+        ws.send(msg.respond(new JSONMap().set("locations", res)));
+    }
+
+    @Override public synchronized void pause(V8Message msg) {
+        pendingPause = true;
+        ws.send(msg.respond());
+    }
+    @Override public synchronized void resume(V8Message msg) {
+        resume(State.RESUMED);
+        ws.send(msg.respond(new JSONMap()));
+    }
+
+    @Override public synchronized void setBreakpointByUrl(V8Message msg) {
+        var line = (int)msg.params.number("lineNumber") + 1;
+        var col = (int)msg.params.number("columnNumber", 0) + 1;
+        var cond = msg.params.string("condition", "").trim();
+
+        if (cond.equals("")) cond = null;
+        if (cond != null) cond  = "(" + cond + ")";
+
+        Pattern regex;
+
+        if (msg.params.isString("url")) regex = Pattern.compile(Pattern.quote(msg.params.string("url")));
+        else regex = Pattern.compile(msg.params.string("urlRegex"));
+
+        var bpcd = new BreakpointCandidate(nextId(), regex, line, col, cond);
+        idToBptCand.put(bpcd.id, bpcd);
+
+        var locs = new JSONList();
+
+        for (var src : idToSource.values()) {
+            if (regex.matcher(src.filename.toString()).matches()) {
+                var loc = correctLocation(src, new Location(line, col, src.filename));
+                if (loc == null) continue;
+                var bp = new Breakpoint(nextId(), loc, bpcd.condition);
+
+                bpcd.resolvedBreakpoints.add(bp);
+                locs.add(serializeLocation(loc));
+                addBreakpoint(bp);
+            }
+        }
+
+        ws.send(msg.respond(new JSONMap()
+            .set("breakpointId", bpcd.id + "")
+            .set("locations", locs)
+        ));
+    }
+    @Override public synchronized void removeBreakpoint(V8Message msg) {
+        var id = Integer.parseInt(msg.params.string("breakpointId"));
+
+        if (idToBptCand.containsKey(id)) {
+            var bpcd = idToBptCand.get(id);
+            for (var bp : bpcd.resolvedBreakpoints) {
+                idToBreakpoint.remove(bp.id);
+                locToBreakpoint.remove(bp.location);
+            }
+            idToBptCand.remove(id);
+        }
+        else if (idToBreakpoint.containsKey(id)) {
+            var bp = idToBreakpoint.remove(id);
+            locToBreakpoint.remove(bp.location);
+        }
+        ws.send(msg.respond());
+    }
+    @Override public synchronized void continueToLocation(V8Message msg) {
+        var loc = deserializeLocation(msg.params.get("location"), true);
+
+        tmpBreakpts.add(loc);
+
+        resume(State.RESUMED);
+        ws.send(msg.respond());
+    }
+
+    @Override public synchronized void setPauseOnExceptions(V8Message msg) {
+        switch (msg.params.string("state")) {
+            case "none": execptionType = CatchType.NONE; break;
+            case "all": execptionType = CatchType.ALL; break;
+            case "uncaught": execptionType = CatchType.UNCAUGHT; break;
+            default:
+                ws.send(new V8Error("Invalid exception pause type."));
+                return;
+        }
+
+        ws.send(msg.respond());
+    }
+
+    @Override public synchronized void stepInto(V8Message msg) {
+        if (state == State.RESUMED) ws.send(new V8Error("Debugger is resumed."));
+        else {
+            stepOutFrame = currFrame;
+            stepOutPtr = currFrame.frame.codePtr;
+            resume(State.STEPPING_IN);
+            ws.send(msg.respond());
+        }
+    }
+    @Override public synchronized void stepOut(V8Message msg) {
+        if (state == State.RESUMED) ws.send(new V8Error("Debugger is resumed."));
+        else {
+            stepOutFrame = currFrame;
+            stepOutPtr = currFrame.frame.codePtr;
+            resume(State.STEPPING_OUT);
+            ws.send(msg.respond());
+        }
+    }
+    @Override public synchronized void stepOver(V8Message msg) {
+        if (state == State.RESUMED) ws.send(new V8Error("Debugger is resumed."));
+        else {
+            stepOutFrame = currFrame;
+            stepOutPtr = currFrame.frame.codePtr;
+            resume(State.STEPPING_OVER);
+            ws.send(msg.respond());
+        }
+    }
+
+    @Override public synchronized void evaluateOnCallFrame(V8Message msg) {
+        var cfId = Integer.parseInt(msg.params.string("callFrameId"));
+        var expr = msg.params.string("expression");
+        var group = msg.params.string("objectGroup", null);
+
+        var cf = idToFrame.get(cfId);
+        var res = run(cf, expr);
+
+        if (group != null) addObjectGroup(group, res.result);
+
+        if (res.error != null) ws.send(msg.respond(new JSONMap().set("exceptionDetails", serializeException(res.ctx, res.error))));
+        else ws.send(msg.respond(new JSONMap().set("result", serializeObj(res.ctx, res.result))));
+    }
+
+    @Override public synchronized void releaseObjectGroup(V8Message msg) {
+        var group = msg.params.string("objectGroup");
+        releaseGroup(group);
+        ws.send(msg.respond());
+    }
+    @Override public synchronized void releaseObject(V8Message msg) {
+        var id = Integer.parseInt(msg.params.string("objectId"));
+        var ref = idToObject.get(id);
+        ref.held = false;
+
+        if (ref.shouldRelease()) {
+            objectToId.remove(ref.obj);
+            idToObject.remove(id);
+        }
+
+        ws.send(msg.respond());
+    }
+    @Override public synchronized void getProperties(V8Message msg) {
+        var ref = idToObject.get(Integer.parseInt(msg.params.string("objectId")));
+        var obj = ref.obj;
+
+        var res = new JSONList();
+        var ctx = ref.ctx;
+
+        if (obj != emptyObject && obj != null) {
+            for (var key : obj.keys(true)) {
+                var propDesc = new JSONMap();
+
+                if (obj.properties.containsKey(key)) {
+                    var prop = obj.properties.get(key);
+
+                    propDesc.set("name", Values.toString(ctx, key));
+                    if (prop.getter != null) propDesc.set("get", serializeObj(ctx, prop.getter));
+                    if (prop.setter != null) propDesc.set("set", serializeObj(ctx, prop.setter));
+                    propDesc.set("enumerable", obj.memberEnumerable(key));
+                    propDesc.set("configurable", obj.memberConfigurable(key));
+                    propDesc.set("isOwn", true);
+                    res.add(propDesc);
+                }
+                else {
+                    propDesc.set("name", Values.toString(ctx, key));
+                    propDesc.set("value", serializeObj(ctx, obj.getMember(ctx, key)));
+                    propDesc.set("writable", obj.memberWritable(key));
+                    propDesc.set("enumerable", obj.memberEnumerable(key));
+                    propDesc.set("configurable", obj.memberConfigurable(key));
+                    propDesc.set("isOwn", true);
+                    res.add(propDesc);
+                }
+            }
+    
+            var proto = obj.getPrototype(ctx);
+    
+            var protoDesc = new JSONMap();
+            protoDesc.set("name", "__proto__");
+            protoDesc.set("value", serializeObj(ctx, proto == null ? Values.NULL : proto));
+            protoDesc.set("writable", true);
+            protoDesc.set("enumerable", false);
+            protoDesc.set("configurable", false);
+            protoDesc.set("isOwn", true);
+            res.add(protoDesc);
+        }
+
+        ws.send(msg.respond(new JSONMap().set("result", res)));
+    }
+    @Override public synchronized void callFunctionOn(V8Message msg) {
+        var src = msg.params.string("functionDeclaration");
+        var args = msg.params
+            .list("arguments", new JSONList())
+            .stream()
+            .map(v -> v.map())
+            .map(this::deserializeArgument)
+            .collect(Collectors.toList());
+        var byValue = msg.params.bool("returnByValue", false);
+
+        var thisArgRef = idToObject.get(Integer.parseInt(msg.params.string("objectId")));
+        var thisArg = thisArgRef.obj;
+        var ctx = thisArgRef.ctx;
+
+        while (true) {
+            var start = src.lastIndexOf("//# sourceURL=");
+            if (start < 0) break;
+            var end = src.indexOf("\n", start);
+            if (end < 0) src = src.substring(0, start);
+            else src = src.substring(0, start) + src.substring(end + 1);
+        }
+
+        try {
+            Object res = null;
+            if (compare(src, VSCODE_EMPTY)) res = emptyObject;
+            else if (compare(src, VSCODE_SELF)) res = thisArg;
+            else if (compare(src, CHROME_GET_PROP_FUNC)) {
+                res = thisArg;
+                for (var el : JSON.parse(null, (String)args.get(0)).list()) res = Values.getMember(ctx, res, JSON.toJs(el));
+            }
+            else if (compare(src, VSCODE_CALL)) {
+                var func = (FunctionValue)(args.size() < 1 ? null : args.get(0));
+                ws.send(msg.respond(new JSONMap().set("result", serializeObj(ctx, func.call(ctx, thisArg)))));
+            }
+            else if (compare(src, VSCODE_AUTOCOMPLETE)) {
+                var target = args.get(0);
+                if (target == null) target = thisArg;
+                res = vscodeAutoSuggest(ctx, target, Values.toString(ctx, args.get(1)), Values.toBoolean(args.get(2)));
+            }
+            else {
+                ws.send(new V8Error("Please use well-known functions with callFunctionOn"));
+                return;
+            }
+            ws.send(msg.respond(new JSONMap().set("result", serializeObj(ctx, res, byValue))));
+        }
+        catch (EngineException e) { ws.send(msg.respond(new JSONMap().set("exceptionDetails", serializeException(ctx, e)))); }
+    }
+
+    @Override public synchronized void runtimeEnable(V8Message msg) {
+        ws.send(msg.respond());
+    }
+
+    @Override public void onSource(Filename filename, String source, TreeSet<Location> locations, SourceMap map) {
+        int id = nextId();
+        var src = new Source(id, filename, source, locations);
+
+        idToSource.put(id, src);
+        filenameToId.put(filename, id);
+
+        for (var bpcd : idToBptCand.values()) {
+            if (!bpcd.pattern.matcher(filename.toString()).matches()) continue;
+            var loc = correctLocation(src, new Location(bpcd.line, bpcd.start, filename));
+            var bp = new Breakpoint(nextId(), loc, bpcd.condition);
+            if (loc == null) continue;
+            bpcd.resolvedBreakpoints.add(bp);
+            addBreakpoint(bp);
+        }
+
+        if (!enabled) pendingSources.add(src);
+        else sendSource(src);
+    }
+    @Override public boolean onInstruction(Context ctx, CodeFrame cf, Instruction instruction, Object returnVal, EngineException error, boolean caught) {
+        if (!enabled) return false;
+
+        boolean isBreakpointable;
+        Location loc;
+        Frame frame;
+
+        synchronized (this) {
+            frame = codeFrameToFrame.get(cf);
+
+            if (!frame.debugData) return false;
+
+            if (instruction.location != null) frame.updateLoc(ctx.engine.mapToCompiled(instruction.location));
+            loc = frame.location;
+            isBreakpointable = loc != null && (instruction.breakpoint.shouldStepIn());
+
+            if (error != null && (execptionType == CatchType.ALL || execptionType == CatchType.UNCAUGHT && !caught)) {
+                pauseException(ctx);
+            }
+            else if (loc != null && (state == State.STEPPING_IN || state == State.STEPPING_OVER) && returnVal != Runners.NO_RETURN && stepOutFrame == frame) {
+                pauseDebug(ctx, null);
+            }
+            else if (isBreakpointable && locToBreakpoint.containsKey(loc)) {
+                var bp = locToBreakpoint.get(loc);
+                var ok = bp.condition == null ? true : Values.toBoolean(run(currFrame, bp.condition).result);
+                if (ok) pauseDebug(ctx, locToBreakpoint.get(loc));
+            }
+            else if (isBreakpointable && tmpBreakpts.remove(loc)) pauseDebug(ctx, null);
+            else if (isBreakpointable && pendingPause) {
+                pauseDebug(ctx, null);
+                pendingPause = false;
+            }
+            else if (instruction.type == Type.NOP && instruction.match("debug")) pauseDebug(ctx, null);
+        }
+
+
+        while (enabled) {
+            synchronized (this) {
+                switch (state) {
+                    case PAUSED_EXCEPTION:
+                    case PAUSED_NORMAL: break;
+
+                    case STEPPING_OUT:
+                    case RESUMED: return false;
+
+                    case STEPPING_IN:
+                    case STEPPING_OVER:
+                        if (stepOutFrame.frame == frame.frame) {
+                            if (returnVal != Runners.NO_RETURN || error != null) {
+                                state = State.STEPPING_OUT;
+                                continue;
+                            }
+                            else if (stepOutPtr != frame.frame.codePtr) {
+                                if (state == State.STEPPING_IN && instruction.breakpoint.shouldStepIn()) {
+                                    pauseDebug(ctx, null);
+                                    break;
+                                }
+                                else if (state == State.STEPPING_OVER && instruction.breakpoint.shouldStepOver()) {
+                                    pauseDebug(ctx, null);
+                                    break;
+                                }
+                            }
+                        }
+                        return false;
+                }
+            }
+            updateNotifier.await();
+        }
+
+        return false;
+    }
+    @Override public void onFramePush(Context ctx, CodeFrame frame) {
+        var prevFrame = currFrame;
+        updateFrames(ctx);
+
+        if (stepOutFrame != null && stepOutFrame.frame == prevFrame.frame && state == State.STEPPING_IN) {
+            stepOutFrame = currFrame;
+        }
+    }
+    @Override public void onFramePop(Context ctx, CodeFrame frame) {
+        updateFrames(ctx);
+
+        try { idToFrame.remove(codeFrameToFrame.remove(frame).id); }
+        catch (NullPointerException e) { }
+
+        if (ctx.frames().size() == 0) {
+            if (state == State.PAUSED_EXCEPTION || state == State.PAUSED_NORMAL) resume(State.RESUMED);
+        }
+        else if (stepOutFrame != null && stepOutFrame.frame == frame && state == State.STEPPING_OUT) {
+            state = State.STEPPING_IN;
+            stepOutFrame = currFrame;
+        }
+    }
+
+    @Override public synchronized void connect() {
+        if (!target.attachDebugger(this)) {
+            ws.send(new V8Error("A debugger is already attached to this engine."));
+        }
+    }
+    @Override public synchronized void disconnect() {
+        target.detachDebugger();
+        enabled = false;
+        updateNotifier.next();
+    }
+
+    public SimpleDebugger(WebSocket ws, Engine target) {
+        this.ws = ws;
+        this.target = target;
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/V8Error.java
+++ b/src/me/topchetoeu/jscript/engine/debug/V8Error.java
@@ -0,0 +1,19 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONMap;
+
+public class V8Error {
+    public final String message;
+
+    public V8Error(String message) {
+        this.message = message;
+    }
+
+    @Override
+    public String toString() {
+        return JSON.stringify(new JSONMap().set("error", new JSONMap()
+            .set("message", message)
+        ));
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/V8Event.java
+++ b/src/me/topchetoeu/jscript/engine/debug/V8Event.java
@@ -0,0 +1,22 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONMap;
+
+public class V8Event {
+    public final String name;
+    public final JSONMap params;
+
+    public V8Event(String name, JSONMap params) {
+        this.name = name;
+        this.params = params;
+    }
+
+    @Override
+    public String toString() {
+        return JSON.stringify(new JSONMap()
+            .set("method", name)
+            .set("params", params)
+        );
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/V8Message.java
+++ b/src/me/topchetoeu/jscript/engine/debug/V8Message.java
@@ -0,0 +1,50 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.util.Map;
+
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONElement;
+import me.topchetoeu.jscript.json.JSONMap;
+
+public class V8Message {
+    public final String name;
+    public final int id;
+    public final JSONMap params;
+
+    public V8Message(String name, int id, Map<String, JSONElement> params) {
+        this.name = name;
+        this.params = new JSONMap(params);
+        this.id = id;
+    }
+    public V8Result respond(JSONMap result) {
+        return new V8Result(id, result);
+    }
+    public V8Result respond() {
+        return new V8Result(id, new JSONMap());
+    }
+
+    public V8Message(JSONMap raw) {
+        if (!raw.isNumber("id")) throw new IllegalArgumentException("Expected number property 'id'.");
+        if (!raw.isString("method")) throw new IllegalArgumentException("Expected string property 'method'.");
+
+        this.name = raw.string("method");
+        this.id = (int)raw.number("id");
+        this.params = raw.contains("params") ? raw.map("params") : new JSONMap();
+    }
+    public V8Message(String raw) {
+        this(JSON.parse(null, raw).map());
+    }
+
+    public JSONMap toMap() {
+        var res = new JSONMap();
+        return res;
+    }
+    @Override
+    public String toString() {
+        return JSON.stringify(new JSONMap()
+            .set("method", name)
+            .set("params", params)
+            .set("id", id)
+        );
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/V8Result.java
+++ b/src/me/topchetoeu/jscript/engine/debug/V8Result.java
@@ -0,0 +1,22 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import me.topchetoeu.jscript.json.JSON;
+import me.topchetoeu.jscript.json.JSONMap;
+
+public class V8Result {
+    public final int id;
+    public final JSONMap result;
+
+    public V8Result(int id, JSONMap result) {
+        this.id = id;
+        this.result = result;
+    }
+
+    @Override
+    public String toString() {
+        return JSON.stringify(new JSONMap()
+            .set("id", id)
+            .set("result", result)
+        );
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/WebSocket.java
+++ b/src/me/topchetoeu/jscript/engine/debug/WebSocket.java
@@ -0,0 +1,216 @@
+package me.topchetoeu.jscript.engine.debug;
+
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.Socket;
+
+import me.topchetoeu.jscript.engine.debug.WebSocketMessage.Type;
+import me.topchetoeu.jscript.exceptions.UncheckedIOException;
+
+public class WebSocket implements AutoCloseable {
+    public long maxLength = 1 << 20;
+
+    private Socket socket;
+    private boolean closed = false;
+
+    private OutputStream out() {
+        try { return socket.getOutputStream(); }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+    private InputStream in() {
+        try { return socket.getInputStream(); }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+
+    private long readLen(int byteLen) {
+        long res = 0;
+
+        try {
+            if (byteLen == 126) {
+                res |= in().read() << 8;
+                res |= in().read();
+                return res;
+            }
+            else if (byteLen == 127) {
+                res |= in().read() << 56;
+                res |= in().read() << 48;
+                res |= in().read() << 40;
+                res |= in().read() << 32;
+                res |= in().read() << 24;
+                res |= in().read() << 16;
+                res |= in().read() << 8;
+                res |= in().read();
+                return res;
+            }
+            else return byteLen;
+        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+    private byte[] readMask(boolean has) {
+        if (has) {
+            try { return new byte[] {
+                (byte)in().read(),
+                (byte)in().read(),
+                (byte)in().read(),
+                (byte)in().read()
+            }; }
+            catch (IOException e) { throw new UncheckedIOException(e); }
+        }
+        else return new byte[4];
+    }
+
+    private void writeLength(int len) {
+        try {
+            if (len < 126) {
+                out().write((int)len);
+            }
+            else if (len <= 0xFFFF) {
+                out().write(126);
+                out().write((int)(len >> 8) & 0xFF);
+                out().write((int)len & 0xFF);
+            }
+            else {
+                out().write(127);
+                out().write((len >> 56) & 0xFF);
+                out().write((len >> 48) & 0xFF);
+                out().write((len >> 40) & 0xFF);
+                out().write((len >> 32) & 0xFF);
+                out().write((len >> 24) & 0xFF);
+                out().write((len >> 16) & 0xFF);
+                out().write((len >> 8) & 0xFF);
+                out().write(len & 0xFF);
+            }
+        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+    private synchronized void write(int type, byte[] data) {
+        try {
+            int i;
+
+            for (i = 0; i < data.length / 0xFFFF; i++) {
+                out().write(type);
+                writeLength(0xFFFF);
+                out().write(data, i * 0xFFFF, 0xFFFF);
+                type = 0;
+            }
+
+            out().write(type | 0x80);
+            writeLength(data.length % 0xFFFF);
+            out().write(data, i * 0xFFFF, data.length % 0xFFFF);
+        }
+        catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+
+    public void send(String data) {
+        if (closed) throw new IllegalStateException("Object is closed.");
+        write(1, data.getBytes());
+    }
+    public void send(byte[] data) {
+        if (closed) throw new IllegalStateException("Object is closed.");
+        write(2, data);
+    }
+    public void send(WebSocketMessage msg) {
+        if (msg.type == Type.Binary) send(msg.binaryData());
+        else send(msg.textData());
+    }
+    public void send(Object data) {
+        if (closed) throw new IllegalStateException("Object is closed.");
+        write(1, data.toString().getBytes());
+    }
+
+    public void close(String reason) {
+        if (socket != null) {
+            try {
+                write(8, reason.getBytes());
+                socket.close();
+            }
+            catch (Throwable e) { }
+        }
+
+        socket = null;
+        closed = true;
+    }
+    public void close() {
+        close("");
+    }
+
+    private WebSocketMessage fail(String reason) {
+        System.out.println("WebSocket Error: " + reason);
+        close(reason);
+        return null;
+    }
+
+    private byte[] readData() {
+        try {
+            var maskLen = in().read();
+            var hasMask = (maskLen & 0x80) != 0;
+            var len = (int)readLen(maskLen & 0x7F);
+            var mask = readMask(hasMask);
+    
+            if (len > maxLength) fail("WebSocket Error: client exceeded configured max message size");
+            else {
+                var buff = new byte[len];
+    
+                if (in().read(buff) < len) fail("WebSocket Error: payload too short");
+                else {
+                    for (int i = 0; i < len; i++) {
+                        buff[i] ^= mask[(int)(i % 4)];
+                    }
+                    return buff;
+                }
+            }
+
+            return null;
+        }
+        catch (IOException e) { throw new UncheckedIOException(e); }
+    }
+
+    public WebSocketMessage receive() {
+        try {
+            var data = new ByteArrayOutputStream();
+            var type = 0;
+
+            while (socket != null && !closed) {
+                var finId = in().read();
+                if (finId < 0) break;
+                var fin = (finId & 0x80) != 0;
+                int id = finId & 0x0F;
+
+                if (id == 0x8) { close(); return null; }
+                if (id >= 0x8) {
+                    if (!fin) return fail("WebSocket Error: client-sent control frame was fragmented");
+                    if (id == 0x9) write(0xA, data.toByteArray());
+                    continue;
+                }
+
+                if (type == 0) type = id;
+                if (type == 0) return fail("WebSocket Error: client used opcode 0x00 for first fragment");
+
+                var buff = readData();
+                if (buff == null) break;
+
+                if (data.size() + buff.length > maxLength) return fail("WebSocket Error: client exceeded configured max message size");
+                data.write(buff);
+
+                if (!fin) continue;
+                var raw = data.toByteArray();
+
+                if (type == 1) return new WebSocketMessage(new String(raw));
+                else return new WebSocketMessage(raw);
+            }
+        }
+        catch (IOException e) {
+            close();
+        }
+
+        return null;
+    }
+
+    public WebSocket(Socket socket) {
+        this.socket = socket;
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/debug/WebSocketMessage.java
+++ b/src/me/topchetoeu/jscript/engine/debug/WebSocketMessage.java
@@ -0,0 +1,29 @@
+package me.topchetoeu.jscript.engine.debug;
+
+public class WebSocketMessage {
+    public static enum Type {
+        Text,
+        Binary,
+    }
+
+    public final Type type;
+    private final Object data;
+
+    public final String textData() {
+        if (type != Type.Text) throw new IllegalStateException("Message is not text.");
+        return (String)data;
+    }
+    public final byte[] binaryData() {
+        if (type != Type.Binary) throw new IllegalStateException("Message is not binary.");
+        return (byte[])data;
+    }
+
+    public WebSocketMessage(String data) {
+        this.type = Type.Text;
+        this.data = data;
+    }
+    public WebSocketMessage(byte[] data) {
+        this.type = Type.Binary;
+        this.data = data;
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/frame/CodeFrame.java
+++ b/src/me/topchetoeu/jscript/engine/frame/CodeFrame.java
@@ -1,44 +1,90 @@
 package me.topchetoeu.jscript.engine.frame;

+import java.util.List;
 import java.util.Stack;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.scope.LocalScope;
 import me.topchetoeu.jscript.engine.scope.ValueVariable;
 import me.topchetoeu.jscript.engine.values.ArrayValue;
 import me.topchetoeu.jscript.engine.values.CodeFunction;
 import me.topchetoeu.jscript.engine.values.ObjectValue;
+import me.topchetoeu.jscript.engine.values.ScopeValue;
 import me.topchetoeu.jscript.engine.values.Values;
 import me.topchetoeu.jscript.exceptions.EngineException;
+import me.topchetoeu.jscript.exceptions.InterruptException;

 public class CodeFrame {
-    private class TryCtx {
-        public static final int STATE_TRY = 0;
-        public static final int STATE_CATCH = 1;
-        public static final int STATE_FINALLY_THREW = 2;
-        public static final int STATE_FINALLY_RETURNED = 3;
-        public static final int STATE_FINALLY_JUMPED = 4;
+    public static enum TryState {
+        TRY,
+        CATCH,
+        FINALLY,
+    }

-        public final boolean hasCatch, hasFinally;
-        public final int tryStart, catchStart, finallyStart, end;
-        public int state;
-        public Object retVal;
-        public EngineException err;
-        public int jumpPtr;
+    public static class TryCtx {
+        public final int start, end, catchStart, finallyStart;
+        public final int restoreStackPtr;
+        public final TryState state;
+        public final EngineException error;
+        public final PendingResult result;

-        public TryCtx(int tryStart, int tryN, int catchN, int finallyN) {
-            hasCatch = catchN >= 0;
-            hasFinally = finallyN >= 0;
+        public boolean hasCatch() { return catchStart >= 0; }
+        public boolean hasFinally() { return finallyStart >= 0; }

-            if (catchN < 0) catchN = 0;
-            if (finallyN < 0) finallyN = 0;
+        public boolean inBounds(int ptr) {
+            return ptr >= start && ptr < end;
+        }

-            this.tryStart = tryStart;
-            this.catchStart = tryStart + tryN;
-            this.finallyStart = catchStart + catchN;
-            this.end = finallyStart + finallyN;
-            this.jumpPtr = end;
+        public TryCtx _catch(EngineException e) {
+            if (error != null) e.setCause(error);
+            return new TryCtx(TryState.CATCH, e, result, restoreStackPtr, start, end, -1, finallyStart);
+        }
+        public TryCtx _finally(PendingResult res) {
+            return new TryCtx(TryState.FINALLY, error, res, restoreStackPtr, start, end, -1, -1);
+        }
+
+        public TryCtx(TryState state, EngineException err, PendingResult res, int stackPtr, int start, int end, int catchStart, int finallyStart) {
+            this.catchStart = catchStart;
+            this.finallyStart = finallyStart;
+            this.restoreStackPtr = stackPtr;
+            this.result = res == null ? PendingResult.ofNone() : res;
+            this.state = state;
+            this.start = start;
+            this.end = end;
+            this.error = err;
+        }
+    }
+
+    private static class PendingResult {
+        public final boolean isReturn, isJump, isThrow;
+        public final Object value;
+        public final EngineException error;
+        public final int ptr;
+        public final Instruction instruction;
+
+        private PendingResult(Instruction instr, boolean isReturn, boolean isJump, boolean isThrow, Object value, EngineException error, int ptr) {
+            this.instruction = instr;
+            this.isReturn = isReturn;
+            this.isJump = isJump;
+            this.isThrow = isThrow;
+            this.value = value;
+            this.error = error;
+            this.ptr = ptr;
+        }
+
+        public static PendingResult ofNone() {
+            return new PendingResult(null, false, false, false, null, null, 0);
+        }
+        public static PendingResult ofReturn(Object value, Instruction instr) {
+            return new PendingResult(instr, true, false, false, value, null, 0);
+        }
+        public static PendingResult ofThrow(EngineException error, Instruction instr) {
+            return new PendingResult(instr, false, false, true, null, error, 0);
+        }
+        public static PendingResult ofJump(int codePtr, Instruction instr) {
+            return new PendingResult(instr, false, true, false, null, null, codePtr);
        }
    }

@@ -47,15 +93,62 @@ public class CodeFrame {
    public final Object[] args;
    public final Stack<TryCtx> tryStack = new Stack<>();
    public final CodeFunction function;
-
    public Object[] stack = new Object[32];
    public int stackPtr = 0;
    public int codePtr = 0;
-    public boolean jumpFlag = false;
+    public boolean jumpFlag = false, popTryFlag = false;
    private Location prevLoc = null;

-    public void addTry(int n, int catchN, int finallyN) {
-        var res = new TryCtx(codePtr + 1, n, catchN, finallyN);
+    public ObjectValue getLocalScope(Context ctx, boolean props) {
+        var names = new String[scope.locals.length];
+
+        for (int i = 0; i < scope.locals.length; i++) {
+            var name = "local_" + (i - 2);
+
+            if (i == 0) name = "this";
+            else if (i == 1) name = "arguments";
+            else if (i < function.localNames.length) name = function.localNames[i];
+
+            names[i] = name;
+        }
+
+        return new ScopeValue(scope.locals, names);
+    }
+    public ObjectValue getCaptureScope(Context ctx, boolean props) {
+        var names = new String[scope.captures.length];
+
+        for (int i = 0; i < scope.captures.length; i++) {
+            var name = "capture_" + (i - 2);
+            if (i < function.captureNames.length) name = function.captureNames[i];
+            names[i] = name;
+        }
+
+        return new ScopeValue(scope.captures, names);
+    }
+    public ObjectValue getValStackScope(Context ctx) {
+        return new ObjectValue() {
+            @Override
+            protected Object getField(Context ctx, Object key) {
+                var i = (int)Values.toNumber(ctx, key);
+                if (i < 0 || i >= stackPtr) return null;
+                else return stack[i];
+            }
+            @Override
+            protected boolean hasField(Context ctx, Object key) {
+                return true;
+            }
+            @Override
+            public List<Object> keys(boolean includeNonEnumerable) {
+                var res = super.keys(includeNonEnumerable);
+                for (var i = 0; i < stackPtr; i++) res.add(i);
+                return res;
+            }
+        };
+    }
+
+    public void addTry(int start, int end, int catchStart, int finallyStart) {
+        var err = tryStack.empty() ? null : tryStack.peek().error;
+        var res = new TryCtx(TryState.TRY, err, null, stackPtr, start, end, catchStart, finallyStart);

        tryStack.add(res);
    }
@@ -93,153 +186,121 @@ public class CodeFrame {
        stack[stackPtr++] = Values.normalize(ctx, val);
    }

-    private void setCause(Context ctx, EngineException err, EngineException cause) throws InterruptedException {
-        if (err.value instanceof ObjectValue) {
-            Values.setMember(ctx, err, ctx.env.symbol("Symbol.cause"), cause);
-        }
-        err.cause = cause;
-    }
-    private Object nextNoTry(Context ctx) throws InterruptedException {
-        if (Thread.currentThread().isInterrupted()) throw new InterruptedException();
-        if (codePtr < 0 || codePtr >= function.body.length) return null;
-
-        var instr = function.body[codePtr];
-
-        var loc = instr.location;
-        if (loc != null) prevLoc = loc;
-
-        try {
-            this.jumpFlag = false;
-            return Runners.exec(ctx, instr, this);
-        }
-        catch (EngineException e) {
-            throw e.add(function.name, prevLoc).setContext(ctx);
-        }
-    }
-
-    public Object next(Context ctx, Object value, Object returnValue, EngineException error) throws InterruptedException {
+    public Object next(Context ctx, Object value, Object returnValue, EngineException error) {
        if (value != Runners.NO_RETURN) push(ctx, value);

+        Instruction instr = null;
+        if (codePtr >= 0 && codePtr < function.body.length) instr = function.body[codePtr];
+
        if (returnValue == Runners.NO_RETURN && error == null) {
-            try { returnValue = nextNoTry(ctx); }
+            try {
+                if (Thread.currentThread().isInterrupted()) throw new InterruptException();
+
+                if (instr == null) returnValue = null;
+                else {
+                // System.out.println(instr + "@" + instr.location);
+                    ctx.engine.onInstruction(ctx, this, instr, Runners.NO_RETURN, null, false);
+
+                    if (instr.location != null) prevLoc = instr.location;
+
+                    try {
+                        this.jumpFlag = this.popTryFlag = false;
+                        returnValue = Runners.exec(ctx, instr, this);
+                    }
+                    catch (EngineException e) {
+                        error = e.add(ctx, function.name, prevLoc);
+                    }
+                }
+            }
            catch (EngineException e) { error = e; }
        }

        while (!tryStack.empty()) {
            var tryCtx = tryStack.peek();
-            var newState = -1;
+            TryCtx newCtx = null;

-            switch (tryCtx.state) {
-                case TryCtx.STATE_TRY:
-                    if (error != null) {
-                        if (tryCtx.hasCatch) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_CATCH;
-                        }
-                        else if (tryCtx.hasFinally) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_FINALLY_THREW;
-                        }
-                        break;
-                    }
-                    else if (returnValue != Runners.NO_RETURN) {
-                        if (tryCtx.hasFinally) {
-                            tryCtx.retVal = error;
-                            newState = TryCtx.STATE_FINALLY_RETURNED;
-                        }
-                        break;
-                    }
-                    else if (codePtr >= tryCtx.tryStart && codePtr < tryCtx.catchStart) return Runners.NO_RETURN;
-
-                    if (tryCtx.hasFinally) {
-                        if (jumpFlag) tryCtx.jumpPtr = codePtr;
-                        else tryCtx.jumpPtr = tryCtx.end;
-                        newState = TryCtx.STATE_FINALLY_JUMPED;
-                    }
-                    else codePtr = tryCtx.end;
-                    break;
-                case TryCtx.STATE_CATCH:
-                    if (error != null) {
-                        if (tryCtx.hasFinally) {
-                            tryCtx.err = error;
-                            newState = TryCtx.STATE_FINALLY_THREW;
-                        }
-                        break;
-                    }
-                    else if (returnValue != Runners.NO_RETURN) {
-                        if (tryCtx.hasFinally) {
-                            tryCtx.retVal = returnValue;
-                            newState = TryCtx.STATE_FINALLY_RETURNED;
-                        }
-                        break;
-                    }
-                    else if (codePtr >= tryCtx.catchStart && codePtr < tryCtx.finallyStart) return Runners.NO_RETURN;
-
-                    if (tryCtx.hasFinally) {
-                        if (jumpFlag) tryCtx.jumpPtr = codePtr;
-                        else tryCtx.jumpPtr = tryCtx.end;
-                        newState = TryCtx.STATE_FINALLY_JUMPED;
-                    }
-                    else codePtr = tryCtx.end;
-                    break;
-                case TryCtx.STATE_FINALLY_THREW:
-                    if (error != null) setCause(ctx, error, tryCtx.err);
-                    else if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) error = tryCtx.err;
-                    else return Runners.NO_RETURN;
-                    break;
-                case TryCtx.STATE_FINALLY_RETURNED:
-                    if (returnValue == Runners.NO_RETURN) {
-                        if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) returnValue = tryCtx.retVal;
-                        else return Runners.NO_RETURN;
-                    }
-                    break;
-                case TryCtx.STATE_FINALLY_JUMPED:
-                    if (codePtr < tryCtx.finallyStart || codePtr >= tryCtx.end) {
-                        if (!jumpFlag) codePtr = tryCtx.jumpPtr;
-                        else codePtr = tryCtx.end;
-                    }
-                    else return Runners.NO_RETURN;
-                    break;
+            if (error != null) {
+                if (tryCtx.hasCatch()) newCtx = tryCtx._catch(error);
+                else if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofThrow(error, instr));
            }
-
-            if (tryCtx.state == TryCtx.STATE_CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
-
-            if (newState == -1) {
-                tryStack.pop();
-                continue;
+            else if (returnValue != Runners.NO_RETURN) {
+                if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofReturn(returnValue, instr));
            }
+            else if (jumpFlag && !tryCtx.inBounds(codePtr)) {
+                if (tryCtx.hasFinally()) newCtx = tryCtx._finally(PendingResult.ofJump(codePtr, instr));
+            }
+            else if (!this.popTryFlag) newCtx = tryCtx;

-            tryCtx.state = newState;
-            switch (newState) {
-                case TryCtx.STATE_CATCH:
-                    scope.catchVars.add(new ValueVariable(false, tryCtx.err.value));
-                    codePtr = tryCtx.catchStart;
-                    break;
-                default:
+            if (newCtx != null) {
+                if (newCtx != tryCtx) {
+                    switch (newCtx.state) {
+                        case CATCH:
+                            if (tryCtx.state != TryState.CATCH) scope.catchVars.add(new ValueVariable(false, error.value));
+                            codePtr = tryCtx.catchStart;
+                            stackPtr = tryCtx.restoreStackPtr;
+                            break;
+                        case FINALLY:
+                            if (tryCtx.state == TryState.CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
+                            codePtr = tryCtx.finallyStart;
+                            stackPtr = tryCtx.restoreStackPtr;
+                        default:
+                    }
+
+                    tryStack.pop();
+                    tryStack.push(newCtx);
+                }
+                error = null;
+                returnValue = Runners.NO_RETURN;
+                break;
+            }
+            else {
+                if (tryCtx.state == TryState.CATCH) scope.catchVars.remove(scope.catchVars.size() - 1);
+
+                if (tryCtx.state != TryState.FINALLY && tryCtx.hasFinally()) {
                    codePtr = tryCtx.finallyStart;
+                    stackPtr = tryCtx.restoreStackPtr;
+                    tryStack.pop();
+                    tryStack.push(tryCtx._finally(null));
+                    break;
+                }
+                else {
+                    tryStack.pop();
+                    codePtr = tryCtx.end;
+                    if (tryCtx.result.instruction != null) instr = tryCtx.result.instruction;
+                    if (tryCtx.result.isJump) {
+                        codePtr = tryCtx.result.ptr;
+                        jumpFlag = true;
+                    }
+                    if (tryCtx.result.isReturn) returnValue = tryCtx.result.value;
+                    if (tryCtx.result.isThrow) {
+                        error = tryCtx.result.error;
+                    }
+                    if (error != null) error.setCause(tryCtx.error);
+                    continue;
+                }
+            }
+        }
+
+        if (error != null) {
+            var caught = false;
+
+            for (var frame : ctx.frames()) {
+                for (var tryCtx : frame.tryStack) {
+                    if (tryCtx.state == TryState.TRY) caught = true;
+                }
            }

-            return Runners.NO_RETURN;
+            ctx.engine.onInstruction(ctx, this, instr, null, error, caught);
+            throw error;
        }
-    
-        if (error != null) throw error.setContext(ctx);
-        if (returnValue != Runners.NO_RETURN) return returnValue;
+        if (returnValue != Runners.NO_RETURN) {
+            ctx.engine.onInstruction(ctx, this, instr, returnValue, null, false);
+            return returnValue;
+        }
+
        return Runners.NO_RETURN;
    }

-    public Object run(Context ctx) throws InterruptedException {
-        try {
-            ctx.message.pushFrame(ctx, this);
-            while (true) {
-                var res = next(ctx, Runners.NO_RETURN, Runners.NO_RETURN, null);
-                if (res != Runners.NO_RETURN) return res;
-            }
-        }
-        finally {
-            ctx.message.popFrame(this);
-        }
-    }
-
    public CodeFrame(Context ctx, Object thisArg, Object[] args, CodeFunction func) {
        this.args = args.clone();
        this.scope = new LocalScope(func.localsN, func.captures);
--- a/src/me/topchetoeu/jscript/engine/frame/Runners.java
+++ b/src/me/topchetoeu/jscript/engine/frame/Runners.java
@@ -4,12 +4,12 @@ import java.util.Collections;

 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.Engine;
 import me.topchetoeu.jscript.engine.Operation;
 import me.topchetoeu.jscript.engine.scope.ValueVariable;
 import me.topchetoeu.jscript.engine.values.ArrayValue;
 import me.topchetoeu.jscript.engine.values.CodeFunction;
 import me.topchetoeu.jscript.engine.values.ObjectValue;
-import me.topchetoeu.jscript.engine.values.SignalValue;
 import me.topchetoeu.jscript.engine.values.Symbol;
 import me.topchetoeu.jscript.engine.values.Values;
 import me.topchetoeu.jscript.exceptions.EngineException;
@@ -20,58 +20,40 @@ public class Runners {
    public static Object execReturn(Context ctx, Instruction instr, CodeFrame frame) {
        return frame.pop();
    }
-    public static Object execSignal(Context ctx, Instruction instr, CodeFrame frame) {
-        return new SignalValue(instr.get(0));
-    }
    public static Object execThrow(Context ctx, Instruction instr, CodeFrame frame) {
        throw new EngineException(frame.pop());
    }
-    public static Object execThrowSyntax(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execThrowSyntax(Context ctx, Instruction instr, CodeFrame frame) {
        throw EngineException.ofSyntax((String)instr.get(0));
    }

-    private static Object call(Context ctx, Object func, Object thisArg, Object ...args) throws InterruptedException {
-        return Values.call(ctx, func, thisArg, args);
-    }
-
-    public static Object execCall(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execCall(Context ctx, Instruction instr, CodeFrame frame) {
        var callArgs = frame.take(instr.get(0));
        var func = frame.pop();
        var thisArg = frame.pop();

-        frame.push(ctx, call(ctx, func, thisArg, callArgs));
+        frame.push(ctx, Values.call(ctx, func, thisArg, callArgs));

        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execCallNew(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execCallNew(Context ctx, Instruction instr, CodeFrame frame) {
        var callArgs = frame.take(instr.get(0));
        var funcObj = frame.pop();

        frame.push(ctx, Values.callNew(ctx, funcObj, callArgs));

-        // if (Values.isFunction(funcObj) && Values.function(funcObj).special) {
-        //     frame.push(ctx, call(ctx, funcObj, null, callArgs));
-        // }
-        // else {
-        //     var proto = Values.getMember(ctx, funcObj, "prototype");
-        //     var obj = new ObjectValue();
-        //     obj.setPrototype(ctx, proto);
-        //     call(ctx, funcObj, obj, callArgs);
-        //     frame.push(ctx, obj);
-        // }
-
        frame.codePtr++;
        return NO_RETURN;
    }

-    public static Object execMakeVar(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execMakeVar(Context ctx, Instruction instr, CodeFrame frame) {
        var name = (String)instr.get(0);
-        ctx.env.global.define(name);
+        ctx.environment().global.define(name);
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execDefProp(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execDefProp(Context ctx, Instruction instr, CodeFrame frame) {
        var setter = frame.pop();
        var getter = frame.pop();
        var name = frame.pop();
@@ -86,7 +68,7 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execInstanceof(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execInstanceof(Context ctx, Instruction instr, CodeFrame frame) {
        var type = frame.pop();
        var obj = frame.pop();

@@ -101,54 +83,51 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execKeys(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execKeys(Context ctx, Instruction instr, CodeFrame frame) {
        var val = frame.pop();

-        var arr = new ObjectValue();
-        var i = 0;
-
        var members = Values.getMembers(ctx, val, false, false);
        Collections.reverse(members);
+
+        frame.push(ctx, null);
+
        for (var el : members) {
            if (el instanceof Symbol) continue;
-            arr.defineProperty(ctx, i++, el);
+            var obj = new ObjectValue();
+            obj.defineProperty(ctx, "value", el);
+            frame.push(ctx, obj);
        }

-        arr.defineProperty(ctx, "length", i);
-
-        frame.push(ctx, arr);
        frame.codePtr++;
        return NO_RETURN;
    }

-    public static Object execTry(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
-        frame.addTry(instr.get(0), instr.get(1), instr.get(2));
+    public static Object execTryStart(Context ctx, Instruction instr, CodeFrame frame) {
+        int start = frame.codePtr + 1;
+        int catchStart = (int)instr.get(0);
+        int finallyStart = (int)instr.get(1);
+        if (finallyStart >= 0) finallyStart += start;
+        if (catchStart >= 0) catchStart += start;
+        int end = (int)instr.get(2) + start;
+        frame.addTry(start, end, catchStart, finallyStart);
        frame.codePtr++;
        return NO_RETURN;
    }
+    public static Object execTryEnd(Context ctx, Instruction instr, CodeFrame frame) {
+        frame.popTryFlag = true;
+        return NO_RETURN;
+    }

    public static Object execDup(Context ctx, Instruction instr, CodeFrame frame) {
-        int offset = instr.get(0), count = instr.get(1);
+        int count = instr.get(0);

        for (var i = 0; i < count; i++) {
-            frame.push(ctx, frame.peek(offset + count - 1));
+            frame.push(ctx, frame.peek(count - 1));
        }

        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execMove(Context ctx, Instruction instr, CodeFrame frame) {
-        int offset = instr.get(0), count = instr.get(1);
-
-        var tmp = frame.take(offset);
-        var res = frame.take(count);
-
-        for (var i = 0; i < offset; i++) frame.push(ctx, tmp[i]);
-        for (var i = 0; i < count; i++) frame.push(ctx, res[i]);
-
-        frame.codePtr++;
-        return NO_RETURN;
-    }
    public static Object execLoadUndefined(Context ctx, Instruction instr, CodeFrame frame) {
        frame.push(ctx, null);
        frame.codePtr++;
@@ -159,10 +138,10 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execLoadVar(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execLoadVar(Context ctx, Instruction instr, CodeFrame frame) {
        var i = instr.get(0);

-        if (i instanceof String) frame.push(ctx, ctx.env.global.get(ctx, (String)i));
+        if (i instanceof String) frame.push(ctx, ctx.environment().global.get(ctx, (String)i));
        else frame.push(ctx, frame.scope.get((int)i).get(ctx));

        frame.codePtr++;
@@ -174,7 +153,7 @@ public class Runners {
        return NO_RETURN;
    }
    public static Object execLoadGlob(Context ctx, Instruction instr, CodeFrame frame) {
-        frame.push(ctx, ctx.env.global.obj);
+        frame.push(ctx, ctx.environment().global.obj);
        frame.codePtr++;
        return NO_RETURN;
    }
@@ -186,27 +165,21 @@ public class Runners {
        return NO_RETURN;
    }
    public static Object execLoadFunc(Context ctx, Instruction instr, CodeFrame frame) {
-        int n = (Integer)instr.get(0);
-        int localsN = (Integer)instr.get(1);
-        int len = (Integer)instr.get(2);
-        var captures = new ValueVariable[instr.params.length - 3];
+        long id = (Long)instr.get(0);
+        var captures = new ValueVariable[instr.params.length - 1];

-        for (var i = 3; i < instr.params.length; i++) {
-            captures[i - 3] = frame.scope.get(instr.get(i));
+        for (var i = 1; i < instr.params.length; i++) {
+            captures[i - 1] = frame.scope.get(instr.get(i));
        }

-        var start = frame.codePtr + 1;
-        var end = start + n - 1;
-        var body = new Instruction[end - start];
-        System.arraycopy(frame.function.body, start, body, 0, end - start);
+        var func = new CodeFunction(ctx.environment(), "", Engine.functions.get(id), captures);

-        var func = new CodeFunction(ctx.env, "", localsN, len, captures, body);
        frame.push(ctx, func);

-        frame.codePtr += n;
+        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execLoadMember(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execLoadMember(Context ctx, Instruction instr, CodeFrame frame) {
        var key = frame.pop();
        var obj = frame.pop();

@@ -219,12 +192,12 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execLoadKeyMember(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execLoadKeyMember(Context ctx, Instruction instr, CodeFrame frame) {
        frame.push(ctx, instr.get(0));
        return execLoadMember(ctx, instr, frame);
    }
-    public static Object execLoadRegEx(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
-        frame.push(ctx, ctx.env.regexConstructor.call(ctx, null, instr.get(0), instr.get(1)));
+    public static Object execLoadRegEx(Context ctx, Instruction instr, CodeFrame frame) {
+        frame.push(ctx, ctx.environment().regexConstructor.call(ctx, null, instr.get(0), instr.get(1)));
        frame.codePtr++;
        return NO_RETURN;
    }
@@ -234,7 +207,7 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execStoreMember(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execStoreMember(Context ctx, Instruction instr, CodeFrame frame) {
        var val = frame.pop();
        var key = frame.pop();
        var obj = frame.pop();
@@ -244,11 +217,11 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execStoreVar(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execStoreVar(Context ctx, Instruction instr, CodeFrame frame) {
        var val = (boolean)instr.get(1) ? frame.peek() : frame.pop();
        var i = instr.get(0);

-        if (i instanceof String) ctx.env.global.set(ctx, (String)i, val);
+        if (i instanceof String) ctx.environment().global.set(ctx, (String)i, val);
        else frame.scope.get((int)i).set(ctx, val);

        frame.codePtr++;
@@ -265,7 +238,7 @@ public class Runners {
        frame.jumpFlag = true;
        return NO_RETURN;
    }
-    public static Object execJmpIf(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execJmpIf(Context ctx, Instruction instr, CodeFrame frame) {
        if (Values.toBoolean(frame.pop())) {
            frame.codePtr += (int)instr.get(0);
            frame.jumpFlag = true;
@@ -273,7 +246,7 @@ public class Runners {
        else frame.codePtr ++;
        return NO_RETURN;
    }
-    public static Object execJmpIfNot(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execJmpIfNot(Context ctx, Instruction instr, CodeFrame frame) {
        if (Values.not(frame.pop())) {
            frame.codePtr += (int)instr.get(0);
            frame.jumpFlag = true;
@@ -282,7 +255,7 @@ public class Runners {
        return NO_RETURN;
    }

-    public static Object execIn(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execIn(Context ctx, Instruction instr, CodeFrame frame) {
        var obj = frame.pop();
        var index = frame.pop();

@@ -290,13 +263,13 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execTypeof(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execTypeof(Context ctx, Instruction instr, CodeFrame frame) {
        String name = instr.get(0);
        Object obj;

        if (name != null) {
-            if (ctx.env.global.has(ctx, name)) {
-                obj = ctx.env.global.get(ctx, name);
+            if (ctx.environment().global.has(ctx, name)) {
+                obj = ctx.environment().global.get(ctx, name);
            }
            else obj = null;
        }
@@ -307,31 +280,21 @@ public class Runners {
        frame.codePtr++;
        return NO_RETURN;
    }
-    public static Object execNop(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
-        if (instr.is(0, "dbg_names")) {
-            var names = new String[instr.params.length - 1];
-            for (var i = 0; i < instr.params.length - 1; i++) {
-                if (!(instr.params[i + 1] instanceof String)) throw EngineException.ofSyntax("NOP dbg_names instruction must specify only string parameters.");
-                names[i] = (String)instr.params[i + 1];
-            }
-            frame.scope.setNames(names);
-        }
-
+    public static Object execNop(Context ctx, Instruction instr, CodeFrame frame) {
        frame.codePtr++;
        return NO_RETURN;
    }

-    public static Object execDelete(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execDelete(Context ctx, Instruction instr, CodeFrame frame) {
        var key = frame.pop();
        var val = frame.pop();

        if (!Values.deleteMember(ctx, val, key)) throw EngineException.ofSyntax("Can't delete member '" + key + "'.");
-        frame.push(ctx, true);
        frame.codePtr++;
        return NO_RETURN;
    }

-    public static Object execOperation(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
+    public static Object execOperation(Context ctx, Instruction instr, CodeFrame frame) {
        Operation op = instr.get(0);
        var args = new Object[op.operands];

@@ -342,20 +305,18 @@ public class Runners {
        return NO_RETURN;
    }

-    public static Object exec(Context ctx, Instruction instr, CodeFrame frame) throws InterruptedException {
-        // System.out.println(instr + "@" + instr.location);
+    public static Object exec(Context ctx, Instruction instr, CodeFrame frame) {
        switch (instr.type) {
            case NOP: return execNop(ctx, instr, frame);
            case RETURN: return execReturn(ctx, instr, frame);
-            case SIGNAL: return execSignal(ctx, instr, frame);
            case THROW: return execThrow(ctx, instr, frame);
            case THROW_SYNTAX: return execThrowSyntax(ctx, instr, frame);
            case CALL: return execCall(ctx, instr, frame);
            case CALL_NEW: return execCallNew(ctx, instr, frame);
-            case TRY: return execTry(ctx, instr, frame);
+            case TRY_START: return execTryStart(ctx, instr, frame);
+            case TRY_END: return execTryEnd(ctx, instr, frame);

            case DUP: return execDup(ctx, instr, frame);
-            case MOVE: return execMove(ctx, instr, frame);
            case LOAD_VALUE: return execLoadValue(ctx, instr, frame);
            case LOAD_VAR: return execLoadVar(ctx, instr, frame);
            case LOAD_OBJ: return execLoadObj(ctx, instr, frame);
--- a/src/me/topchetoeu/jscript/engine/scope/GlobalScope.java
+++ b/src/me/topchetoeu/jscript/engine/scope/GlobalScope.java
@@ -12,10 +12,7 @@ import me.topchetoeu.jscript.exceptions.EngineException;
 public class GlobalScope implements ScopeRecord {
    public final ObjectValue obj;

-    @Override
-    public GlobalScope parent() { return null; }
-
-    public boolean has(Context ctx, String name) throws InterruptedException {
+    public boolean has(Context ctx, String name) {
        return obj.hasMember(ctx, name, false);
    }
    public Object getKey(String name) {
@@ -28,17 +25,11 @@ public class GlobalScope implements ScopeRecord {
        return new GlobalScope(obj);
    }
    public LocalScopeRecord child() {
-        return new LocalScopeRecord(this);
+        return new LocalScopeRecord();
    }

    public Object define(String name) {
-        try {
-            if (obj.hasMember(null, name, true)) return name;
-        }
-        catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            return name;
-        }
+        if (obj.hasMember(null, name, true)) return name;
        obj.defineProperty(null, name, null);
        return name;
    }
@@ -59,11 +50,11 @@ public class GlobalScope implements ScopeRecord {
        define(null, val.name, readonly, val);
    }

-    public Object get(Context ctx, String name) throws InterruptedException {
+    public Object get(Context ctx, String name) {
        if (!obj.hasMember(ctx, name, false)) throw EngineException.ofSyntax("The variable '" + name + "' doesn't exist.");
        else return obj.getMember(ctx, name);
    }
-    public void set(Context ctx, String name, Object val) throws InterruptedException {
+    public void set(Context ctx, String name, Object val) {
        if (!obj.hasMember(ctx, name, false)) throw EngineException.ofSyntax("The variable '" + name + "' doesn't exist.");
        if (!obj.setMember(ctx, name, val, false)) throw EngineException.ofSyntax("The global '" + name + "' is readonly.");
    }
--- a/src/me/topchetoeu/jscript/engine/scope/LocalScope.java
+++ b/src/me/topchetoeu/jscript/engine/scope/LocalScope.java
@@ -3,43 +3,21 @@ package me.topchetoeu.jscript.engine.scope;
 import java.util.ArrayList;

 public class LocalScope {
-    private String[] names;
    public final ValueVariable[] captures;
    public final ValueVariable[] locals;
    public final ArrayList<ValueVariable> catchVars = new ArrayList<>();

    public ValueVariable get(int i) {
-        if (i >= locals.length)
-            return catchVars.get(i - locals.length);
+        if (i >= locals.length) return catchVars.get(i - locals.length);
        if (i >= 0) return locals[i];
        else return captures[~i];
    }

-    public String[] getNames() {
-        var res = new String[locals.length];
-
-        for (var i = 0; i < locals.length; i++) {
-            if (names == null || i >= names.length) res[i] = "local_" + i;
-            else res[i] = names[i];
-        }
-
-        return res;
-    }
-    public void setNames(String[] names) {
-        this.names = names;
-    }

    public int size() {
        return captures.length + locals.length;
    }

-    public void toGlobal(GlobalScope global) {
-        var names = getNames();
-        for (var i = 0; i < names.length; i++) {
-            global.define(names[i], locals[i]);
-        }
-    }
-
    public LocalScope(int n, ValueVariable[] captures) {
        locals = new ValueVariable[n];
        this.captures = captures;
--- a/src/me/topchetoeu/jscript/engine/scope/LocalScopeRecord.java
+++ b/src/me/topchetoeu/jscript/engine/scope/LocalScopeRecord.java
@@ -2,24 +2,21 @@ package me.topchetoeu.jscript.engine.scope;

 import java.util.ArrayList;

-import me.topchetoeu.jscript.engine.Context;
-
 public class LocalScopeRecord implements ScopeRecord {
    public final LocalScopeRecord parent;
-    public final GlobalScope global;

    private final ArrayList<String> captures = new ArrayList<>();
    private final ArrayList<String> locals = new ArrayList<>();

+    public String[] captures() {
+        return captures.toArray(String[]::new);
+    }
    public String[] locals() {
        return locals.toArray(String[]::new);
    }

-    @Override
-    public LocalScopeRecord parent() { return parent; }
-
    public LocalScopeRecord child() {
-        return new LocalScopeRecord(this, global);
+        return new LocalScopeRecord(this);
    }

    public int localsCount() {
@@ -59,12 +56,6 @@ public class LocalScopeRecord implements ScopeRecord {

        return name;
    }
-    public boolean has(Context ctx, String name) throws InterruptedException {
-        return
-            global.has(ctx, name) ||
-            locals.contains(name) ||
-            parent != null && parent.has(ctx, name);
-    }
    public Object define(String name, boolean force) {
        if (!force && locals.contains(name)) return locals.indexOf(name);
        locals.add(name);
@@ -77,12 +68,10 @@ public class LocalScopeRecord implements ScopeRecord {
        locals.remove(locals.size() - 1);
    }

-    public LocalScopeRecord(GlobalScope global) {
+    public LocalScopeRecord() {
        this.parent = null;
-        this.global = global;
    }
-    public LocalScopeRecord(LocalScopeRecord parent, GlobalScope global) {
+    public LocalScopeRecord(LocalScopeRecord parent) {
        this.parent = parent;
-        this.global = global;
    }
 }
--- a/src/me/topchetoeu/jscript/engine/scope/ScopeRecord.java
+++ b/src/me/topchetoeu/jscript/engine/scope/ScopeRecord.java
@@ -3,6 +3,5 @@ package me.topchetoeu.jscript.engine.scope;
 public interface ScopeRecord {
    public Object getKey(String name);
    public Object define(String name);
-    public ScopeRecord parent();
    public LocalScopeRecord child();
 }
--- a/src/me/topchetoeu/jscript/engine/scope/Variable.java
+++ b/src/me/topchetoeu/jscript/engine/scope/Variable.java
@@ -3,7 +3,7 @@ package me.topchetoeu.jscript.engine.scope;
 import me.topchetoeu.jscript.engine.Context;

 public interface Variable {
-    Object get(Context ctx) throws InterruptedException;
+    Object get(Context ctx);
    default boolean readonly() { return true; }
-    default void set(Context ctx, Object val) throws InterruptedException { }
+    default void set(Context ctx, Object val) { }
 }
--- a/src/me/topchetoeu/jscript/engine/values/ArrayValue.java
+++ b/src/me/topchetoeu/jscript/engine/values/ArrayValue.java
@@ -14,13 +14,14 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
    private Object[] values;
    private int size;

-    private void alloc(int index) {
-        if (index < values.length) return;
+    private Object[] alloc(int index) {
+        index++;
+        if (index < values.length) return values;
        if (index < values.length * 2) index = values.length * 2;

        var arr = new Object[index];
        System.arraycopy(values, 0, arr, 0, values.length);
-        values = arr;
+        return arr;
    }

    public int size() { return size; }
@@ -28,7 +29,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        if (val < 0) return false;
        if (size > val) shrink(size - val);
        else {
-            alloc(val);
+            values = alloc(val);
            size = val;
        }
        return true;
@@ -43,7 +44,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
    public void set(Context ctx, int i, Object val) {
        if (i < 0) return;

-        alloc(i);
+        values = alloc(i);

        val = Values.normalize(ctx, val);
        if (val == null) val = UNDEFINED;
@@ -51,7 +52,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        if (i >= size) size = i + 1;
    }
    public boolean has(int i) {
-        return i >= 0 && i < values.length && values[i] != null;
+        return i >= 0 && i < size && values[i] != null;
    }
    public void remove(int i) {
        if (i < 0 || i >= values.length) return;
@@ -84,8 +85,9 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
    public void copyTo(Context ctx, ArrayValue arr, int sourceStart, int destStart, int count) {
        // Iterate in reverse to reallocate at most once
        for (var i = count - 1; i >= 0; i--) {
-            if (i + sourceStart < 0 || i + sourceStart >= size) arr.set(ctx, i + destStart, null);
+            if (i + sourceStart < 0 || i + sourceStart >= size) arr.remove(i + destStart);
            if (values[i + sourceStart] == UNDEFINED) arr.set(ctx, i + destStart, null);
+            else if (values[i + sourceStart] == null) arr.remove(i + destStart);
            else arr.set(ctx, i + destStart, values[i + sourceStart]);
        }
    }
@@ -97,7 +99,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
    }

    public void move(int srcI, int dstI, int n) {
-        alloc(dstI + n);
+        values = alloc(dstI + n);

        System.arraycopy(values, srcI, values, dstI, n);

@@ -122,7 +124,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
    }

    @Override
-    protected Object getField(Context ctx, Object key) throws InterruptedException {
+    protected Object getField(Context ctx, Object key) {
        if (key instanceof Number) {
            var i = ((Number)key).doubleValue();
            if (i >= 0 && i - Math.floor(i) == 0) {
@@ -133,7 +135,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        return super.getField(ctx, key);
    }
    @Override
-    protected boolean setField(Context ctx, Object key, Object val) throws InterruptedException {
+    protected boolean setField(Context ctx, Object key, Object val) {
        if (key instanceof Number) {
            var i = Values.number(key);
            if (i >= 0 && i - Math.floor(i) == 0) {
@@ -145,7 +147,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        return super.setField(ctx, key, val);
    }
    @Override
-    protected boolean hasField(Context ctx, Object key) throws InterruptedException {
+    protected boolean hasField(Context ctx, Object key) {
        if (key instanceof Number) {
            var i = Values.number(key);
            if (i >= 0 && i - Math.floor(i) == 0) {
@@ -156,7 +158,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        return super.hasField(ctx, key);
    }
    @Override
-    protected void deleteField(Context ctx, Object key) throws InterruptedException {
+    protected void deleteField(Context ctx, Object key) {
        if (key instanceof Number) {
            var i = Values.number(key);
            if (i >= 0 && i - Math.floor(i) == 0) {
@@ -212,7 +214,7 @@ public class ArrayValue extends ObjectValue implements Iterable<Object> {
        for (var i = 0; i < size; i++) this.values[i] = Values.normalize(ctx, values[i]);
    }

-    public static ArrayValue of(Context ctx, Collection<Object> values) {
+    public static ArrayValue of(Context ctx, Collection<?> values) {
        return new ArrayValue(ctx, values.toArray(Object[]::new));
    }
 }
--- a/src/me/topchetoeu/jscript/engine/values/CodeFunction.java
+++ b/src/me/topchetoeu/jscript/engine/values/CodeFunction.java
@@ -1,16 +1,18 @@
 package me.topchetoeu.jscript.engine.values;

 import me.topchetoeu.jscript.Location;
+import me.topchetoeu.jscript.compilation.FunctionBody;
 import me.topchetoeu.jscript.compilation.Instruction;
 import me.topchetoeu.jscript.engine.Context;
 import me.topchetoeu.jscript.engine.Environment;
 import me.topchetoeu.jscript.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.engine.frame.Runners;
 import me.topchetoeu.jscript.engine.scope.ValueVariable;

 public class CodeFunction extends FunctionValue {
    public final int localsN;
-    public final int length;
    public final Instruction[] body;
+    public final String[] captureNames, localNames;
    public final ValueVariable[] captures;
    public Environment environment;

@@ -28,16 +30,28 @@ public class CodeFunction extends FunctionValue {
    }

    @Override
-    public Object call(Context ctx, Object thisArg, Object ...args) throws InterruptedException {
-        return new CodeFrame(ctx, thisArg, args, this).run(ctx.setEnv(environment));
+    public Object call(Context ctx, Object thisArg, Object ...args) {
+        var frame = new CodeFrame(ctx, thisArg, args, this);
+        try {
+            ctx.pushFrame(frame);
+
+            while (true) {
+                var res = frame.next(ctx, Runners.NO_RETURN, Runners.NO_RETURN, null);
+                if (res != Runners.NO_RETURN) return res;
+            }
+        }
+        finally {
+            ctx.popFrame(frame);
+        }
    }

-    public CodeFunction(Environment environment, String name, int localsN, int length, ValueVariable[] captures, Instruction[] body) {
-        super(name, length);
+    public CodeFunction(Environment environment, String name, FunctionBody body, ValueVariable... captures) {
+        super(name, body.argsN);
        this.captures = captures;
+        this.captureNames = body.captureNames;
+        this.localNames = body.localNames;
        this.environment = environment;
-        this.localsN = localsN;
-        this.length = length;
-        this.body = body;
+        this.localsN = body.localsN;
+        this.body = body.instructions;
    }
 }
--- a/src/me/topchetoeu/jscript/engine/values/FunctionValue.java
+++ b/src/me/topchetoeu/jscript/engine/values/FunctionValue.java
@@ -11,31 +11,31 @@ public abstract class FunctionValue extends ObjectValue {

    @Override
    public String toString() {
-        return "function(...) {  ...}";
+        return String.format("function %s(...)", name);
    }

-    public abstract Object call(Context ctx, Object thisArg, Object ...args) throws InterruptedException;
-    public Object call(Context ctx) throws InterruptedException {
+    public abstract Object call(Context ctx, Object thisArg, Object ...args);
+    public Object call(Context ctx) {
        return call(ctx, null);
    }

    @Override
-    protected Object getField(Context ctx, Object key) throws InterruptedException {
-        if (key.equals("name")) return name;
-        if (key.equals("length")) return length;
+    protected Object getField(Context ctx, Object key) {
+        if ("name".equals(key)) return name;
+        if ("length".equals(key)) return length;
        return super.getField(ctx, key);
    }
    @Override
-    protected boolean setField(Context ctx, Object key, Object val) throws InterruptedException {
-        if (key.equals("name")) name = Values.toString(ctx, val);
-        else if (key.equals("length")) length = (int)Values.toNumber(ctx, val);
+    protected boolean setField(Context ctx, Object key, Object val) {
+        if ("name".equals(key)) name = Values.toString(ctx, val);
+        else if ("length".equals(key)) length = (int)Values.toNumber(ctx, val);
        else return super.setField(ctx, key, val);
        return true;
    }
    @Override
-    protected boolean hasField(Context ctx, Object key) throws InterruptedException {
-        if (key.equals("name")) return true;
-        if (key.equals("length")) return true;
+    protected boolean hasField(Context ctx, Object key) {
+        if ("name".equals(key)) return true;
+        if ("length".equals(key)) return true;
        return super.hasField(ctx, key);
    }

--- a/src/me/topchetoeu/jscript/engine/values/NativeFunction.java
+++ b/src/me/topchetoeu/jscript/engine/values/NativeFunction.java
@@ -4,13 +4,13 @@ import me.topchetoeu.jscript.engine.Context;

 public class NativeFunction extends FunctionValue {
    public static interface NativeFunctionRunner {
-        Object run(Context ctx, Object thisArg, Object[] args) throws InterruptedException;
+        Object run(Context ctx, Object thisArg, Object[] args);
    }

    public final NativeFunctionRunner action;

    @Override
-    public Object call(Context ctx, Object thisArg, Object ...args) throws InterruptedException {
+    public Object call(Context ctx, Object thisArg, Object ...args) {
        return action.run(ctx, thisArg, args);
    }

--- a/src/me/topchetoeu/jscript/engine/values/NativeWrapper.java
+++ b/src/me/topchetoeu/jscript/engine/values/NativeWrapper.java
@@ -7,12 +7,24 @@ public class NativeWrapper extends ObjectValue {
    public final Object wrapped;

    @Override
-    public ObjectValue getPrototype(Context ctx) throws InterruptedException {
-        if (prototype == NATIVE_PROTO)
-            return ctx.env.wrappersProvider.getProto(wrapped.getClass());
+    public ObjectValue getPrototype(Context ctx) {
+        if (prototype == NATIVE_PROTO) return ctx.environment().wrappers.getProto(wrapped.getClass());
        else return super.getPrototype(ctx);
    }

+    @Override
+    public String toString() {
+        return wrapped.toString();
+    }
+    @Override
+    public boolean equals(Object obj) {
+        return wrapped.equals(obj);
+    }
+    @Override
+    public int hashCode() {
+        return wrapped.hashCode();
+    }
+
    public NativeWrapper(Object wrapped) {
        this.wrapped = wrapped;
        prototype = NATIVE_PROTO;
--- a/src/me/topchetoeu/jscript/engine/values/ObjectValue.java
+++ b/src/me/topchetoeu/jscript/engine/values/ObjectValue.java
@@ -1,8 +1,8 @@
 package me.topchetoeu.jscript.engine.values;

 import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Map;

@@ -47,11 +47,11 @@ public class ObjectValue {
    protected Object prototype;

    public State state = State.NORMAL;
-    public HashMap<Object, Object> values = new HashMap<>();
-    public HashMap<Object, Property> properties = new HashMap<>();
-    public HashSet<Object> nonWritableSet = new HashSet<>();
-    public HashSet<Object> nonConfigurableSet = new HashSet<>();
-    public HashSet<Object> nonEnumerableSet = new HashSet<>();
+    public LinkedHashMap<Object, Object> values = new LinkedHashMap<>();
+    public LinkedHashMap<Object, Property> properties = new LinkedHashMap<>();
+    public LinkedHashSet<Object> nonWritableSet = new LinkedHashSet<>();
+    public LinkedHashSet<Object> nonConfigurableSet = new LinkedHashSet<>();
+    public LinkedHashSet<Object> nonEnumerableSet = new LinkedHashSet<>();

    public final boolean memberWritable(Object key) {
        if (state == State.FROZEN) return false;
@@ -103,8 +103,7 @@ public class ObjectValue {
        ) return true;

        if (!extensible() && !values.containsKey(key) && !properties.containsKey(key)) return false;
-        if (!memberConfigurable(key))
-            return false;
+        if (!memberConfigurable(key)) return false;

        nonWritableSet.remove(key);
        nonEnumerableSet.remove(key);
@@ -145,19 +144,17 @@ public class ObjectValue {
        return true;
    }

-    public ObjectValue getPrototype(Context ctx) throws InterruptedException {
+    public ObjectValue getPrototype(Context ctx) {
        try {
-            if (prototype == OBJ_PROTO) return ctx.env.proto("object");
-            if (prototype == ARR_PROTO) return ctx.env.proto("array");
-            if (prototype == FUNC_PROTO) return ctx.env.proto("function");
-            if (prototype == ERR_PROTO) return ctx.env.proto("error");
-            if (prototype == RANGE_ERR_PROTO) return ctx.env.proto("rangeErr");
-            if (prototype == SYNTAX_ERR_PROTO) return ctx.env.proto("syntaxErr");
-            if (prototype == TYPE_ERR_PROTO) return ctx.env.proto("typeErr");
-        }
-        catch (NullPointerException e) {
-            return null;
+            if (prototype == OBJ_PROTO) return ctx.environment().proto("object");
+            if (prototype == ARR_PROTO) return ctx.environment().proto("array");
+            if (prototype == FUNC_PROTO) return ctx.environment().proto("function");
+            if (prototype == ERR_PROTO) return ctx.environment().proto("error");
+            if (prototype == RANGE_ERR_PROTO) return ctx.environment().proto("rangeErr");
+            if (prototype == SYNTAX_ERR_PROTO) return ctx.environment().proto("syntaxErr");
+            if (prototype == TYPE_ERR_PROTO) return ctx.environment().proto("typeErr");
        }
+        catch (NullPointerException e) { return null; }

        return (ObjectValue)prototype;
    }
@@ -172,14 +169,14 @@ public class ObjectValue {
        else if (Values.isObject(val)) {
            var obj = Values.object(val);

-            if (ctx != null && ctx.env != null) {
-                if (obj == ctx.env.proto("object")) prototype = OBJ_PROTO;
-                else if (obj == ctx.env.proto("array")) prototype = ARR_PROTO;
-                else if (obj == ctx.env.proto("function")) prototype = FUNC_PROTO;
-                else if (obj == ctx.env.proto("error")) prototype = ERR_PROTO;
-                else if (obj == ctx.env.proto("syntaxErr")) prototype = SYNTAX_ERR_PROTO;
-                else if (obj == ctx.env.proto("typeErr")) prototype = TYPE_ERR_PROTO;
-                else if (obj == ctx.env.proto("rangeErr")) prototype = RANGE_ERR_PROTO;
+            if (ctx != null && ctx.environment() != null) {
+                if (obj == ctx.environment().proto("object")) prototype = OBJ_PROTO;
+                else if (obj == ctx.environment().proto("array")) prototype = ARR_PROTO;
+                else if (obj == ctx.environment().proto("function")) prototype = FUNC_PROTO;
+                else if (obj == ctx.environment().proto("error")) prototype = ERR_PROTO;
+                else if (obj == ctx.environment().proto("syntaxErr")) prototype = SYNTAX_ERR_PROTO;
+                else if (obj == ctx.environment().proto("typeErr")) prototype = TYPE_ERR_PROTO;
+                else if (obj == ctx.environment().proto("rangeErr")) prototype = RANGE_ERR_PROTO;
                else prototype = obj;
            }
            else prototype = obj;
@@ -203,19 +200,19 @@ public class ObjectValue {
        return true;
    }

-    protected Property getProperty(Context ctx, Object key) throws InterruptedException {
+    protected Property getProperty(Context ctx, Object key) {
        if (properties.containsKey(key)) return properties.get(key);
        var proto = getPrototype(ctx);
        if (proto != null) return proto.getProperty(ctx, key);
        else return null;
    }
-    protected Object getField(Context ctx, Object key) throws InterruptedException {
+    protected Object getField(Context ctx, Object key) {
        if (values.containsKey(key)) return values.get(key);
        var proto = getPrototype(ctx);
        if (proto != null) return proto.getField(ctx, key);
        else return null;
    }
-    protected boolean setField(Context ctx, Object key, Object val) throws InterruptedException {
+    protected boolean setField(Context ctx, Object key, Object val) {
        if (val instanceof FunctionValue && ((FunctionValue)val).name.equals("")) {
            ((FunctionValue)val).name = Values.toString(ctx, key);
        }
@@ -223,14 +220,14 @@ public class ObjectValue {
        values.put(key, val);
        return true;
    }
-    protected void deleteField(Context ctx, Object key) throws InterruptedException {
+    protected void deleteField(Context ctx, Object key) {
        values.remove(key);
    }
-    protected boolean hasField(Context ctx, Object key) throws InterruptedException {
+    protected boolean hasField(Context ctx, Object key) {
        return values.containsKey(key);
    }

-    public final Object getMember(Context ctx, Object key, Object thisArg) throws InterruptedException {
+    public final Object getMember(Context ctx, Object key, Object thisArg) {
        key = Values.normalize(ctx, key);

        if ("__proto__".equals(key)) {
@@ -246,11 +243,11 @@ public class ObjectValue {
        }
        else return getField(ctx, key);
    }
-    public final Object getMember(Context ctx, Object key) throws InterruptedException {
+    public final Object getMember(Context ctx, Object key) {
        return getMember(ctx, key, this);
    }

-    public final boolean setMember(Context ctx, Object key, Object val, Object thisArg, boolean onlyProps) throws InterruptedException {
+    public final boolean setMember(Context ctx, Object key, Object val, Object thisArg, boolean onlyProps) {
        key = Values.normalize(ctx, key); val = Values.normalize(ctx, val);

        var prop = getProperty(ctx, key);
@@ -265,25 +262,25 @@ public class ObjectValue {
            values.put(key, val);
            return true;
        }
-        else if (key.equals("__proto__")) return setPrototype(ctx, val);
+        else if ("__proto__".equals(key)) return setPrototype(ctx, val);
        else if (nonWritableSet.contains(key)) return false;
        else return setField(ctx, key, val);
    }
-    public final boolean setMember(Context ctx, Object key, Object val, boolean onlyProps) throws InterruptedException {
+    public final boolean setMember(Context ctx, Object key, Object val, boolean onlyProps) {
        return setMember(ctx, Values.normalize(ctx, key), Values.normalize(ctx, val), this, onlyProps);
    }

-    public final boolean hasMember(Context ctx, Object key, boolean own) throws InterruptedException {
+    public final boolean hasMember(Context ctx, Object key, boolean own) {
        key = Values.normalize(ctx, key);

-        if (key != null && key.equals("__proto__")) return true;
+        if (key != null && "__proto__".equals(key)) return true;
        if (hasField(ctx, key)) return true;
        if (properties.containsKey(key)) return true;
        if (own) return false;
        var proto = getPrototype(ctx);
        return proto != null && proto.hasMember(ctx, key, own);
    }
-    public final boolean deleteMember(Context ctx, Object key) throws InterruptedException {
+    public final boolean deleteMember(Context ctx, Object key) {
        key = Values.normalize(ctx, key);

        if (!memberConfigurable(key)) return false;
@@ -294,7 +291,7 @@ public class ObjectValue {
        return true;
    }

-    public final ObjectValue getMemberDescriptor(Context ctx, Object key) throws InterruptedException {
+    public final ObjectValue getMemberDescriptor(Context ctx, Object key) {
        key = Values.normalize(ctx, key);

        var prop = properties.get(key);
--- a/src/me/topchetoeu/jscript/engine/values/ScopeValue.java
+++ b/src/me/topchetoeu/jscript/engine/values/ScopeValue.java
@@ -0,0 +1,54 @@
+package me.topchetoeu.jscript.engine.values;
+
+import java.util.HashMap;
+import java.util.List;
+
+import me.topchetoeu.jscript.engine.Context;
+import me.topchetoeu.jscript.engine.scope.ValueVariable;
+
+public class ScopeValue extends ObjectValue {
+    public final ValueVariable[] variables;
+    public final HashMap<String, Integer> names = new HashMap<>();
+
+    @Override
+    protected Object getField(Context ctx, Object key) {
+        if (names.containsKey(key)) return variables[names.get(key)].get(ctx);
+        return super.getField(ctx, key);
+    }
+    @Override
+    protected boolean setField(Context ctx, Object key, Object val) {
+        if (names.containsKey(key)) {
+            variables[names.get(key)].set(ctx, val);
+            return true;
+        }
+
+        var proto = getPrototype(ctx);
+        if (proto != null && proto.hasField(ctx, key) && proto.setField(ctx, key, val)) return true;
+
+        return super.setField(ctx, key, val);
+    }
+    @Override
+    protected void deleteField(Context ctx, Object key) {
+        if (names.containsKey(key)) return;
+        super.deleteField(ctx, key);
+    }
+    @Override
+    protected boolean hasField(Context ctx, Object key) {
+        if (names.containsKey(key)) return true;
+        return super.hasField(ctx, key);
+    }
+    @Override
+    public List<Object> keys(boolean includeNonEnumerable) {
+        var res = super.keys(includeNonEnumerable);
+        res.addAll(names.keySet());
+        return res;
+    }
+
+    public ScopeValue(ValueVariable[] variables, String[] names) {
+        this.variables = variables;
+        for (var i = 0; i < names.length && i < variables.length; i++) {
+            this.names.put(names[i], i);
+            this.nonConfigurableSet.add(names[i]);
+        }
+    }
+}
--- a/src/me/topchetoeu/jscript/engine/values/SignalValue.java
+++ b/src/me/topchetoeu/jscript/engine/values/SignalValue.java
@@ -1,17 +0,0 @@
-package me.topchetoeu.jscript.engine.values;
-
-public final class SignalValue {
-    public final String data;
-
-    public SignalValue(String data) {
-        this.data = data;
-    }
-
-    public static boolean isSignal(Object signal, String value) {
-        if (!(signal instanceof SignalValue)) return false;
-        var val = ((SignalValue)signal).data;
-
-        if (value.endsWith("*")) return val.startsWith(value.substring(0, value.length() - 1));
-        else return val.equals(value);
-    }
-}
--- a/src/me/topchetoeu/jscript/engine/values/Values.java
+++ b/src/me/topchetoeu/jscript/engine/values/Values.java
@@ -16,8 +16,28 @@ import me.topchetoeu.jscript.engine.frame.ConvertHint;
 import me.topchetoeu.jscript.exceptions.ConvertException;
 import me.topchetoeu.jscript.exceptions.EngineException;
 import me.topchetoeu.jscript.exceptions.SyntaxException;
+import me.topchetoeu.jscript.exceptions.UncheckedException;
+import me.topchetoeu.jscript.lib.PromiseLib;

 public class Values {
+    public static enum CompareResult {
+        NOT_EQUAL,
+        EQUAL,
+        LESS,
+        GREATER;
+
+        public boolean less() { return this == LESS; }
+        public boolean greater() { return this == GREATER; }
+        public boolean lessOrEqual() { return this == LESS || this == EQUAL; }
+        public boolean greaterOrEqual() { return this == GREATER || this == EQUAL; }
+
+        public static CompareResult from(int cmp) {
+            if (cmp < 0) return LESS;
+            if (cmp > 0) return GREATER;
+            return EQUAL;
+        }
+    }
+
    public static final Object NULL = new Object();

    public static boolean isObject(Object val) { return val instanceof ObjectValue; }
@@ -50,8 +70,7 @@ public class Values {

    @SuppressWarnings("unchecked")
    public static <T> T wrapper(Object val, Class<T> clazz) { 
-        if (!isWrapper(val)) return null;
-
+        if (!isWrapper(val)) val = new NativeWrapper(val);
        var res = (NativeWrapper)val;
        if (res != null && clazz.isInstance(res.wrapped)) return (T)res.wrapped;
        else return null;
@@ -67,7 +86,7 @@ public class Values {
        return "object";
    }

-    private static Object tryCallConvertFunc(Context ctx, Object obj, String name) throws InterruptedException {
+    private static Object tryCallConvertFunc(Context ctx, Object obj, String name) {
        var func = getMember(ctx, obj, name);

        if (func != null) {
@@ -84,12 +103,11 @@ public class Values {
            obj instanceof String ||
            obj instanceof Boolean ||
            obj instanceof Symbol ||
-            obj instanceof SignalValue ||
            obj == null ||
            obj == NULL;
    }

-    public static Object toPrimitive(Context ctx, Object obj, ConvertHint hint) throws InterruptedException {
+    public static Object toPrimitive(Context ctx, Object obj, ConvertHint hint) {
        obj = normalize(ctx, obj);
        if (isPrimitive(obj)) return obj;

@@ -97,37 +115,32 @@ public class Values {
        var second = hint == ConvertHint.VALUEOF ? "toString" : "valueOf";

        if (ctx != null) {
-            try {
-                return tryCallConvertFunc(ctx, obj, first);
-            }
-            catch (EngineException unused) {
-                return tryCallConvertFunc(ctx, obj, second);
-            }
+            try { return tryCallConvertFunc(ctx, obj, first); }
+            catch (EngineException unused) { return tryCallConvertFunc(ctx, obj, second); }
        }

        throw EngineException.ofType("Value couldn't be converted to a primitive.");
    }
    public static boolean toBoolean(Object obj) {
        if (obj == NULL || obj == null) return false;
-        if (obj instanceof Number && number(obj) == 0) return false;
+        if (obj instanceof Number && (number(obj) == 0 || Double.isNaN(number(obj)))) return false;
        if (obj instanceof String && ((String)obj).equals("")) return false;
        if (obj instanceof Boolean) return (Boolean)obj;
        return true;
    }
-    public static double toNumber(Context ctx, Object obj) throws InterruptedException {
+    public static double toNumber(Context ctx, Object obj) {
        var val = toPrimitive(ctx, obj, ConvertHint.VALUEOF);

        if (val instanceof Number) return number(val);
        if (val instanceof Boolean) return ((Boolean)val) ? 1 : 0;
        if (val instanceof String) {
-            try {
-                return Double.parseDouble((String)val);
-            }
-            catch (NumberFormatException e) { }
+            try { return Double.parseDouble((String)val); }
+            catch (NumberFormatException e) { return Double.NaN; }
+            catch (Throwable e) { throw new UncheckedException(e); }
        }
        return Double.NaN;
    }
-    public static String toString(Context ctx, Object obj) throws InterruptedException {
+    public static String toString(Context ctx, Object obj) {
        var val = toPrimitive(ctx, obj, ConvertHint.VALUEOF);

        if (val == null) return "undefined";
@@ -142,53 +155,52 @@ public class Values {
        }
        if (val instanceof Boolean) return (Boolean)val ? "true" : "false";
        if (val instanceof String) return (String)val;
-        if (val instanceof Symbol) return ((Symbol)val).toString();
-        if (val instanceof SignalValue) return "[signal '" + ((SignalValue)val).data + "']";
+        if (val instanceof Symbol) return val.toString();

        return "Unknown value";
    }

-    public static Object add(Context ctx, Object a, Object b) throws InterruptedException {
+    public static Object add(Context ctx, Object a, Object b) {
        if (a instanceof String || b instanceof String) return toString(ctx, a) + toString(ctx, b);
        else return toNumber(ctx, a) + toNumber(ctx, b);
    }
-    public static double subtract(Context ctx, Object a, Object b) throws InterruptedException {
+    public static double subtract(Context ctx, Object a, Object b) {
        return toNumber(ctx, a) - toNumber(ctx, b);
    }
-    public static double multiply(Context ctx, Object a, Object b) throws InterruptedException {
+    public static double multiply(Context ctx, Object a, Object b) {
        return toNumber(ctx, a) * toNumber(ctx, b);
    }
-    public static double divide(Context ctx, Object a, Object b) throws InterruptedException {
+    public static double divide(Context ctx, Object a, Object b) {
        return toNumber(ctx, a) / toNumber(ctx, b);
    }
-    public static double modulo(Context ctx, Object a, Object b) throws InterruptedException {
+    public static double modulo(Context ctx, Object a, Object b) {
        return toNumber(ctx, a) % toNumber(ctx, b);
    }
    
-    public static double negative(Context ctx, Object obj) throws InterruptedException {
+    public static double negative(Context ctx, Object obj) {
        return -toNumber(ctx, obj);
    }

-    public static int and(Context ctx, Object a, Object b) throws InterruptedException {
+    public static int and(Context ctx, Object a, Object b) {
        return (int)toNumber(ctx, a) & (int)toNumber(ctx, b);
    }
-    public static int or(Context ctx, Object a, Object b) throws InterruptedException {
+    public static int or(Context ctx, Object a, Object b) {
        return (int)toNumber(ctx, a) | (int)toNumber(ctx, b);
    }
-    public static int xor(Context ctx, Object a, Object b) throws InterruptedException {
+    public static int xor(Context ctx, Object a, Object b) {
        return (int)toNumber(ctx, a) ^ (int)toNumber(ctx, b);
    }
-    public static int bitwiseNot(Context ctx, Object obj) throws InterruptedException {
+    public static int bitwiseNot(Context ctx, Object obj) {
        return ~(int)toNumber(ctx, obj);
    }

-    public static int shiftLeft(Context ctx, Object a, Object b) throws InterruptedException {
+    public static int shiftLeft(Context ctx, Object a, Object b) {
        return (int)toNumber(ctx, a) << (int)toNumber(ctx, b);
    }
-    public static int shiftRight(Context ctx, Object a, Object b) throws InterruptedException {
+    public static int shiftRight(Context ctx, Object a, Object b) {
        return (int)toNumber(ctx, a) >> (int)toNumber(ctx, b);
    }
-    public static long unsignedShiftRight(Context ctx, Object a, Object b) throws InterruptedException {
+    public static long unsignedShiftRight(Context ctx, Object a, Object b) {
        long _a = (long)toNumber(ctx, a);
        long _b = (long)toNumber(ctx, b);

@@ -197,19 +209,25 @@ public class Values {
        return _a >>> _b;
    }

-    public static int compare(Context ctx, Object a, Object b) throws InterruptedException {
+    public static CompareResult compare(Context ctx, Object a, Object b) {
        a = toPrimitive(ctx, a, ConvertHint.VALUEOF);
        b = toPrimitive(ctx, b, ConvertHint.VALUEOF);

-        if (a instanceof String && b instanceof String) return ((String)a).compareTo((String)b);
-        else return Double.compare(toNumber(ctx, a), toNumber(ctx, b));
+        if (a instanceof String && b instanceof String) CompareResult.from(((String)a).compareTo((String)b));
+
+        var _a = toNumber(ctx, a);
+        var _b = toNumber(ctx, b);
+
+        if (Double.isNaN(_a) || Double.isNaN(_b)) return CompareResult.NOT_EQUAL;
+
+        return CompareResult.from(Double.compare(_a, _b));
    }

    public static boolean not(Object obj) {
        return !toBoolean(obj);
    }

-    public static boolean isInstanceOf(Context ctx, Object obj, Object proto) throws InterruptedException {
+    public static boolean isInstanceOf(Context ctx, Object obj, Object proto) {
        if (obj == null || obj == NULL || proto == null || proto == NULL) return false;
        var val = getPrototype(ctx, obj);

@@ -221,7 +239,7 @@ public class Values {
        return false;
    }

-    public static Object operation(Context ctx, Operation op, Object ...args) throws InterruptedException {
+    public static Object operation(Context ctx, Operation op, Object ...args) {
        switch (op) {
            case ADD: return add(ctx, args[0], args[1]);
            case SUBTRACT: return subtract(ctx, args[0], args[1]);
@@ -238,10 +256,10 @@ public class Values {
            case LOOSE_EQUALS: return looseEqual(ctx, args[0], args[1]);
            case LOOSE_NOT_EQUALS: return !looseEqual(ctx, args[0], args[1]);

-            case GREATER: return compare(ctx, args[0], args[1]) > 0;
-            case GREATER_EQUALS: return compare(ctx, args[0], args[1]) >= 0;
-            case LESS: return compare(ctx, args[0], args[1]) < 0;
-            case LESS_EQUALS: return compare(ctx, args[0], args[1]) <= 0;
+            case GREATER: return compare(ctx, args[0], args[1]).greater();
+            case GREATER_EQUALS: return compare(ctx, args[0], args[1]).greaterOrEqual();
+            case LESS: return compare(ctx, args[0], args[1]).less();
+            case LESS_EQUALS: return compare(ctx, args[0], args[1]).lessOrEqual();

            case INVERSE: return bitwiseNot(ctx, args[0]);
            case NOT: return not(args[0]);
@@ -262,7 +280,7 @@ public class Values {
        }
    }

-    public static Object getMember(Context ctx, Object obj, Object key) throws InterruptedException {
+    public static Object getMember(Context ctx, Object obj, Object key) {
        obj = normalize(ctx, obj); key = normalize(ctx, key);
        if (obj == null) throw new IllegalArgumentException("Tried to access member of undefined.");
        if (obj == NULL) throw new IllegalArgumentException("Tried to access member of null.");
@@ -278,25 +296,30 @@ public class Values {

        var proto = getPrototype(ctx, obj);

-        if (proto == null) return key.equals("__proto__") ? NULL : null;
-        else if (key != null && key.equals("__proto__")) return proto;
+        if (proto == null) return "__proto__".equals(key) ? NULL : null;
+        else if (key != null && "__proto__".equals(key)) return proto;
        else return proto.getMember(ctx, key, obj);
    }
-    public static boolean setMember(Context ctx, Object obj, Object key, Object val) throws InterruptedException {
+    public static Object getMemberPath(Context ctx, Object obj, Object ...path) {
+        var res = obj;
+        for (var key : path) res = getMember(ctx, res, key);
+        return res;
+    }
+    public static boolean setMember(Context ctx, Object obj, Object key, Object val) {
        obj = normalize(ctx, obj); key = normalize(ctx, key); val = normalize(ctx, val);
        if (obj == null) throw EngineException.ofType("Tried to access member of undefined.");
        if (obj == NULL) throw EngineException.ofType("Tried to access member of null.");
-        if (key.equals("__proto__")) return setPrototype(ctx, obj, val);
+        if (key != null && "__proto__".equals(key)) return setPrototype(ctx, obj, val);
        if (isObject(obj)) return object(obj).setMember(ctx, key, val, false);

        var proto = getPrototype(ctx, obj);
        return proto.setMember(ctx, key, val, obj, true);
    }
-    public static boolean hasMember(Context ctx, Object obj, Object key, boolean own) throws InterruptedException {
+    public static boolean hasMember(Context ctx, Object obj, Object key, boolean own) {
        if (obj == null || obj == NULL) return false;
        obj = normalize(ctx, obj); key = normalize(ctx, key);

-        if (key.equals("__proto__")) return true;
+        if ("__proto__".equals(key)) return true;
        if (isObject(obj)) return object(obj).hasMember(ctx, key, own);

        if (obj instanceof String && key instanceof Number) {
@@ -310,31 +333,31 @@ public class Values {
        var proto = getPrototype(ctx, obj);
        return proto != null && proto.hasMember(ctx, key, own);
    }
-    public static boolean deleteMember(Context ctx, Object obj, Object key) throws InterruptedException {
+    public static boolean deleteMember(Context ctx, Object obj, Object key) {
        if (obj == null || obj == NULL) return false;
        obj = normalize(ctx, obj); key = normalize(ctx, key);

        if (isObject(obj)) return object(obj).deleteMember(ctx, key);
        else return false;
    }
-    public static ObjectValue getPrototype(Context ctx, Object obj) throws InterruptedException {
+    public static ObjectValue getPrototype(Context ctx, Object obj) {
        if (obj == null || obj == NULL) return null;
        obj = normalize(ctx, obj);
        if (isObject(obj)) return object(obj).getPrototype(ctx);
        if (ctx == null) return null;

-        if (obj instanceof String) return ctx.env.proto("string");
-        else if (obj instanceof Number) return ctx.env.proto("number");
-        else if (obj instanceof Boolean) return ctx.env.proto("bool");
-        else if (obj instanceof Symbol) return ctx.env.proto("symbol");
+        if (obj instanceof String) return ctx.environment().proto("string");
+        else if (obj instanceof Number) return ctx.environment().proto("number");
+        else if (obj instanceof Boolean) return ctx.environment().proto("bool");
+        else if (obj instanceof Symbol) return ctx.environment().proto("symbol");

        return null;
    }
-    public static boolean setPrototype(Context ctx, Object obj, Object proto) throws InterruptedException {
+    public static boolean setPrototype(Context ctx, Object obj, Object proto) {
        obj = normalize(ctx, obj);
        return isObject(obj) && object(obj).setPrototype(ctx, proto);
    }
-    public static List<Object> getMembers(Context ctx, Object obj, boolean own, boolean includeNonEnumerable) throws InterruptedException {  
+    public static List<Object> getMembers(Context ctx, Object obj, boolean own, boolean includeNonEnumerable) {  
        List<Object> res = new ArrayList<>();

        if (isObject(obj)) res = object(obj).keys(includeNonEnumerable);
@@ -354,7 +377,7 @@ public class Values {

        return res;
    }
-    public static ObjectValue getMemberDescriptor(Context ctx, Object obj, Object key) throws InterruptedException {
+    public static ObjectValue getMemberDescriptor(Context ctx, Object obj, Object key) {
        if (obj instanceof ObjectValue) return ((ObjectValue)obj).getMemberDescriptor(ctx, key);
        else if (obj instanceof String && key instanceof Number) {
            var i = ((Number)key).intValue();
@@ -372,19 +395,24 @@ public class Values {
        else return null;
    }

-    public static Object call(Context ctx, Object func, Object thisArg, Object ...args) throws InterruptedException {
+    public static Object call(Context ctx, Object func, Object thisArg, Object ...args) {
        if (!isFunction(func)) throw EngineException.ofType("Tried to call a non-function value.");
        return function(func).call(ctx, thisArg, args);
    }
-    public static Object callNew(Context ctx, Object func, Object ...args) throws InterruptedException {
+    public static Object callNew(Context ctx, Object func, Object ...args) {
        var res = new ObjectValue();
-        var proto = Values.getMember(ctx, func, "prototype");
-        res.setPrototype(ctx, proto);
-
-        var ret = call(ctx, func, res, args);
-
-        if (ret != null && func instanceof FunctionValue && ((FunctionValue)func).special) return ret;
-        return res;
+        try {
+            var proto = Values.getMember(ctx, func, "prototype");
+            res.setPrototype(ctx, proto);
+    
+            var ret = call(ctx, func, res, args);
+    
+            if (ret != null && func instanceof FunctionValue && ((FunctionValue)func).special) return ret;
+            return res;
+        }
+        catch (IllegalArgumentException e) {
+            throw EngineException.ofType("Tried to call new on an invalid constructor.");
+        }
    }

    public static boolean strictEquals(Context ctx, Object a, Object b) {
@@ -397,7 +425,7 @@ public class Values {

        return a == b || a.equals(b);
    }
-    public static boolean looseEqual(Context ctx, Object a, Object b) throws InterruptedException {
+    public static boolean looseEqual(Context ctx, Object a, Object b) {
        a = normalize(ctx, a); b = normalize(ctx, b);

        // In loose equality, null is equivalent to undefined
@@ -448,14 +476,14 @@ public class Values {

        if (val instanceof Class) {
            if (ctx == null) return null;
-            else return ctx.env.wrappersProvider.getConstr((Class<?>)val);
+            else return ctx.environment().wrappers.getConstr((Class<?>)val);
        }

        return new NativeWrapper(val);
    }

    @SuppressWarnings("unchecked")
-    public static <T> T convert(Context ctx, Object obj, Class<T> clazz) throws InterruptedException {
+    public static <T> T convert(Context ctx, Object obj, Class<T> clazz) {
        if (clazz == Void.class) return null;

        if (obj instanceof NativeWrapper) {
@@ -519,10 +547,10 @@ public class Values {
        throw new ConvertException(type(obj), clazz.getSimpleName());
    }

-    public static Iterable<Object> toJavaIterable(Context ctx, Object obj) {
+    public static Iterable<Object> fromJSIterator(Context ctx, Object obj) {
        return () -> {
            try {
-                var symbol = ctx.env.symbol("Symbol.iterator");
+                var symbol = ctx.environment().symbol("Symbol.iterator");

                var iteratorFunc = getMember(ctx, obj, symbol);
                if (!isFunction(iteratorFunc)) return Collections.emptyIterator();
@@ -538,7 +566,7 @@ public class Values {
                    public boolean consumed = true;
                    private FunctionValue next = (FunctionValue)nextFunc;

-                    private void loadNext() throws InterruptedException {
+                    private void loadNext() {
                        if (next == null) value = null;
                        else if (consumed) {
                            var curr = object(next.call(ctx, iterator));
@@ -553,63 +581,89 @@ public class Values {

                    @Override
                    public boolean hasNext() {
-                        try {
-                            loadNext();
-                            return next != null;
-                        }
-                        catch (InterruptedException e) {
-                            Thread.currentThread().interrupt();
-                            return false;
-                        }
+                        loadNext();
+                        return next != null;
                    }
                    @Override
                    public Object next() {
-                        try {
-                            loadNext();
-                            var res = value;
-                            value = null;
-                            consumed = true;
-                            return res;
-                        }
-                        catch (InterruptedException e) {
-                            Thread.currentThread().interrupt();
-                            return null;
-                        }
+                        loadNext();
+                        var res = value;
+                        value = null;
+                        consumed = true;
+                        return res;
                    }
                };
            }
-            catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-                return null;
-            }
            catch (IllegalArgumentException | NullPointerException e) {
                return Collections.emptyIterator();
            }
        };
    }

-    public static ObjectValue fromJavaIterator(Context ctx, Iterator<?> it) throws InterruptedException {
+    public static ObjectValue toJSIterator(Context ctx, Iterator<?> it) {
        var res = new ObjectValue();

        try {
-            var key = getMember(ctx, getMember(ctx, ctx.env.proto("symbol"), "constructor"), "iterator");
+            var key = getMember(ctx, getMember(ctx, ctx.environment().proto("symbol"), "constructor"), "iterator");
            res.defineProperty(ctx, key, new NativeFunction("", (_ctx, thisArg, args) -> thisArg));
        }
        catch (IllegalArgumentException | NullPointerException e) { }

        res.defineProperty(ctx, "next", new NativeFunction("", (_ctx, _th, _args) -> {
            if (!it.hasNext()) return new ObjectValue(ctx, Map.of("done", true));
-            else return new ObjectValue(ctx, Map.of("value", it.next()));
+            else {
+                var obj = new ObjectValue();
+                obj.defineProperty(_ctx, "value", it.next());
+                return obj;
+            }
        }));

        return res;
    }

-    public static ObjectValue fromJavaIterable(Context ctx, Iterable<?> it) throws InterruptedException {
-        return fromJavaIterator(ctx, it.iterator());
+    public static ObjectValue toJSIterator(Context ctx, Iterable<?> it) {
+        return toJSIterator(ctx, it.iterator());
    }

-    private static void printValue(Context ctx, Object val, HashSet<Object> passed, int tab) throws InterruptedException {
+    public static ObjectValue toJSAsyncIterator(Context ctx, Iterator<?> it) {
+        var res = new ObjectValue();
+
+        try {
+            var key = getMemberPath(ctx, ctx.environment().proto("symbol"), "constructor", "asyncIterator");
+            res.defineProperty(ctx, key, new NativeFunction("", (_ctx, thisArg, args) -> thisArg));
+        }
+        catch (IllegalArgumentException | NullPointerException e) { }
+
+        res.defineProperty(ctx, "next", new NativeFunction("", (_ctx, _th, _args) -> {
+            return PromiseLib.await(ctx, () -> {
+                if (!it.hasNext()) return new ObjectValue(ctx, Map.of("done", true));
+                else {
+                    var obj = new ObjectValue();
+                    obj.defineProperty(_ctx, "value", it.next());
+                    return obj;
+                }
+            });
+        }));
+
+        return res;
+    }
+
+    private static boolean isEmptyFunc(ObjectValue val) {
+        if (!(val instanceof FunctionValue)) return false;
+        if (!val.values.containsKey("prototype") || val.values.size() + val.properties.size() > 1) return false;
+        var proto = val.values.get("prototype");
+        if (!(proto instanceof ObjectValue)) return false;
+        var protoObj = (ObjectValue)proto;
+        if (protoObj.values.get("constructor") != val) return false;
+        if (protoObj.values.size() + protoObj.properties.size() != 1) return false;
+        return true;
+    }
+    private static void printValue(Context ctx, Object val, HashSet<Object> passed, int tab) {
+        if (tab == 0 && val instanceof String) {
+            System.out.print(val);
+            return;
+        }
+
        if (passed.contains(val)) {
            System.out.print("[circular]");
            return;
@@ -618,10 +672,7 @@ public class Values {
        var printed = true;

        if (val instanceof FunctionValue) {
-            System.out.print("function ");
-            var name = Values.getMember(ctx, val, "name");
-            if (name != null) System.out.print(Values.toString(ctx, name));
-            System.out.print("(...)");
+            System.out.print(val.toString());
            var loc = val instanceof CodeFunction ? ((CodeFunction)val).loc() : null;

            if (loc != null) System.out.print(" @ " + loc);
@@ -651,7 +702,7 @@ public class Values {
            passed.add(val);

            var obj = (ObjectValue)val;
-            if (obj.values.size() + obj.properties.size() == 0) {
+            if (obj.values.size() + obj.properties.size() == 0 || isEmptyFunc(obj)) {
                if (!printed) System.out.println("{}");
            }
            else {
@@ -669,26 +720,28 @@ public class Values {
                    printValue(ctx, el.getKey(), passed, tab + 1);
                    System.out.println(": [prop],");
                }
-    
+
                for (int i = 0; i < tab; i++) System.out.print("    ");
                System.out.print("}");
-    
-                passed.remove(val);
+
            }
+
+            passed.remove(val);
        }
        else if (val == null) System.out.print("undefined");
        else if (val == Values.NULL) System.out.print("null");
        else if (val instanceof String) System.out.print("'" + val + "'");
        else System.out.print(Values.toString(ctx, val));
    }
-    public static void printValue(Context ctx, Object val) throws InterruptedException {
+    public static void printValue(Context ctx, Object val) {
        printValue(ctx, val, new HashSet<>(), 0);
    }
-    public static void printError(RuntimeException err, String prefix) throws InterruptedException {
+    public static void printError(RuntimeException err, String prefix) {
        prefix = prefix == null ? "Uncaught" : "Uncaught " + prefix;
        try {
            if (err instanceof EngineException) {
-                System.out.println(prefix + " " + ((EngineException)err).toString(((EngineException)err).ctx));
+                var ee = ((EngineException)err);
+                System.out.println(prefix + " " + ee.toString(new Context(ee.engine).pushEnv(ee.env)));
            }
            else if (err instanceof SyntaxException) {
                System.out.println("Syntax error:" + ((SyntaxException)err).msg);
--- a/src/me/topchetoeu/jscript/events/Awaitable.java
+++ b/src/me/topchetoeu/jscript/events/Awaitable.java
@@ -1,7 +1,9 @@
 package me.topchetoeu.jscript.events;

+import me.topchetoeu.jscript.exceptions.InterruptException;
+
 public interface Awaitable<T> {
-    T await() throws FinishedException, InterruptedException;
+    T await() throws FinishedException;

    default Observable<T> toObservable() {
        return sub -> {
@@ -10,9 +12,7 @@ public interface Awaitable<T> {
                    sub.next(await());
                    sub.finish();
                }
-                catch (InterruptedException | FinishedException e) {
-                    sub.finish();
-                }
+                catch (InterruptException | FinishedException e) { sub.finish(); }
                catch (RuntimeException e) {
                    sub.error(e);
                }
--- a/src/me/topchetoeu/jscript/events/DataNotifier.java
+++ b/src/me/topchetoeu/jscript/events/DataNotifier.java
@@ -19,7 +19,7 @@ public class DataNotifier<T> implements Awaitable<T> {
        isErr = false;
        notifier.next();
    }
-    public T await() throws InterruptedException {
+    public T await() {
        notifier.await();

        try {
--- a/src/me/topchetoeu/jscript/events/Notifier.java
+++ b/src/me/topchetoeu/jscript/events/Notifier.java
@@ -1,5 +1,7 @@
 package me.topchetoeu.jscript.events;

+import me.topchetoeu.jscript.exceptions.InterruptException;
+
 public class Notifier {
    private boolean ok = false;

@@ -7,8 +9,11 @@ public class Notifier {
        ok = true;
        notifyAll();
    }
-    public synchronized void await() throws InterruptedException {
-        while (!ok) wait();
-        ok = false;
+    public synchronized void await() {
+        try {
+            while (!ok) wait();
+            ok = false;
+        }
+        catch (InterruptedException e) { throw new InterruptException(e); }
    }
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
TopchetoEU	8c6379eb24	Merge pull request #10 from TopchetoEU/TopchetoEU/mapping Add support for source mappings	2023-12-18 22:42:38 +02:00
TopchetoEU	380a5c720a	feat: make environment hidable from stack trace	2023-12-18 22:38:26 +02:00
TopchetoEU	76c3d377af	feat: use mappings in stack traces	2023-12-18 22:30:14 +02:00
TopchetoEU	42f443572a	fix: how the hell did i fix this (it was the cache all along)	2023-12-18 22:11:08 +02:00
TopchetoEU	773bc72f3e	refactor: rename compileWithDebug to compile	2023-12-14 21:07:16 +02:00
TopchetoEU	0b5178e9fd	fix: return minified typescript	2023-12-14 21:06:23 +02:00
TopchetoEU	8cffcff7db	refactor: remove unused instructions	2023-12-14 17:02:24 +02:00
TopchetoEU	60bbaaccd4	fix: some issues with try-catch	2023-12-14 16:49:51 +02:00
TopchetoEU	60b1762462	refactor: remove printf	2023-12-14 16:49:35 +02:00
TopchetoEU	34434965d2	cant be fucked to split this one up	2023-12-14 12:39:01 +02:00
TopchetoEU	fe86123f0f	refactor: improve function statement	2023-11-29 13:04:41 +02:00
TopchetoEU	d5e6edfa8b	refactor: replace .locate with argument	2023-11-29 13:03:53 +02:00
TopchetoEU	73345062ca	feat: implement new API with source maps	2023-11-28 21:40:37 +02:00
TopchetoEU	124341969c	fix: simplify source map API	2023-11-28 21:39:25 +02:00
TopchetoEU	8defd93855	fix: use proper name for native constructors	2023-11-28 21:37:46 +02:00
TopchetoEU	6c57e0e9f2	fix: properly handle wrapper function	2023-11-28 21:37:13 +02:00
TopchetoEU	f1932914ee	fix: move debugger assets to correct location	2023-11-27 20:28:02 +02:00
TopchetoEU	977701e601	feat: implement source maps	2023-11-26 16:50:07 +02:00
TopchetoEU	e8a7ac8da8	refactor: reorganize assets	2023-11-26 16:49:47 +02:00
TopchetoEU	6b1cb852c2	fix: arrays wrongly stringified in JSONLib	2023-11-26 13:51:56 +02:00
TopchetoEU	b59a003086	feat: implement VLQ parsing	2023-11-26 13:51:43 +02:00
TopchetoEU	1902e41f61	feat: make typescript output mappings	2023-11-26 11:52:47 +02:00
TopchetoEU	27162ef8ac	feat: improve Bufffer API	2023-11-26 11:51:32 +02:00
TopchetoEU	4f22e76d2b	fix: make code java 11 compatible	2023-11-25 20:22:16 +02:00
TopchetoEU	8924e7aadc	build: fix build script to exit with code when error occurs	2023-11-25 20:16:06 +02:00
TopchetoEU	1d0e31a423	Merge pull request #9 from TopchetoEU/TopchetoEU/perms-and-fs Permissions and filesystems	2023-11-25 20:10:59 +02:00
TopchetoEU	ab56908171	fix: faulty insufficient permissions error	2023-11-25 20:09:59 +02:00
TopchetoEU	eb14bb080c	fix: debugger breakpoints not registered	2023-11-25 20:09:47 +02:00
TopchetoEU	f52f47cdb4	feat: properly implement filesystems	2023-11-25 19:36:18 +02:00
TopchetoEU	567eaa8514	fix: incorrect declarations	2023-11-25 19:13:20 +02:00
TopchetoEU	2cfdd8e335	feat: add utf8 encoding and decoding	2023-11-25 19:12:56 +02:00
TopchetoEU	4b1ec671e2	fix: micro tasks not handled properly	2023-11-25 18:58:35 +02:00
TopchetoEU	b127aadcf6	fix: promise was sending macro tasks instead of micro	2023-11-25 18:58:24 +02:00
TopchetoEU	b6eaff65ca	style: remove unnececeary import	2023-11-25 18:48:46 +02:00
TopchetoEU	443dc0ffa1	feat: add await function to promise	2023-11-25 18:47:51 +02:00
TopchetoEU	e107dd3507	fix: promise doesn't use microtasks in some cases	2023-11-25 18:47:36 +02:00
TopchetoEU	6af3c70fce	feat: add filesystem libs	2023-11-25 18:47:01 +02:00
TopchetoEU	8b743f49d1	feat: add toString, equals and hashCode overrides to wrappers and objects	2023-11-25 18:46:13 +02:00
TopchetoEU	e1ce384815	feat: add parse function to Filename	2023-11-25 18:44:27 +02:00
TopchetoEU	86d205e521	fix: parsing files won't modify last instruction to RET, instead will just append it	2023-11-25 18:44:11 +02:00
TopchetoEU	f0ad936e5b	refactor: use new iterable names	2023-11-25 18:43:43 +02:00
TopchetoEU	4a1473c5be	fix: sorting with no comparator now works	2023-11-25 18:42:54 +02:00
TopchetoEU	4111dbf5c4	fix: functions now print their name when stringified	2023-11-25 18:41:47 +02:00
TopchetoEU	1666682dc2	refactor: get rid of data parent hierarchy	2023-11-25 18:41:18 +02:00
TopchetoEU	f2b33d0233	feat: add support for async iterators fix: comparasions had small behavioural issue	2023-11-25 18:40:49 +02:00
TopchetoEU	f5a0b6eaf7	fix: some improvements of compiled bytecode	2023-11-25 18:38:43 +02:00
TopchetoEU	829bea755d	fix: CodeFrame didnt't handle out of bounds jumps well	2023-11-25 18:38:16 +02:00
TopchetoEU	4b0dcffd13	feat: add fs declarations in lib.d.ts	2023-11-25 18:37:40 +02:00
TopchetoEU	987f8b8f00	fix: handle native errors properly-ish	2023-11-25 14:18:46 +02:00
TopchetoEU	55e3d46bc2	feat: implement memory and root fs	2023-11-25 14:18:04 +02:00
TopchetoEU	3e25068219	feat: implement bulk of fs	2023-11-25 14:17:37 +02:00
TopchetoEU	7ecb8bfabb	feat: implement permissions	2023-11-25 14:16:02 +02:00
TopchetoEU	488deea164	fix: improve performance of typescript by caching separate declarations	2023-11-14 09:24:39 +02:00
TopchetoEU	ed08041335	fix: internal error when trying to use key of "undefined"	2023-11-14 09:24:00 +02:00
TopchetoEU	0a4149ba81	fix: remove double space in "Uncaught ..."	2023-11-14 09:23:15 +02:00
TopchetoEU	30f5d619c3	fix: errors now have the right prototype and name	2023-11-14 09:22:56 +02:00
TopchetoEU	e7dbe91374	refactor: clean up protocol.json	2023-11-13 20:06:07 +02:00
TopchetoEU	455f5a613e	feat: implement simple permission matching	2023-11-13 19:09:33 +02:00
TopchetoEU	1eeac3ae97	fix: replace templates in Metadata class with placeholder data	2023-11-13 19:08:56 +02:00
TopchetoEU	1acd78e119	refactor: clean up Main class	2023-11-13 18:56:59 +02:00
TopchetoEU	df9932874d	feat: remove unnececeary @NativeInit directives	2023-11-06 14:03:15 +02:00
TopchetoEU	b47d1a7576	refactor: remove StackData and Data usage	2023-11-06 13:53:36 +02:00
TopchetoEU	fdfa8d7713	refactor: some minor fixes, rewrite README example	2023-11-06 10:55:38 +02:00
TopchetoEU	f5d1287948	fix: some annoying bugs, as well as splice	2023-11-06 00:55:30 +02:00
TopchetoEU	15f4278cb1	fix: build with java 17	2023-11-05 21:00:39 +02:00
TopchetoEU	df8465cb49	Merge pull request #8 from TopchetoEU/TopchetoEU/tests Integrate typescript	2023-11-05 20:32:42 +02:00
TopchetoEU	e3104c223c	fix: remove some unnececeary logs	2023-11-05 20:29:21 +02:00
TopchetoEU	1d0bae3de8	feat: include typescript code in source code	2023-11-05 20:27:23 +02:00
TopchetoEU	b66acd3089	fix: several more fixes	2023-11-05 19:44:44 +02:00
TopchetoEU	e326847287	feat: send value stack to debug client	2023-11-05 19:44:35 +02:00
TopchetoEU	26591d6631	fix: lazy operators incorrectly pop values from stack	2023-11-05 19:44:08 +02:00
TopchetoEU	af31b1ab79	fix: several small fixes	2023-11-05 19:43:53 +02:00
TopchetoEU	f885d4349f	refactor: fix some bad code >:(	2023-11-05 19:43:28 +02:00
TopchetoEU	d57044acb7	fix: several bug fixes to help with typescript support	2023-11-05 12:44:29 +02:00
TopchetoEU	7df4e3b03f	fix: oops	2023-11-04 11:43:57 +02:00
TopchetoEU	ed1009ab69	refactor: some code restructuring in the debugging	2023-11-04 11:42:06 +02:00
TopchetoEU	f856cdf37e	fix: messages larger than 64KB are now fragmented properly	2023-11-04 11:41:31 +02:00
TopchetoEU	4f82574b8c	fix: various small behavioural issues fix: pesky try-catch logic	2023-11-04 11:40:50 +02:00
TopchetoEU	0ae24148d8	feat: write some tests	2023-11-04 11:38:48 +02:00
TopchetoEU	ac128d17f4	feat: implement Array.reduce fix: native functions are now named	2023-11-04 11:38:29 +02:00
TopchetoEU	6508f15bb0	refactor: remove typescript source code from repo (for now)	2023-11-04 11:37:13 +02:00
TopchetoEU	69f93b4f87	refactor: make filenames more consistent	2023-11-04 11:36:36 +02:00
TopchetoEU	b675411925	fix: a lot of minor bugs	2023-10-29 23:47:48 +02:00
TopchetoEU	d1e93c2088	Merge branch 'master' of https://github.com/TopchetoEU/java-jscript	2023-10-29 12:33:18 +02:00
TopchetoEU	942db54546	feat: improve vscode debugging compatibility	2023-10-29 12:30:43 +02:00
TopchetoEU	d20df66982	feat: improve vscode debugging compatibility	2023-10-29 12:25:33 +02:00
TopchetoEU	16a9e5d761	Merge pull request #7 from TopchetoEU/TopcehtoEU/debugging Debugging support	2023-10-28 17:11:55 +03:00
TopchetoEU	dc9d84a370	chore: nothing of use	2023-10-28 17:10:27 +03:00
TopchetoEU	edb71daef4	feat: fully implement local and capture scope object wrappers feat: implement object sending and receiving	2023-10-28 16:58:33 +03:00
TopchetoEU	4b84309df6	feat: complete steptrough and breakpoints in debugger	2023-10-27 15:12:14 +03:00
TopchetoEU	d2d9fa9738	fix: exit now works	2023-10-07 14:08:47 +03:00
TopchetoEU	a4e5f7f471	refactor: clean up useless catch blocks	2023-10-07 13:55:44 +03:00
TopchetoEU	cc044374ba	refactor: replace InterruptedException with unchecked alternative	2023-10-07 13:42:55 +03:00
TopchetoEU	517e3e6657	refactor: clean up context and stack data	2023-10-07 13:07:07 +03:00
TopchetoEU	926b9c17d8	feat: readd JSON to lib	2023-10-06 18:42:35 +03:00
TopchetoEU	fc705e7383	feat: readd date internals	2023-10-06 12:03:33 +03:00
TopchetoEU	a17ec737b7	refactor: rename polyfills to libs	2023-10-06 11:57:29 +03:00
TopchetoEU	952a4d631d	fix: keep order of object fields	2023-10-04 22:06:49 +03:00
TopchetoEU	005610ca40	Merge pull request #6 from TopchetoEU/TopchetoEU/function-optimizations Cache function bodies	2023-10-04 21:38:29 +03:00
TopchetoEU	9743a6c078	fix: cache function bodies	2023-10-04 21:34:33 +03:00
TopchetoEU	21a6d20ac5	refactor: some code cleanup, emit better bytecode	2023-10-04 12:16:06 +03:00