fix: wrappers cache compare objects with .equals and not ==

feat: allow adding custom wrappers

.github/workflows/tagged-release.yml

@@ -3,7 +3,7 @@ name: "tagged-release"
 on:
   push:
     tags:
-      - "v*"
+      - "*"
 
 jobs:
   tagged-release:
@@ -16,15 +16,17 @@ jobs:
         with:
           distribution: 'adopt'
           java-version: '11'
+      - name: Setup Gradle
+        uses: gradle/gradle-build-action@v2
       - name: Clone repository
         uses: GuillaumeFalourd/clone-github-repo-action@main
         with:
-          branch: 'master' # fuck this political bullshitshit, took me an hour to fix this
+          branch: 'master'
           owner: 'TopchetoEU'
           repository: 'java-jscript'
-      - name: "Build"
+      - name: Build
         run: |
-          cd java-jscript; node ./build.js release ${{ github.ref }}
+          cd java-jscript; gradle build
 
       - uses: "marvinpinto/action-automatic-releases@latest"
         with:
@@ -32,4 +34,4 @@ jobs:
           prerelease: false
           files: |
             java-jscript/LICENSE
-            java-jscript/dst/*.jar
+            java-jscript/build/libs/*.jar

.gitignore

@@ -2,7 +2,6 @@
 
 !/src
 !/src/**/*
-/src/assets/js/ts.js
 
 !/doc
 !/doc/**/*
@@ -10,12 +9,16 @@
 !/tests
 !/tests/**/*
 
-
 !/.github
 !/.github/**/*
 
 !/.gitignore
 !/.gitattributes
-!/build.js
 !/LICENSE
 !/README.md
+!/settings.gradle
+!/build.gradle
+!/gradle.properties
+!/gradle
+!/gradle/wrapper
+!/gradle/wrapper/gradle-wrapper.properties

README.md

@@ -23,7 +23,3 @@ engine.run(true);
 // Get our result
 System.out.println(awaitable.await());
 ```
-
-## NOTE:
-
-To setup the typescript bundle in your sources, run `node build.js init-ts`. This will download the latest version of typescript, minify it, and add it to your src folder. If you are going to work with the `node build.js debug|release` command, this is not a necessary step.

build.gradle

@@ -0,0 +1,32 @@
+plugins {
+    id "application"
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_11
+    targetCompatibility = JavaVersion.VERSION_11
+    toolchain.languageVersion = JavaLanguageVersion.of(11)
+    withSourcesJar()
+}
+
+jar {
+    manifest.attributes["Main-class"] = project.main_class
+}
+
+sourceSets {
+    main.java.srcDirs = [ "src/java" ]
+    main.resources.srcDirs = [ "src/assets" ]
+}
+
+processResources {
+    filesMatching "metadata.json", {
+        expand(
+            version: project.project_version,
+            name: project.project_name
+        )
+    }
+}
+
+base.archivesName = project.project_name
+version = project.project_version
+group = project.project_group

build.js

@@ -1,193 +0,0 @@
-const { spawn } = require('child_process');
-const fs = require('fs/promises');
-const pt = require('path');
-const { argv, exit } = require('process');
-const { Readable } = require('stream');
-
-
-async function* find(src, dst, wildcard) {
-    const stat = await fs.stat(src);
-
-    if (stat.isDirectory()) {
-        for (const el of await fs.readdir(src)) {
-            for await (const res of find(pt.join(src, el), dst ? pt.join(dst, el) : undefined, wildcard)) yield res;
-        }
-    }
-    else if (stat.isFile() && wildcard(src)) yield dst ? { src, dst } : src;
-}
-async function copy(src, dst, wildcard) {
-    const promises = [];
-
-    for await (const el of find(src, dst, wildcard)) {
-        promises.push((async () => {
-            await fs.mkdir(pt.dirname(el.dst), { recursive: true });
-            await fs.copyFile(el.src, el.dst);
-        })());
-    }
-
-    await Promise.all(promises);
-}
-
-function run(suppressOutput, cmd, ...args) {
-    return new Promise((res, rej) => {
-        const proc = spawn(cmd, args, { stdio: suppressOutput ? 'ignore' : 'inherit' });
-        proc.once('exit', code => {
-            if (code === 0) res(code);
-            else rej(new Error(`Process ${cmd} exited with code ${code}.`));
-        });
-    })
-}
-
-async function downloadTypescript(outFile) {
-    try {
-        // Import the required libraries, without the need of a package.json
-        console.log('Importing modules...');
-        await run(true, 'npm', 'i', 'tar', 'zlib', 'uglify-js');
-        await fs.mkdir(pt.dirname(outFile), { recursive: true });
-        await fs.mkdir('tmp', { recursive: true });
-
-        const tar = require('tar');
-        const zlib = require('zlib');
-        const { minify } = await import('uglify-js');
-
-        // Download the package.json file of typescript
-        const packageDesc = await (await fetch('https://registry.npmjs.org/typescript/latest')).json();
-        const url = packageDesc.dist.tarball;
-
-        console.log('Extracting typescript...');
-        await new Promise(async (res, rej) => Readable.fromWeb((await fetch(url)).body)
-            .pipe(zlib.createGunzip())
-            .pipe(tar.x({ cwd: 'tmp', filter: v => v === 'package/lib/typescript.js' }))
-            .on('end', res)
-            .on('error', rej)
-        );
-
-        console.log('Compiling typescript to ES5...');
-
-        const ts = require('./tmp/package/lib/typescript');
-        const program = ts.createProgram([ 'tmp/package/lib/typescript.js' ], {
-            outFile: "tmp/typescript-es5.js",
-            target: ts.ScriptTarget.ES5,
-            module: ts.ModuleKind.None,
-            downlevelIteration: true,
-            allowJs: true,
-        });
-        program.emit();
-
-        console.log('Minifying typescript...');
-
-        const minified = minify((await fs.readFile('tmp/typescript-es5.js')).toString());
-        // const minified = { code: (await fs.readFile('tmp/typescript-es5.js')).toString() };
-        if (minified.error) throw minified.error;
-
-        // Patch unsupported regex syntax
-        minified.code = minified.code.replaceAll('[-/\\\\^$*+?.()|[\\]{}]', '[-/\\\\^$*+?.()|\\[\\]{}]');
-
-        const stream = await fs.open(outFile, 'w');
-
-        // Write typescript's license
-        await stream.write(new TextEncoder().encode(`
-/*! *****************************************************************************
-Copyright (c) Microsoft Corporation. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-
-The following is a minified version of the unmodified Typescript 5.2
-***************************************************************************** */
-`));
-
-        await stream.write(minified.code);
-        console.log('Typescript bundling done!');
-    }
-    finally {
-        // Clean up all stuff left from typescript bundling
-        await fs.rm('tmp', { recursive: true, force: true });
-        await fs.rm('package.json');
-        await fs.rm('package-lock.json');
-        await fs.rm('node_modules', { recursive: true });
-    }
-}
-async function compileJava(conf) {
-    try {
-        await fs.writeFile('Metadata.java', (await fs.readFile('src/me/topchetoeu/jscript/common/Metadata.java')).toString()
-            .replace('${VERSION}', conf.version)
-            .replace('${NAME}', conf.name)
-            .replace('${AUTHOR}', conf.author)
-        );
-        const args = ['--release', '11', ];
-        if (argv[2] === 'debug') args.push('-g');
-        args.push('-d', 'dst/classes', 'Metadata.java');
-    
-        console.log('Compiling java project...');
-        for await (const path of find('src', undefined, v => v.endsWith('.java') && !v.endsWith('Metadata.java'))) args.push(path);
-        await run(false, conf.javahome + 'javac', ...args);
-        console.log('Compiled java project!');
-    }
-    finally {
-        await fs.rm('Metadata.java');
-    }
-}
-async function jar(conf, project, mainClass) {
-    const args = [
-        'jar', '-c',
-        '-f', `dst/${project}-v${conf.version}.jar`,
-    ];
-    if (mainClass) args.push('-e', mainClass);
-    args.push('-C', 'dst/classes', project.replaceAll('.', '/'));
-    console.log(args.join(' '));
-
-    await run(true, ...args);
-}
-
-(async () => {
-    try {
-        if (argv[2] === 'init-ts') {
-            await downloadTypescript('src/me/topchetoeu/jscript/utils/assets/js/ts.js');
-        }
-        else {
-            const conf = {
-                name: "java-jscript",
-                author: "TopchetoEU",
-                javahome: "",
-                version: argv[3]
-            };
-
-            if (conf.version.startsWith('refs/tags/')) conf.version = conf.version.substring(10);
-            if (conf.version.startsWith('v')) conf.version = conf.version.substring(1);
-
-            try { await fs.rm('dst', { recursive: true }); } catch {}
-
-            await Promise.all([
-                (async () => {
-                    await copy('src', 'dst/classes', v => !v.endsWith('.java'));
-                    await downloadTypescript('dst/classes/me/topchetoeu/jscript/utils/assets/js/ts.js');
-                })(),
-                compileJava(conf),
-            ]);
-
-            await Promise.all([
-                jar(conf, 'me.topchetoeu.jscript.common'),
-                jar(conf, 'me.topchetoeu.jscript.core'),
-                jar(conf, 'me.topchetoeu.jscript.lib'),
-                jar(conf, 'me.topchetoeu.jscript.utils'),
-                jar(conf, 'me.topchetoeu.jscript', 'me.topchetoeu.jscript.utils.JScriptRepl'),
-            ]);
-
-            console.log('Done!');
-        }
-    }
-    catch (e) {
-        if (argv[2] === 'debug') throw e;
-        console.log(e.toString());
-        exit(-1);
-    }
-})();

gradle.properties

@@ -0,0 +1,4 @@
+project_group = me.topchetoeu
+project_name = jscript
+project_version = 0.9.41-beta
+main_class = me.topchetoeu.jscript.utils.JScriptRepl

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,7 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists

settings.gradle

@@ -0,0 +1,5 @@
+plugins {
+    id 'org.gradle.toolchains.foojay-resolver-convention' version '0.7.0'
+}
+
+rootProject.name = properties.project_name

src/assets/metadata.json

@@ -0,0 +1,5 @@
+{
+    "version": "${version}",
+    "name": "${name}",
+    "author": "TopchetoEU"
+}

src/java/me/topchetoeu/jscript/common/Buffer.java

@@ -24,6 +24,11 @@ public class Buffer {
         return n;
     }
 
+    public void clear() {
+        data = new byte[128];
+        length = 0;
+    }
+
     public void append(byte b) {
         write(length, new byte[] { b });
     }

src/java/me/topchetoeu/jscript/common/Filename.java

@@ -7,22 +7,17 @@ public class Filename {
     public final String protocol;
     public final String path;
 
-    public String toString() {
+    @Override public String toString() {
         return protocol + "://" + path;
     }
-
+    @Override public int hashCode() {
-    @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) {
-
-    @Override
-    public boolean equals(Object obj) {
         if (this == obj) return true;
         if (obj == null) return false;
         if (getClass() != obj.getClass()) return false;
@@ -41,9 +36,6 @@ public class Filename {
         return true;
     }
 
-
-
-
     public Filename(String protocol, String path) {
         path = path.trim();
         protocol = protocol.trim();

src/java/me/topchetoeu/jscript/common/FunctionBody.java

@@ -0,0 +1,14 @@
+package me.topchetoeu.jscript.common;
+
+public class FunctionBody {
+    public final FunctionBody[] children;
+    public final Instruction[] instructions;
+    public final int localsN, argsN;
+
+    public FunctionBody(int localsN, int argsN, Instruction[] instructions, FunctionBody[] children) {
+        this.children = children;
+        this.argsN = argsN;
+        this.localsN = localsN;
+        this.instructions = instructions;
+    }
+}

src/java/me/topchetoeu/jscript/common/Instruction.java

@@ -0,0 +1,369 @@
+package me.topchetoeu.jscript.common;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.HashMap;
+
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
+
+public class Instruction {
+    public static enum Type {
+        NOP(0),
+        RETURN(1),
+        THROW(2),
+        THROW_SYNTAX(3),
+        DELETE(4),
+        TRY_START(5),
+        TRY_END(6),
+
+        CALL(7),
+        CALL_NEW(8),
+        JMP_IF(9),
+        JMP_IFN(10),
+        JMP(11),
+
+        PUSH_UNDEFINED(12),
+        PUSH_NULL(13),
+        PUSH_BOOL(14),
+        PUSH_NUMBER(15),
+        PUSH_STRING(16),
+
+        LOAD_VAR(17),
+        LOAD_MEMBER(18),
+        LOAD_GLOB(20),
+
+        LOAD_FUNC(21),
+        LOAD_ARR(22),
+        LOAD_OBJ(23),
+        STORE_SELF_FUNC(24),
+        LOAD_REGEX(25),
+
+        DUP(26),
+
+        STORE_VAR(27),
+        STORE_MEMBER(28),
+        DISCARD(29),
+
+        MAKE_VAR(30),
+        DEF_PROP(31),
+        KEYS(32),
+
+        TYPEOF(33),
+        OPERATION(34);
+
+        private static final HashMap<Integer, Type> types = new HashMap<>();
+        public final int numeric;
+
+        static {
+            for (var val : Type.values()) types.put(val.numeric, val);
+        }
+
+        private Type(int numeric) {
+            this.numeric = numeric;
+        }
+
+        public static Type fromNumeric(int i) {
+            return types.get(i);
+        }
+    }
+    public static enum BreakpointType {
+        NONE,
+        STEP_OVER,
+        STEP_IN;
+
+        public boolean shouldStepIn() {
+            return this != NONE;
+        }
+        public boolean shouldStepOver() {
+            return this == STEP_OVER;
+        }
+    }
+
+    public final Type type;
+    public final Object[] params;
+
+    @SuppressWarnings("unchecked")
+    public <T> T get(int i) {
+        if (i >= params.length || i < 0) return null;
+        return (T)params[i];
+    }
+    @SuppressWarnings("unchecked")
+    public <T> T get(int i, T defaultVal) {
+        if (i >= params.length || i < 0) return defaultVal;
+        return (T)params[i];
+    }
+    public boolean match(Object ...args) {
+        if (args.length != params.length) return false;
+        for (int i = 0; i < args.length; i++) {
+            var a = params[i];
+            var b = args[i];
+            if (a == null || b == null) {
+                if (!(a == null && b == null)) return false;
+            }
+            if (!a.equals(b)) return false;
+        }
+        return true;
+    }
+    public boolean is(int i, Object arg) {
+        if (params.length <= i) return false;
+        return params[i].equals(arg);
+    }
+
+    public void write(DataOutputStream writer) throws IOException {
+        var rawType = type.numeric;
+
+        switch (type) {
+            case KEYS:
+            case PUSH_BOOL:
+            case STORE_MEMBER: rawType |= (boolean)get(0) ? 128 : 0; break;
+            case STORE_VAR: rawType |= (boolean)get(1) ? 128 : 0; break;
+            case TYPEOF: rawType |= params.length > 0 ? 128 : 0; break;
+            default:
+        }
+
+        writer.writeByte(rawType);
+
+        switch (type) {
+            case CALL: writer.writeInt(get(0)); break;
+            case CALL_NEW: writer.writeInt(get(0)); break;
+            case DUP: writer.writeInt(get(0)); break;
+            case JMP: writer.writeInt(get(0)); break;
+            case JMP_IF: writer.writeInt(get(0)); break;
+            case JMP_IFN: writer.writeInt(get(0)); break;
+            case LOAD_ARR: writer.writeInt(get(0)); break;
+            case LOAD_FUNC: {
+                writer.writeInt(params.length - 1);
+
+                for (var i = 0; i < params.length; i++) {
+                    writer.writeInt(get(i + 1));
+                }
+
+                writer.writeInt(get(0));
+                break;
+            }
+            case LOAD_REGEX: writer.writeUTF(get(0)); break;
+            case LOAD_VAR: writer.writeInt(get(0)); break;
+            case MAKE_VAR: writer.writeUTF(get(0)); break;
+            case OPERATION: writer.writeByte(((Operation)get(0)).numeric); break;
+            case PUSH_NUMBER: writer.writeDouble(get(0)); break;
+            case PUSH_STRING: writer.writeUTF(get(0)); break;
+            case STORE_SELF_FUNC: writer.writeInt(get(0)); break;
+            case STORE_VAR: writer.writeInt(get(0)); break;
+            case THROW_SYNTAX: writer.writeUTF(get(0));
+            case TRY_START:
+                writer.writeInt(get(0));
+                writer.writeInt(get(1));
+                writer.writeInt(get(2));
+                break;
+            case TYPEOF:
+                if (params.length > 0) writer.writeUTF(get(0));
+                break;
+            default:
+        }
+    }
+
+    private Instruction(Type type, Object ...params) {
+        this.type = type;
+        this.params = params;
+    }
+
+    public static Instruction read(DataInputStream stream) throws IOException {
+        var rawType = stream.readUnsignedByte();
+        var type = Type.fromNumeric(rawType & 127);
+        var flag = (rawType & 128) != 0;
+
+        switch (type) {
+            case CALL: return call(stream.readInt());
+            case CALL_NEW: return callNew(stream.readInt());
+            case DEF_PROP: return defProp();
+            case DELETE: return delete();
+            case DISCARD: return discard();
+            case DUP: return dup(stream.readInt());
+            case JMP: return jmp(stream.readInt());
+            case JMP_IF: return jmpIf(stream.readInt());
+            case JMP_IFN: return jmpIfNot(stream.readInt());
+            case KEYS: return keys(flag);
+            case LOAD_ARR: return loadArr(stream.readInt());
+            case LOAD_FUNC: {
+                var captures = new int[stream.readInt()];
+
+                for (var i = 0; i < captures.length; i++) {
+                    captures[i] = stream.readInt();
+                }
+
+                return loadFunc(stream.readInt(), captures);
+            }
+            case LOAD_GLOB: return loadGlob();
+            case LOAD_MEMBER: return loadMember();
+            case LOAD_OBJ: return loadObj();
+            case LOAD_REGEX: return loadRegex(stream.readUTF(), null);
+            case LOAD_VAR: return loadVar(stream.readInt());
+            case MAKE_VAR: return makeVar(stream.readUTF());
+            case OPERATION: return operation(Operation.fromNumeric(stream.readUnsignedByte()));
+            case PUSH_NULL: return pushNull();
+            case PUSH_UNDEFINED: return pushUndefined();
+            case PUSH_BOOL: return pushValue(flag);
+            case PUSH_NUMBER: return pushValue(stream.readDouble());
+            case PUSH_STRING: return pushValue(stream.readUTF());
+            case RETURN: return ret();
+            case STORE_MEMBER: return storeMember(flag);
+            case STORE_SELF_FUNC: return storeSelfFunc(stream.readInt());
+            case STORE_VAR: return storeVar(stream.readInt(), flag);
+            case THROW: return throwInstr();
+            case THROW_SYNTAX: return throwSyntax(stream.readUTF());
+            case TRY_END: return tryEnd();
+            case TRY_START: return tryStart(stream.readInt(), stream.readInt(), stream.readInt());
+            case TYPEOF: return flag ? typeof(stream.readUTF()) : typeof();
+            case NOP:
+                if (flag) return null;
+                else return nop();
+            default: return null;
+        }
+    }
+
+    public static Instruction tryStart(int catchStart, int finallyStart, int end) {
+        return new Instruction(Type.TRY_START, catchStart, finallyStart, end);
+    }
+    public static Instruction tryEnd() {
+        return new Instruction(Type.TRY_END);
+    }
+    public static Instruction throwInstr() {
+        return new Instruction(Type.THROW);
+    }
+    public static Instruction throwSyntax(SyntaxException err) {
+        return new Instruction(Type.THROW_SYNTAX, err.getMessage());
+    }
+    public static Instruction throwSyntax(String err) {
+        return new Instruction(Type.THROW_SYNTAX, err);
+    }
+    public static Instruction delete() {
+        return new Instruction(Type.DELETE);
+    }
+    public static Instruction ret() {
+        return new Instruction(Type.RETURN);
+    }
+    public static Instruction debug() {
+        return new Instruction(Type.NOP, "debug");
+    }
+
+    public static Instruction nop(Object ...params) {
+        return new Instruction(Type.NOP, params);
+    }
+
+    public static Instruction call(int argn) {
+        return new Instruction(Type.CALL, argn);
+    }
+    public static Instruction callNew(int argn) {
+        return new Instruction(Type.CALL_NEW, argn);
+    }
+    public static Instruction jmp(int offset) {
+        return new Instruction(Type.JMP, offset);
+    }
+    public static Instruction jmpIf(int offset) {
+        return new Instruction(Type.JMP_IF, offset);
+    }
+    public static Instruction jmpIfNot(int offset) {
+        return new Instruction(Type.JMP_IFN, offset);
+    }
+
+    public static Instruction pushUndefined() {
+        return new Instruction(Type.PUSH_UNDEFINED);
+    }
+    public static Instruction pushNull() {
+        return new Instruction(Type.PUSH_NULL);
+    }
+    public static Instruction pushValue(boolean val) {
+        return new Instruction(Type.PUSH_BOOL, val);
+    }
+    public static Instruction pushValue(double val) {
+        return new Instruction(Type.PUSH_NUMBER, val);
+    }
+    public static Instruction pushValue(String val) {
+        return new Instruction(Type.PUSH_STRING, val);
+    }
+
+    public static Instruction makeVar(String name) {
+        return new Instruction(Type.MAKE_VAR, name);
+    }
+    public static Instruction loadVar(Object i) {
+        return new Instruction(Type.LOAD_VAR, i);
+    }
+    public static Instruction loadGlob() {
+        return new Instruction(Type.LOAD_GLOB);
+    }
+    public static Instruction loadMember() {
+        return new Instruction(Type.LOAD_MEMBER);
+    }
+
+    public static Instruction loadRegex(String pattern, String flags) {
+        return new Instruction(Type.LOAD_REGEX, pattern, flags);
+    }
+    public static Instruction loadFunc(int 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(Type.LOAD_FUNC, args);
+    }
+    public static Instruction loadObj() {
+        return new Instruction(Type.LOAD_OBJ);
+    }
+    public static Instruction loadArr(int count) {
+        return new Instruction(Type.LOAD_ARR, count);
+    }
+    public static Instruction dup() {
+        return new Instruction(Type.DUP, 1);
+    }
+    public static Instruction dup(int count) {
+        return new Instruction(Type.DUP, count);
+    }
+
+    public static Instruction storeSelfFunc(int i) {
+        return new Instruction(Type.STORE_SELF_FUNC, i);
+    }
+    public static Instruction storeVar(Object i) {
+        return new Instruction(Type.STORE_VAR, i, false);
+    }
+    public static Instruction storeVar(Object i, boolean keep) {
+        return new Instruction(Type.STORE_VAR, i, keep);
+    }
+    public static Instruction storeMember() {
+        return new Instruction(Type.STORE_MEMBER, false);
+    }
+    public static Instruction storeMember(boolean keep) {
+        return new Instruction(Type.STORE_MEMBER, keep);
+    }
+    public static Instruction discard() {
+        return new Instruction(Type.DISCARD);
+    }
+
+    public static Instruction typeof() {
+        return new Instruction(Type.TYPEOF);
+    }
+    public static Instruction typeof(String varName) {
+        return new Instruction(Type.TYPEOF, varName);
+    }
+
+    public static Instruction keys(boolean forInFormat) {
+        return new Instruction(Type.KEYS, forInFormat);
+    }
+
+    public static Instruction defProp() {
+        return new Instruction(Type.DEF_PROP);
+    }
+
+    public static Instruction operation(Operation op) {
+        return new Instruction(Type.OPERATION, op);
+    }
+
+    @Override
+    public String toString() {
+        var res = type.toString();
+
+        for (int i = 0; i < params.length; i++) {
+            res += " " + params[i];
+        }
+
+        return res;
+    }
+}

src/java/me/topchetoeu/jscript/common/Location.java

@@ -1,7 +1,9 @@
 package me.topchetoeu.jscript.common;
 
+import java.util.ArrayList;
+
 public class Location implements Comparable<Location> {
-    public static final Location INTERNAL = new Location(0, 0, new Filename("jscript", "native"));
+    public static final Location INTERNAL = new Location(-1, -1, new Filename("jscript", "native"));
     private int line;
     private int start;
     private Filename filename;
@@ -12,7 +14,13 @@ public class Location implements Comparable<Location> {
 
     @Override
     public String toString() {
-        return filename.toString() + ":" + line + ":" + start;
+        var res = new ArrayList<String>();
+
+        if (filename != null) res.add(filename.toString());
+        if (line >= 0) res.add(line + "");
+        if (start >= 0) res.add(start + "");
+
+        return String.join(":", res);
     }
 
     public Location add(int n, boolean clone) {

src/java/me/topchetoeu/jscript/common/Metadata.java

@@ -1,9 +1,18 @@
 package me.topchetoeu.jscript.common;
 
+import me.topchetoeu.jscript.common.json.JSON;
+
 public class Metadata {
-    private static final String VERSION = "${VERSION}";
+    private static final String VERSION;
-    private static final String AUTHOR = "${AUTHOR}";
+    private static final String AUTHOR;
-    private static final String NAME = "${NAME}";
+    private static final String NAME;
+
+    static {
+        var data = JSON.parse(null, Reading.resourceToString("metadata.json")).map();
+        VERSION = data.string("version");
+        AUTHOR = data.string("author");
+        NAME = data.string("name");
+    }
 
     public static String version() {
         if (VERSION.equals("$" + "{VERSION}")) return "1337-devel";

src/java/me/topchetoeu/jscript/common/Operation.java

@@ -0,0 +1,54 @@
+package me.topchetoeu.jscript.common;
+
+import java.util.HashMap;
+
+public enum Operation {
+    INSTANCEOF(1, 2),
+    IN(2, 2),
+
+    MULTIPLY(3, 2),
+    DIVIDE(4, 2),
+    MODULO(5, 2),
+    ADD(6, 2),
+    SUBTRACT(7, 2),
+
+    USHIFT_RIGHT(8, 2),
+    SHIFT_RIGHT(9, 2),
+    SHIFT_LEFT(10, 2),
+
+    GREATER(11, 2),
+    LESS(12, 2),
+    GREATER_EQUALS(13, 2),
+    LESS_EQUALS(14, 2),
+    LOOSE_EQUALS(15, 2),
+    LOOSE_NOT_EQUALS(16, 2),
+    EQUALS(17, 2),
+    NOT_EQUALS(18, 2),
+
+    AND(19, 2),
+    OR(20, 2),
+    XOR(21, 2),
+
+    NEG(23, 1),
+    POS(24, 1),
+    NOT(25, 1),
+    INVERSE(26, 1);
+
+    private static final HashMap<Integer, Operation> operations = new HashMap<>();
+
+    static {
+        for (var val : Operation.values()) operations.put(val.numeric, val);
+    }
+
+    public final int numeric;
+    public final int operands;
+
+    private Operation(int numeric, int n) {
+        this.numeric = numeric;
+        this.operands = n;
+    }
+
+    public static Operation fromNumeric(int i) {
+        return operations.get(i);
+    }
+}

src/java/me/topchetoeu/jscript/common/Reading.java

@@ -13,11 +13,6 @@ public class Reading {
         return reader.readLine();
     }
 
-    /**
-     * Reads the given stream to a string
-     * @param in 
-     * @return
-     */
     public static String streamToString(InputStream in) {
         try {
             return new String(in.readAllBytes());

src/java/me/topchetoeu/jscript/common/RefTracker.java

@@ -0,0 +1,23 @@
+package me.topchetoeu.jscript.common;
+
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
+
+public class RefTracker {
+    public static void onDestroy(Object obj, Runnable runnable) {
+        var queue = new ReferenceQueue<>();
+        var ref = new WeakReference<>(obj, queue);
+        obj = null;
+
+        var th = new Thread(() -> {
+            try {
+                queue.remove();
+                ref.get();
+                runnable.run();
+            }
+            catch (InterruptedException e) { return; }
+        });
+        th.setDaemon(true);
+        th.start();
+    }
+}

src/java/me/topchetoeu/jscript/common/events/DataNotifier.java

@@ -1,6 +1,6 @@
 package me.topchetoeu.jscript.common.events;
 
-public class DataNotifier<T> implements Awaitable<T> {
+public class DataNotifier<T> {
     private Notifier notifier = new Notifier();
     private boolean isErr;
     private T val;

src/java/me/topchetoeu/jscript/common/events/Notifier.java

@@ -1,6 +1,6 @@
 package me.topchetoeu.jscript.common.events;
 
-import me.topchetoeu.jscript.core.exceptions.InterruptException;
+import me.topchetoeu.jscript.runtime.exceptions.InterruptException;
 
 public class Notifier {
     private boolean ok = false;

src/java/me/topchetoeu/jscript/common/json/JSON.java

@@ -5,16 +5,16 @@ import java.util.List;
 import java.util.stream.Collectors;
 
 import me.topchetoeu.jscript.common.Filename;
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.compilation.parsing.Operator;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.compilation.parsing.ParseRes;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.compilation.parsing.Parsing;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.compilation.parsing.Token;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.Extensions;
-import me.topchetoeu.jscript.core.exceptions.SyntaxException;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.parsing.Operator;
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
-import me.topchetoeu.jscript.core.parsing.ParseRes;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.parsing.Parsing;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.parsing.Token;
+import me.topchetoeu.jscript.runtime.values.Values;
 
 public class JSON {
     public static Object toJs(JSONElement val) {
@@ -32,7 +32,7 @@ public class JSON {
         if (val.isNull()) return Values.NULL;
         return null;
     }
-    private static JSONElement fromJs(Context ctx, Object val, HashSet<Object> prev) {
+    private static JSONElement fromJs(Extensions ext, Object val, HashSet<Object> prev) {
         if (val instanceof Boolean) return JSONElement.bool((boolean)val);
         if (val instanceof Number) return JSONElement.number(((Number)val).doubleValue());
         if (val instanceof String) return JSONElement.string((String)val);
@@ -44,7 +44,7 @@ public class JSON {
             var res = new JSONList();
 
             for (var el : ((ArrayValue)val).toArray()) {
-                var jsonEl = fromJs(ctx, el, prev);
+                var jsonEl = fromJs(ext, el, prev);
                 if (jsonEl == null) jsonEl = JSONElement.NULL;
                 res.add(jsonEl);
             }
@@ -58,8 +58,8 @@ public class JSON {
 
             var res = new JSONMap();
 
-            for (var el : Values.getMembers(ctx, val, false, false)) {
+            for (var el : Values.getMembers(ext, val, false, false)) {
-                var jsonEl = fromJs(ctx, Values.getMember(ctx, val, el), prev);
+                var jsonEl = fromJs(ext, Values.getMember(ext, val, el), prev);
                 if (jsonEl == null) continue;
                 if (el instanceof String || el instanceof Number) res.put(el.toString(), jsonEl);
             }
@@ -70,8 +70,8 @@ public class JSON {
         if (val == null) return null;
         return null;
     }
-    public static JSONElement fromJs(Context ctx, Object val) {
+    public static JSONElement fromJs(Extensions ext, Object val) {
-        return fromJs(ctx, val, new HashSet<>());
+        return fromJs(ext, val, new HashSet<>());
     }
 
     public static ParseRes<String> parseIdentifier(List<Token> tokens, int i) {

src/java/me/topchetoeu/jscript/common/mapping/ConvertType.java

@@ -0,0 +1,8 @@
+package me.topchetoeu.jscript.common.mapping;
+
+public enum ConvertType {
+    Exact,
+    Lower,
+    Upper,
+    Both,
+}

src/java/me/topchetoeu/jscript/common/mapping/FunctionMap.java

@@ -0,0 +1,192 @@
+package me.topchetoeu.jscript.common.mapping;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.NavigableSet;
+import java.util.Objects;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+
+import me.topchetoeu.jscript.common.Filename;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.scope.LocalScopeRecord;
+import me.topchetoeu.jscript.utils.mapping.SourceMap;
+
+public class FunctionMap {
+    public static class FunctionMapBuilder {
+        private final TreeMap<Integer, Location> sourceMap = new TreeMap<>();
+        private final HashMap<Location, BreakpointType> breakpoints = new HashMap<>();
+
+        public Location toLocation(int pc) {
+            return sourceMap.headMap(pc, true).firstEntry().getValue();
+        }
+
+        public FunctionMapBuilder setDebug(Location loc, BreakpointType type) {
+            if (loc == null || type == null || type == BreakpointType.NONE) return this;
+            breakpoints.put(loc, type);
+            return this;
+        }
+        public FunctionMapBuilder setLocation(int i, Location loc) {
+            if (loc == null || i < 0) return this;
+            sourceMap.put(i, loc);
+            return this;
+        }
+        public FunctionMapBuilder setLocationAndDebug(int i, Location loc, BreakpointType type) {
+            setDebug(loc, type);
+            setLocation(i, loc);
+            return this;
+        }
+
+        public Location first() {
+            if (sourceMap.size() == 0) return null;
+            return sourceMap.firstEntry().getValue();
+        }
+        public Location last() {
+            if (sourceMap.size() == 0) return null;
+            return sourceMap.lastEntry().getValue();
+        }
+
+        public FunctionMap build(String[] localNames, String[] captureNames) {
+            return new FunctionMap(sourceMap, breakpoints, localNames, captureNames);
+        }
+        public FunctionMap build(LocalScopeRecord scope) {
+            return new FunctionMap(sourceMap, breakpoints, scope.locals(), scope.captures());
+        }
+        public FunctionMap build() {
+            return new FunctionMap(sourceMap, breakpoints, new String[0], new String[0]);
+        }
+
+        private FunctionMapBuilder() { }
+    }
+
+    public static final FunctionMap EMPTY = new FunctionMap();
+
+    private final HashMap<Integer, BreakpointType> bps = new HashMap<>();
+    private final HashMap<Filename, TreeSet<Location>> bpLocs = new HashMap<>();
+
+    private final TreeMap<Integer, Location> pcToLoc = new TreeMap<>();
+
+    public final String[] localNames, captureNames;
+
+    public Location toLocation(int pc, boolean approxiamte) {
+        if (pcToLoc.size() == 0 || pc < 0 || pc > pcToLoc.lastKey()) return null;
+        var res = pcToLoc.get(pc);
+        if (!approxiamte || res != null) return res;
+        var entry = pcToLoc.headMap(pc, true).lastEntry();
+        if (entry == null) return null;
+        else return entry.getValue();
+    }
+    public Location toLocation(int pc) {
+        return toLocation(pc, false);
+    }
+
+    public BreakpointType getBreakpoint(int pc) {
+        return bps.getOrDefault(pc, BreakpointType.NONE);
+    }
+    public Location correctBreakpoint(Location loc) {
+        var set = bpLocs.get(loc.filename());
+        if (set == null) return null;
+        else return set.ceiling(loc);
+    }
+    public List<Location> correctBreakpoint(Pattern filename, int line, int column) {
+        var candidates = new HashMap<Filename, TreeSet<Location>>();
+
+        for (var name : bpLocs.keySet()) {
+            if (filename.matcher(name.toString()).matches()) {
+                candidates.put(name, bpLocs.get(name));
+            }
+        }
+
+        var res = new ArrayList<Location>(candidates.size());
+        for (var candidate : candidates.entrySet()) {
+            var val = correctBreakpoint(new Location(line, column, candidate.getKey()));
+            if (val == null) continue;
+            res.add(val);
+        }
+
+        return res;
+    }
+    public List<Location> breakpoints(Location start, Location end) {
+        if (!Objects.equals(start.filename(), end.filename())) return List.of();
+        NavigableSet<Location> set = bpLocs.get(start.filename());
+        if (set == null) return List.of();
+
+        if (start != null) set = set.tailSet(start, true);
+        if (end != null) set = set.headSet(end, true);
+
+        return set.stream().collect(Collectors.toList());
+    }
+
+    public Location start() {
+        if (pcToLoc.size() == 0) return null;
+        return pcToLoc.firstEntry().getValue();
+    }
+    public Location end() {
+        if (pcToLoc.size() == 0) return null;
+        return pcToLoc.lastEntry().getValue();
+    }
+
+    public FunctionMap apply(SourceMap map) {
+        var res = new FunctionMap(Map.of(), Map.of(), localNames, captureNames);
+
+        for (var el : pcToLoc.entrySet()) {
+            res.pcToLoc.put(el.getKey(), map.toCompiled(el.getValue()));
+        }
+
+        res.bps.putAll(bps);
+
+        for (var el : bpLocs.entrySet()) {
+            for (var loc : el.getValue()) {
+                loc = map.toCompiled(loc);
+                if (loc == null) continue;
+
+                if (!res.bpLocs.containsKey(loc.filename())) res.bpLocs.put(loc.filename(), new TreeSet<>());
+                res.bpLocs.get(loc.filename()).add(loc);
+            }
+        }
+
+        return res;
+    }
+
+    public FunctionMap clone() {
+        var res = new FunctionMap(Map.of(), Map.of(), localNames, captureNames);
+        res.pcToLoc.putAll(this.pcToLoc);
+        res.bps.putAll(bps);
+        res.bpLocs.putAll(bpLocs);
+        res.pcToLoc.putAll(pcToLoc);
+        return res;
+    }
+
+    public FunctionMap(Map<Integer, Location> map, Map<Location, BreakpointType> breakpoints, String[] localNames, String[] captureNames) {
+        var locToPc = new HashMap<Location, Integer>();
+
+        for (var el : map.entrySet()) {
+            pcToLoc.put(el.getKey(), el.getValue());
+            locToPc.putIfAbsent(el.getValue(), el.getKey());
+        }
+
+        for (var el : breakpoints.entrySet()) {
+            if (el.getValue() == null || el.getValue() == BreakpointType.NONE) continue;
+            bps.put(locToPc.get(el.getKey()), el.getValue());
+
+            if (!bpLocs.containsKey(el.getKey().filename())) bpLocs.put(el.getKey().filename(), new TreeSet<>());
+            bpLocs.get(el.getKey().filename()).add(el.getKey());
+        }
+
+        this.localNames = localNames;
+        this.captureNames = captureNames;
+    }
+    private FunctionMap() {
+        localNames = new String[0];
+        captureNames = new String[0];
+    }
+
+    public static FunctionMapBuilder builder() {
+        return new FunctionMapBuilder();
+    }
+}

src/java/me/topchetoeu/jscript/compilation/AssignableStatement.java

@@ -1,7 +1,7 @@
-package me.topchetoeu.jscript.core.compilation;
+package me.topchetoeu.jscript.compilation;
 
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.engine.Operation;
+import me.topchetoeu.jscript.common.Operation;
 
 public abstract class AssignableStatement extends Statement {
     public abstract Statement toAssign(Statement val, Operation operation);

src/java/me/topchetoeu/jscript/compilation/CompileResult.java

@@ -0,0 +1,78 @@
+package me.topchetoeu.jscript.compilation;
+
+import java.util.List;
+import java.util.LinkedList;
+import java.util.Vector;
+
+import me.topchetoeu.jscript.common.FunctionBody;
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.mapping.FunctionMap;
+import me.topchetoeu.jscript.common.mapping.FunctionMap.FunctionMapBuilder;
+import me.topchetoeu.jscript.compilation.scope.LocalScopeRecord;
+
+public class CompileResult {
+    public final Vector<Instruction> instructions = new Vector<>();
+    public final List<CompileResult> children = new LinkedList<>();
+    public final FunctionMapBuilder map = FunctionMap.builder();
+    public final LocalScopeRecord scope;
+    public int length = 0;
+
+    public int temp() {
+        instructions.add(null);
+        return instructions.size() - 1;
+    }
+
+    public CompileResult add(Instruction instr) {
+        instructions.add(instr);
+        return this;
+    }
+    public CompileResult set(int i, Instruction instr) {
+        instructions.set(i, instr);
+        return this;
+    }
+    public Instruction get(int i) {
+        return instructions.get(i);
+    }
+    public int size() { return instructions.size(); }
+
+    public void setDebug(Location loc, BreakpointType type) {
+        map.setDebug(loc, type);
+    }
+    public void setLocation(int i, Location loc) {
+        map.setLocation(i, loc);
+    }
+    public void setLocationAndDebug(int i, Location loc, BreakpointType type) {
+        map.setLocationAndDebug(i, loc, type);
+    }
+    public void setDebug(BreakpointType type) {
+        setDebug(map.last(), type);
+    }
+    public void setLocation(Location type) {
+        setLocation(instructions.size() - 1, type);
+    }
+    public void setLocationAndDebug(Location loc, BreakpointType type) {
+        setLocationAndDebug(instructions.size() - 1, loc, type);
+    }
+
+    public CompileResult addChild(CompileResult child) {
+        this.children.add(child);
+        return child;
+    }
+
+    public FunctionMap map() {
+        return map.build(scope);
+    }
+    public FunctionBody body() {
+        var builtChildren = new FunctionBody[children.size()];
+
+        for (var i = 0; i < children.size(); i++) builtChildren[i] = children.get(i).body();
+
+        return new FunctionBody(scope.localsCount(), length, instructions.toArray(Instruction[]::new), builtChildren);
+    }
+
+    public CompileResult(LocalScopeRecord scope) {
+        this.scope = scope;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/CompoundStatement.java

@@ -1,12 +1,12 @@
-package me.topchetoeu.jscript.core.compilation;
+package me.topchetoeu.jscript.compilation;
 
 import java.util.List;
 import java.util.Vector;
 
+import me.topchetoeu.jscript.common.Instruction;
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.compilation.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
-import me.topchetoeu.jscript.core.compilation.values.FunctionStatement;
+import me.topchetoeu.jscript.compilation.values.FunctionStatement;
-import me.topchetoeu.jscript.core.engine.scope.ScopeRecord;
 
 public class CompoundStatement extends Statement {
     public final Statement[] statements;
@@ -22,16 +22,16 @@ public class CompoundStatement extends Statement {
     }
 
     @Override
-    public void declare(ScopeRecord varsScope) {
+    public void declare(CompileResult target) {
-        for (var stm : statements) stm.declare(varsScope);
+        for (var stm : statements) stm.declare(target);
     }
 
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute, BreakpointType type) {
+    public void compile(CompileResult target, 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);
+                stm.compile(target, false);
             }
             else statements.add(stm);
         }
@@ -42,12 +42,12 @@ public class CompoundStatement extends Statement {
         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);
+            if (i != statements.size() - 1) stm.compile(target, false, BreakpointType.STEP_OVER);
-            else stm.compile(target, scope, polluted = pollute, BreakpointType.STEP_OVER);
+            else stm.compile(target, polluted = pollute, BreakpointType.STEP_OVER);
         }
 
         if (!polluted && pollute) {
-            target.add(Instruction.loadValue(loc(), null));
+            target.add(Instruction.pushUndefined());
         }
     }
 

src/java/me/topchetoeu/jscript/compilation/Statement.java

@@ -0,0 +1,27 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+
+public abstract class Statement {
+    private Location _loc;
+
+    public boolean pure() { return false; }
+    public void declare(CompileResult target) { }
+
+    public void compile(CompileResult target, boolean pollute, BreakpointType type) {
+        int start = target.size();
+        compile(target, pollute);
+        if (target.size() != start) target.setLocationAndDebug(start, loc(), type);
+    }
+    public void compile(CompileResult target, boolean pollute) {
+        compile(target, pollute, BreakpointType.NONE);
+    }
+
+    public Location loc() { return _loc; }
+    public void setLoc(Location loc) { _loc = loc; }
+
+    protected Statement(Location loc) {
+        this._loc = loc;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/ThrowSyntaxStatement.java

@@ -0,0 +1,18 @@
+package me.topchetoeu.jscript.compilation;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
+
+public class ThrowSyntaxStatement extends Statement {
+    public final String name;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.throwSyntax(name));
+    }
+
+    public ThrowSyntaxStatement(SyntaxException e) {
+        super(e.loc);
+        this.name = e.msg;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/VariableDeclareStatement.java

@@ -1,11 +1,11 @@
-package me.topchetoeu.jscript.core.compilation;
+package me.topchetoeu.jscript.compilation;
 
 import java.util.List;
 
+import me.topchetoeu.jscript.common.Instruction;
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.compilation.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
-import me.topchetoeu.jscript.core.compilation.values.FunctionStatement;
+import me.topchetoeu.jscript.compilation.values.FunctionStatement;
-import me.topchetoeu.jscript.core.engine.scope.ScopeRecord;
 
 public class VariableDeclareStatement extends Statement {
     public static class Pair {
@@ -23,26 +23,26 @@ public class VariableDeclareStatement extends Statement {
     public final List<Pair> values;
 
     @Override
-    public void declare(ScopeRecord varsScope) {
+    public void declare(CompileResult target) {
         for (var key : values) {
-            varsScope.define(key.name);
+            target.scope.define(key.name);
         }
     }
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileResult target, boolean pollute) {
         for (var entry : values) {
             if (entry.name == null) continue;
-            var key = scope.getKey(entry.name);
+            var key = target.scope.getKey(entry.name);
 
-            if (key instanceof String) target.add(Instruction.makeVar(entry.location, (String)key));
+            if (key instanceof String) target.add(Instruction.makeVar((String)key));
 
             if (entry.value != null) {
-                FunctionStatement.compileWithName(entry.value, target, scope, true, entry.name, BreakpointType.STEP_OVER);
+                FunctionStatement.compileWithName(entry.value, target, true, entry.name, BreakpointType.STEP_OVER);
-                target.add(Instruction.storeVar(entry.location, key));
+                target.add(Instruction.storeVar(key));
             }
         }
 
-        if (pollute) target.add(Instruction.loadValue(loc(), null));
+        if (pollute) target.add(Instruction.pushUndefined());
     }
 
     public VariableDeclareStatement(Location loc, List<Pair> values) {

src/java/me/topchetoeu/jscript/compilation/control/BreakStatement.java

@@ -0,0 +1,21 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class BreakStatement extends Statement {
+    public final String label;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.nop("break", label));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public BreakStatement(Location loc, String label) {
+        super(loc);
+        this.label = label;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ContinueStatement.java

@@ -0,0 +1,21 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ContinueStatement extends Statement {
+    public final String label;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.nop("cont", label));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public ContinueStatement(Location loc, String label) {
+        super(loc);
+        this.label = label;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/DebugStatement.java

@@ -0,0 +1,18 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class DebugStatement extends Statement {
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.debug());
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public DebugStatement(Location loc) {
+        super(loc);
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/DeleteStatement.java

@@ -0,0 +1,26 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class DeleteStatement extends Statement {
+    public final Statement key;
+    public final Statement value;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        value.compile(target, true);
+        key.compile(target, true);
+
+        target.add(Instruction.delete());
+        if (pollute) target.add(Instruction.pushValue(true));
+    }
+
+    public DeleteStatement(Location loc, Statement key, Statement value) {
+        super(loc);
+        this.key = key;
+        this.value = value;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/DoWhileStatement.java

@@ -0,0 +1,36 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class DoWhileStatement extends Statement {
+    public final Statement condition, body;
+    public final String label;
+
+    @Override
+    public void declare(CompileResult target) {
+        body.declare(target);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        int start = target.size();
+        body.compile(target, false, BreakpointType.STEP_OVER);
+        int mid = target.size();
+        condition.compile(target, true, BreakpointType.STEP_OVER);
+        int end = target.size();
+
+        WhileStatement.replaceBreaks(target, label, start, mid - 1, mid, end + 1);
+        target.add(Instruction.jmpIf(start - end));
+    }
+
+    public DoWhileStatement(Location loc, String label, Statement condition, Statement body) {
+        super(loc);
+        this.label = label;
+        this.condition = condition;
+        this.body = body;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ForInStatement.java

@@ -0,0 +1,69 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ForInStatement extends Statement {
+    public final String varName;
+    public final boolean isDeclaration;
+    public final Statement varValue, object, body;
+    public final String label;
+    public final Location varLocation;
+
+    @Override
+    public void declare(CompileResult target) {
+        body.declare(target);
+        if (isDeclaration) target.scope.define(varName);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        var key = target.scope.getKey(varName);
+
+        if (key instanceof String) target.add(Instruction.makeVar((String)key));
+
+        if (varValue != null) {
+            varValue.compile(target, true);
+            target.add(Instruction.storeVar(target.scope.getKey(varName)));
+        }
+
+        object.compile(target, true, BreakpointType.STEP_OVER);
+        target.add(Instruction.keys(true));
+
+        int start = target.size();
+        target.add(Instruction.dup());
+        target.add(Instruction.pushUndefined());
+        target.add(Instruction.operation(Operation.EQUALS));
+        int mid = target.temp();
+
+        target.add(Instruction.pushValue("value")).setLocation(varLocation);
+        target.add(Instruction.loadMember()).setLocation(varLocation);
+        target.add(Instruction.storeVar(key)).setLocationAndDebug(object.loc(), BreakpointType.STEP_OVER);
+
+        body.compile(target, false, BreakpointType.STEP_OVER);
+
+        int end = target.size();
+
+        WhileStatement.replaceBreaks(target, label, mid + 1, end, start, end + 1);
+
+        target.add(Instruction.jmp(start - end));
+        target.add(Instruction.discard());
+        target.set(mid, Instruction.jmpIf(end - mid + 1));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    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;
+        this.varValue = varValue;
+        this.object = object;
+        this.body = body;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ForOfStatement.java

@@ -0,0 +1,73 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ForOfStatement extends Statement {
+    public final String varName;
+    public final boolean isDeclaration;
+    public final Statement iterable, body;
+    public final String label;
+    public final Location varLocation;
+
+    @Override
+    public void declare(CompileResult target) {
+        body.declare(target);
+        if (isDeclaration) target.scope.define(varName);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        var key = target.scope.getKey(varName);
+
+        if (key instanceof String) target.add(Instruction.makeVar((String)key));
+
+        iterable.compile(target, true, BreakpointType.STEP_OVER);
+        target.add(Instruction.dup());
+        target.add(Instruction.loadVar("Symbol"));
+        target.add(Instruction.pushValue("iterator"));
+        target.add(Instruction.loadMember()).setLocation(iterable.loc());
+        target.add(Instruction.loadMember()).setLocation(iterable.loc());
+        target.add(Instruction.call(0)).setLocation(iterable.loc());
+
+        int start = target.size();
+        target.add(Instruction.dup());
+        target.add(Instruction.dup());
+        target.add(Instruction.pushValue("next"));
+        target.add(Instruction.loadMember()).setLocation(iterable.loc());
+        target.add(Instruction.call(0)).setLocation(iterable.loc());
+        target.add(Instruction.dup());
+        target.add(Instruction.pushValue("done"));
+        target.add(Instruction.loadMember()).setLocation(iterable.loc());
+        int mid = target.temp();
+
+        target.add(Instruction.pushValue("value"));
+        target.add(Instruction.loadMember()).setLocation(varLocation);
+        target.add(Instruction.storeVar(key)).setLocationAndDebug(iterable.loc(), BreakpointType.STEP_OVER);
+
+        body.compile(target, false, BreakpointType.STEP_OVER);
+
+        int end = target.size();
+
+        WhileStatement.replaceBreaks(target, label, mid + 1, end, start, end + 1);
+
+        target.add(Instruction.jmp(start - end));
+        target.add(Instruction.discard());
+        target.add(Instruction.discard());
+        target.set(mid, Instruction.jmpIf(end - mid + 1));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public ForOfStatement(Location loc, Location varLocation, String label, boolean isDecl, String varName, Statement object, Statement body) {
+        super(loc);
+        this.varLocation = varLocation;
+        this.label = label;
+        this.isDeclaration = isDecl;
+        this.varName = varName;
+        this.iterable = object;
+        this.body = body;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ForStatement.java

@@ -0,0 +1,45 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ForStatement extends Statement {
+    public final Statement declaration, assignment, condition, body;
+    public final String label;
+
+    @Override
+    public void declare(CompileResult target) {
+        declaration.declare(target);
+        body.declare(target);
+    }
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        declaration.compile(target, false, BreakpointType.STEP_OVER);
+
+        int start = target.size();
+        condition.compile(target, true, BreakpointType.STEP_OVER);
+        int mid = target.temp();
+        body.compile(target, false, BreakpointType.STEP_OVER);
+        int beforeAssign = target.size();
+        assignment.compile(target, false, BreakpointType.STEP_OVER);
+        int end = target.size();
+
+        WhileStatement.replaceBreaks(target, label, mid + 1, end, beforeAssign, end + 1);
+
+        target.add(Instruction.jmp(start - end));
+        target.set(mid, Instruction.jmpIfNot(end - mid + 1));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public ForStatement(Location loc, String label, Statement declaration, Statement condition, Statement assignment, Statement body) {
+        super(loc);
+        this.label = label;
+        this.declaration = declaration;
+        this.condition = condition;
+        this.assignment = assignment;
+        this.body = body;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/IfStatement.java

@@ -0,0 +1,48 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class IfStatement extends Statement {
+    public final Statement condition, body, elseBody;
+
+    @Override
+    public void declare(CompileResult target) {
+        body.declare(target);
+        if (elseBody != null) elseBody.declare(target);
+    }
+
+    @Override public void compile(CompileResult target, boolean pollute, BreakpointType breakpoint) {
+        condition.compile(target, true, breakpoint);
+
+        if (elseBody == null) {
+            int i = target.temp();
+            body.compile(target, pollute, breakpoint);
+            int endI = target.size();
+            target.set(i, Instruction.jmpIfNot(endI - i));
+        }
+        else {
+            int start = target.temp();
+            body.compile(target, pollute, breakpoint);
+            int mid = target.temp();
+            elseBody.compile(target, pollute, breakpoint);
+            int end = target.size();
+
+            target.set(start, Instruction.jmpIfNot(mid - start + 1));
+            target.set(mid, Instruction.jmp(end - mid));
+        }
+    }
+    @Override public void compile(CompileResult target, boolean pollute) {
+        compile(target, pollute, BreakpointType.STEP_IN);
+    }
+
+    public IfStatement(Location loc, Statement condition, Statement body, Statement elseBody) {
+        super(loc);
+        this.condition = condition;
+        this.body = body;
+        this.elseBody = elseBody;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ReturnStatement.java

@@ -0,0 +1,22 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ReturnStatement extends Statement {
+    public final Statement value;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        if (value == null) target.add(Instruction.pushUndefined());
+        else value.compile(target, true);
+        target.add(Instruction.ret()).setLocation(loc());
+    }
+
+    public ReturnStatement(Location loc, Statement value) {
+        super(loc);
+        this.value = value;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/SwitchStatement.java

@@ -0,0 +1,83 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import java.util.HashMap;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.Instruction.Type;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class SwitchStatement extends Statement {
+    public static class SwitchCase {
+        public final Statement value;
+        public final int statementI;
+
+        public SwitchCase(Statement value, int statementI) {
+            this.value = value;
+            this.statementI = statementI;
+        }
+    }
+
+    public final Statement value;
+    public final SwitchCase[] cases;
+    public final Statement[] body;
+    public final int defaultI;
+
+    @Override
+    public void declare(CompileResult target) {
+        for (var stm : body) stm.declare(target);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        var caseToStatement = new HashMap<Integer, Integer>();
+        var statementToIndex = new HashMap<Integer, Integer>();
+
+        value.compile(target, true, BreakpointType.STEP_OVER);
+
+        for (var ccase : cases) {
+            target.add(Instruction.dup());
+            ccase.value.compile(target, true);
+            target.add(Instruction.operation(Operation.EQUALS));
+            caseToStatement.put(target.temp(), ccase.statementI);
+        }
+
+        int start = target.temp();
+
+        for (var stm : body) {
+            statementToIndex.put(statementToIndex.size(), target.size());
+            stm.compile(target, false, BreakpointType.STEP_OVER);
+        }
+
+        int end = target.size();
+        target.add(Instruction.discard());
+        if (pollute) target.add(Instruction.pushUndefined());
+
+        if (defaultI < 0 || defaultI >= body.length) target.set(start, Instruction.jmp(end - start));
+        else target.set(start, Instruction.jmp(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(end - i));
+            }
+        }
+        for (var el : caseToStatement.entrySet()) {
+            var i = statementToIndex.get(el.getValue());
+            if (i == null) i = end;
+            target.set(el.getKey(), Instruction.jmpIf(i - el.getKey()));
+        }
+
+    }
+
+    public SwitchStatement(Location loc, Statement value, int defaultI, SwitchCase[] cases, Statement[] body) {
+        super(loc);
+        this.value = value;
+        this.defaultI = defaultI;
+        this.cases = cases;
+        this.body = body;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/ThrowStatement.java

@@ -0,0 +1,21 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ThrowStatement extends Statement {
+    public final Statement value;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        value.compile(target, true);
+        target.add(Instruction.throwInstr()).setLocation(loc());
+    }
+
+    public ThrowStatement(Location loc, Statement value) {
+        super(loc);
+        this.value = value;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/TryStatement.java

@@ -0,0 +1,58 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class TryStatement extends Statement {
+    public final Statement tryBody;
+    public final Statement catchBody;
+    public final Statement finallyBody;
+    public final String name;
+
+    @Override
+    public void declare(CompileResult target) {
+        tryBody.declare(target);
+        if (catchBody != null) catchBody.declare(target);
+        if (finallyBody != null) finallyBody.declare(target);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute, BreakpointType bpt) {
+        int replace = target.temp();
+
+        int start = replace + 1, catchStart = -1, finallyStart = -1;
+
+        tryBody.compile(target, false);
+        target.add(Instruction.tryEnd());
+
+        if (catchBody != null) {
+            catchStart = target.size() - start;
+            target.scope.define(name, true);
+            catchBody.compile(target, false);
+            target.scope.undefine();
+            target.add(Instruction.tryEnd());
+        }
+
+        if (finallyBody != null) {
+            finallyStart = target.size() - start;
+            finallyBody.compile(target, false);
+            target.add(Instruction.tryEnd());
+        }
+
+        target.set(replace, Instruction.tryStart(catchStart, finallyStart, target.size() - start));
+        target.setLocationAndDebug(replace, loc(), BreakpointType.STEP_OVER);
+
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public TryStatement(Location loc, Statement tryBody, Statement catchBody, Statement finallyBody, String name) {
+        super(loc);
+        this.tryBody = tryBody;
+        this.catchBody = catchBody;
+        this.finallyBody = finallyBody;
+        this.name = name;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/control/WhileStatement.java

@@ -0,0 +1,52 @@
+package me.topchetoeu.jscript.compilation.control;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.Instruction.Type;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class WhileStatement extends Statement {
+    public final Statement condition, body;
+    public final String label;
+
+    @Override
+    public void declare(CompileResult target) {
+        body.declare(target);
+    }
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        int start = target.size();
+        condition.compile(target, true);
+        int mid = target.temp();
+        body.compile(target, false, BreakpointType.STEP_OVER);
+
+        int end = target.size();
+
+        replaceBreaks(target, label, mid + 1, end, start, end + 1);
+
+        target.add(Instruction.jmp(start - end));
+        target.set(mid, Instruction.jmpIfNot(end - mid + 1));
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public WhileStatement(Location loc, String label, Statement condition, Statement body) {
+        super(loc);
+        this.label = label;
+        this.condition = condition;
+        this.body = body;
+    }
+
+    public static void replaceBreaks(CompileResult 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));
+            }
+            if (instr.type == Type.NOP && instr.is(0, "break") && (instr.get(1) == null || instr.is(1, label))) {
+                target.set(i, Instruction.jmp(breakPoint - i));
+            }
+        }
+    }
+}

src/java/me/topchetoeu/jscript/compilation/parsing/Operator.java

@@ -1,9 +1,9 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 import java.util.HashMap;
 import java.util.Map;
 
-import me.topchetoeu.jscript.core.engine.Operation;
+import me.topchetoeu.jscript.common.Operation;
 
 public enum Operator {
     MULTIPLY("*", Operation.MULTIPLY, 13),
@@ -55,7 +55,7 @@ public enum Operator {
     INCREASE("++"),
     DECREASE("--");
 
-    public final String value;
+    public final String readable;
     public final Operation operation;
     public final int precedence;
     public final boolean reverse;
@@ -63,7 +63,7 @@ public enum Operator {
 
     static {
         for (var el : Operator.values()) {
-            ops.put(el.value, el);
+            ops.put(el.readable, el);
         }
     }
 
@@ -74,38 +74,38 @@ public enum Operator {
     }
 
     private Operator() {
-        this.value = null;
+        this.readable = null;
         this.operation = null;
         this.precedence = -1;
         this.reverse = false;
     }
     private Operator(String value) {
-        this. value = value;
+        this.readable = value;
         this.operation = null;
         this.precedence = -1;
         this.reverse = false;
     }
     private Operator(String value, int precedence) {
-        this. value = value;
+        this.readable = value;
         this.operation = null;
         this.precedence = precedence;
         this.reverse = false;
     }
     private Operator(String value, int precedence, boolean reverse) {
-        this. value = value;
+        this.readable = value;
         this.operation = null;
         this.precedence = precedence;
         this.reverse = reverse;
     }
 
     private Operator(String value, Operation funcName, int precedence) {
-        this. value = value;
+        this.readable = value;
         this.operation = funcName;
         this.precedence = precedence;
         this.reverse = false;
     }
     private Operator(String value, Operation funcName, int precedence, boolean reverse) {
-        this.value = value;
+        this.readable = value;
         this.operation = funcName;
         this.precedence = precedence;
         this.reverse = reverse;

src/java/me/topchetoeu/jscript/compilation/parsing/ParseRes.java

@@ -1,10 +1,10 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 import java.util.List;
 import java.util.Map;
 
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.parsing.Parsing.Parser;
+import me.topchetoeu.jscript.compilation.parsing.Parsing.Parser;
 
 public class ParseRes<T> {
     public static enum State {

src/java/me/topchetoeu/jscript/compilation/parsing/Parsing.java

@@ -1,4 +1,4 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -6,21 +6,19 @@ import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
 import java.util.List;
-import java.util.TreeSet;
 
 import me.topchetoeu.jscript.common.Filename;
+import me.topchetoeu.jscript.common.Instruction;
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.compilation.*;
+import me.topchetoeu.jscript.common.Operation;
-import me.topchetoeu.jscript.core.compilation.VariableDeclareStatement.Pair;
+import me.topchetoeu.jscript.compilation.*;
-import me.topchetoeu.jscript.core.compilation.control.*;
+import me.topchetoeu.jscript.compilation.VariableDeclareStatement.Pair;
-import me.topchetoeu.jscript.core.compilation.control.SwitchStatement.SwitchCase;
+import me.topchetoeu.jscript.compilation.control.*;
-import me.topchetoeu.jscript.core.compilation.values.*;
+import me.topchetoeu.jscript.compilation.control.SwitchStatement.SwitchCase;
-import me.topchetoeu.jscript.core.engine.Environment;
+import me.topchetoeu.jscript.compilation.parsing.ParseRes.State;
-import me.topchetoeu.jscript.core.engine.Operation;
+import me.topchetoeu.jscript.compilation.scope.LocalScopeRecord;
-import me.topchetoeu.jscript.core.engine.scope.LocalScopeRecord;
+import me.topchetoeu.jscript.compilation.values.*;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
-import me.topchetoeu.jscript.core.exceptions.SyntaxException;
-import me.topchetoeu.jscript.core.parsing.ParseRes.State;
 
 // TODO: this has to be rewritten
 public class Parsing {
@@ -29,11 +27,11 @@ public class Parsing {
     }
 
     private static class ObjProp {
-        public final Object name;
+        public final String name;
         public final String access;
         public final FunctionStatement func;
 
-        public ObjProp(Object name, String access, FunctionStatement func) {
+        public ObjProp(String name, String access, FunctionStatement func) {
             this.name = name;
             this.access = access;
             this.func = func;
@@ -403,6 +401,10 @@ public class Parsing {
         return -1;
     }
 
+    private static boolean inBounds(List<Token> tokens, int i) {
+        return i >= 0 && i < tokens.size();
+    }
+
     private static String parseString(Location loc, String literal) {
         var res = new StringBuilder();
 
@@ -579,9 +581,9 @@ public class Parsing {
             var loc = new Location(el.line, el.start, filename);
             switch (el.type) {
                 case LITERAL: res.add(Token.identifier(el.line, el.start, el.value)); break;
-                case NUMBER: res.add(Token.number(el.line, el.start, parseNumber(loc, el.value))); break;
+                case NUMBER: res.add(Token.number(el.line, el.start, parseNumber(loc, el.value), el.value)); break;
-                case STRING: res.add(Token.string(el.line, el.start, parseString(loc, el.value))); break;
+                case STRING: res.add(Token.string(el.line, el.start, parseString(loc, el.value), el.value)); break;
-                case REGEX: res.add(Token.regex(el.line, el.start, parseRegex(loc, el.value))); break;
+                case REGEX: res.add(Token.regex(el.line, el.start, parseRegex(loc, el.value), el.value)); break;
                 case OPERATOR:
                     Operator op = Operator.parse(el.value);
                     if (op == null) throw new SyntaxException(loc, String.format("Unrecognized operator '%s'.", el.value));
@@ -608,49 +610,41 @@ public class Parsing {
     }
 
     public static ParseRes<String> parseIdentifier(List<Token> tokens, int i) {
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isIdentifier()) {
                 return ParseRes.res(tokens.get(i).identifier(), 1);
             }
             else return ParseRes.failed();
         }
-        catch (IndexOutOfBoundsException e) {
+        else return ParseRes.failed();
-            return ParseRes.failed();
-        }
     }
     public static ParseRes<Operator> parseOperator(List<Token> tokens, int i) {
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isOperator()) {
                 return ParseRes.res(tokens.get(i).operator(), 1);
             }
             else return ParseRes.failed();
         }
-        catch (IndexOutOfBoundsException e) {
+        else return ParseRes.failed();
-            return ParseRes.failed();
-        }
     }
 
     public static boolean isIdentifier(List<Token> tokens, int i, String lit) {
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isIdentifier(lit)) {
                 return true;
             }
             else return false;
         }
-        catch (IndexOutOfBoundsException e) {
+        else return false;
-            return false;
-        }
     }
     public static boolean isOperator(List<Token> tokens, int i, Operator op) {
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isOperator(op)) {
                 return true;
             }
             else return false;
         }
-        catch (IndexOutOfBoundsException e) {
+        else return false;
-            return false;
-        }
     }
     public static boolean isStatementEnd(List<Token> tokens, int i) {
         if (isOperator(tokens, i, Operator.SEMICOLON)) return true;
@@ -665,32 +659,27 @@ public class Parsing {
 
     public static ParseRes<ConstantStatement> parseString(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isString()) {
                 return ParseRes.res(new ConstantStatement(loc, tokens.get(i).string()), 1);
             }
             else return ParseRes.failed();
         }
-        catch (IndexOutOfBoundsException e) {
+        else return ParseRes.failed();
-            return ParseRes.failed();
-        }
     }
     public static ParseRes<ConstantStatement> parseNumber(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isNumber()) {
                 return ParseRes.res(new ConstantStatement(loc, tokens.get(i).number()), 1);
             }
             else return ParseRes.failed();
         }
-        catch (IndexOutOfBoundsException e) {
+        else return ParseRes.failed();
-            return ParseRes.failed();
-        }
-
     }
     public static ParseRes<RegexStatement> parseRegex(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
-        try {
+        if (inBounds(tokens, i)) {
             if (tokens.get(i).isRegex()) {
                 var val = tokens.get(i).regex();
                 var index = val.lastIndexOf('/');
@@ -700,9 +689,7 @@ public class Parsing {
             }
             else return ParseRes.failed();
         }
-        catch (IndexOutOfBoundsException e) {
+        return ParseRes.failed();
-            return ParseRes.failed();
-        }
     }
 
     public static ParseRes<ArrayStatement> parseArray(Filename filename, List<Token> tokens, int i) {
@@ -776,15 +763,16 @@ public class Parsing {
         return ParseRes.res(args, n);
     }
 
-    public static ParseRes<? extends Object> parsePropName(Filename filename, List<Token> tokens, int i) {
+    public static ParseRes<String> parsePropName(Filename filename, List<Token> tokens, int i) {
-        var idRes = parseIdentifier(tokens, i);
+        var loc = getLoc(filename, tokens, i);
-        if (idRes.isSuccess()) return ParseRes.res(idRes.result, 1);
-        var strRes = parseString(null, tokens, i);
-        if (strRes.isSuccess()) return ParseRes.res(strRes.result.value, 1);
-        var numRes = parseNumber(null, tokens, i);
-        if (numRes.isSuccess()) return ParseRes.res(numRes.result.value, 1);
 
-        return ParseRes.failed();
+        if (inBounds(tokens, i)) {
+            var token = tokens.get(i);
+
+            if (token.isNumber() || token.isIdentifier() || token.isString()) return ParseRes.res(token.rawValue, 1);
+            else return ParseRes.error(loc, "Expected identifier, string or number literal.");
+        }
+        else return ParseRes.failed();
     }
     public static ParseRes<ObjProp> parseObjectProp(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
@@ -820,9 +808,9 @@ public class Parsing {
         int n = 0;
         if (!isOperator(tokens, i + n++, Operator.BRACE_OPEN)) return ParseRes.failed();
 
-        var values = new LinkedHashMap<Object, Statement>();
+        var values = new LinkedHashMap<String, Statement>();
-        var getters = new LinkedHashMap<Object, FunctionStatement>();
+        var getters = new LinkedHashMap<String, FunctionStatement>();
-        var setters = new LinkedHashMap<Object, FunctionStatement>();
+        var setters = new LinkedHashMap<String, FunctionStatement>();
 
         if (isOperator(tokens, i + n, Operator.BRACE_CLOSE)) {
             n++;
@@ -994,7 +982,7 @@ public class Parsing {
         var res = parseValue(filename, tokens, n + i, 14);
 
         if (res.isSuccess()) return ParseRes.res(new OperationStatement(loc, operation, res.result), n + res.n);
-        else return ParseRes.error(loc, String.format("Expected a value after the unary operator '%s'.", op.value), res);
+        else return ParseRes.error(loc, String.format("Expected a value after the unary operator '%s'.", op.readable), res);
     }
     public static ParseRes<ChangeStatement> parsePrefixChange(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
@@ -1079,10 +1067,10 @@ public class Parsing {
             return ParseRes.res(new ConstantStatement(loc, false), 1);
         }
         if (id.result.equals("undefined")) {
-            return ParseRes.res(new ConstantStatement(loc, null), 1);
+            return ParseRes.res(ConstantStatement.ofUndefined(loc), 1);
         }
         if (id.result.equals("null")) {
-            return ParseRes.res(new ConstantStatement(loc, Values.NULL), 1);
+            return ParseRes.res(ConstantStatement.ofNull(loc), 1);
         }
         if (id.result.equals("this")) {
             return ParseRes.res(new VariableIndexStatement(loc, 0), 1);
@@ -1141,7 +1129,7 @@ public class Parsing {
         }
 
         var res = parseValue(filename, tokens, i + n, 2);
-        if (!res.isSuccess()) return ParseRes.error(loc, String.format("Expected value after assignment operator '%s'.", op.value), res);
+        if (!res.isSuccess()) return ParseRes.error(loc, String.format("Expected value after assignment operator '%s'.", op.readable), res);
         n += res.n;
 
         Operation operation = null;
@@ -1279,7 +1267,7 @@ public class Parsing {
         if (op.isAssign()) return parseAssign(filename, tokens, i + n - 1, prev, precedence);
 
         var res = parseValue(filename, tokens, i + n, op.precedence + (op.reverse ? 0 : 1));
-        if (!res.isSuccess()) return ParseRes.error(loc, String.format("Expected a value after the '%s' operator.", op.value), res);
+        if (!res.isSuccess()) return ParseRes.error(loc, String.format("Expected a value after the '%s' operator.", op.readable), res);
         n += res.n;
 
         if (op == Operator.LAZY_AND) {
@@ -1338,11 +1326,10 @@ public class Parsing {
     }
 
     public static ParseRes<? extends Statement> parseValueStatement(Filename filename, List<Token> tokens, int i) {
-        var loc = getLoc(filename, tokens, i);
         var valRes = parseValue(filename, tokens, i, 0, true);
         if (!valRes.isSuccess()) return valRes.transform();
 
-        valRes.result.setLoc(loc);
+        // valRes.result.setLoc(loc);
         var res = ParseRes.res(valRes.result, valRes.n);
 
         if (isStatementEnd(tokens, i + res.n)) {
@@ -1790,6 +1777,46 @@ public class Parsing {
 
         return ParseRes.res(new ForInStatement(loc, nameLoc, labelRes.result, isDecl, nameRes.result, varVal, objRes.result, bodyRes.result), n);
     }
+    public static ParseRes<ForOfStatement> parseForOf(Filename filename, List<Token> tokens, int i) {
+        var loc = getLoc(filename, tokens, i);
+        int n = 0;
+
+        var labelRes = parseLabel(tokens, i + n);
+        var isDecl = false;
+        n += labelRes.n;
+
+        if (!isIdentifier(tokens, i + n++, "for")) return ParseRes.failed();
+        if (!isOperator(tokens, i + n++, Operator.PAREN_OPEN)) return ParseRes.error(loc, "Expected a open paren after 'for'.");
+
+        if (isIdentifier(tokens, i + n, "var")) {
+            isDecl = true;
+            n++;
+        }
+
+        var nameRes = parseIdentifier(tokens, i + n);
+        if (!nameRes.isSuccess()) return ParseRes.error(loc, "Expected a variable name for 'for' loop.");
+        var nameLoc = getLoc(filename, tokens, i + n);
+        n += nameRes.n;
+
+        if (!isIdentifier(tokens, i + n++, "of")) {
+            if (nameRes.result.equals("const")) return ParseRes.error(loc, "'const' declarations are not supported.");
+            else if (nameRes.result.equals("let")) return ParseRes.error(loc, "'let' declarations are not supported.");
+            else return ParseRes.error(loc, "Expected 'of' keyword after variable declaration.");
+        }
+
+        var objRes = parseValue(filename, tokens, i + n, 0);
+        if (!objRes.isSuccess()) return ParseRes.error(loc, "Expected a value.", objRes);
+        n += objRes.n;
+
+        if (!isOperator(tokens, i + n++, Operator.PAREN_CLOSE)) return ParseRes.error(loc, "Expected a closing paren after for.");
+
+
+        var bodyRes = parseStatement(filename, tokens, i + n);
+        if (!bodyRes.isSuccess()) return ParseRes.error(loc, "Expected a for body.", bodyRes);
+        n += bodyRes.n;
+
+        return ParseRes.res(new ForOfStatement(loc, nameLoc, labelRes.result, isDecl, nameRes.result, objRes.result, bodyRes.result), n);
+    }
     public static ParseRes<TryStatement> parseCatch(Filename filename, List<Token> tokens, int i) {
         var loc = getLoc(filename, tokens, i);
         int n = 0;
@@ -1846,6 +1873,7 @@ public class Parsing {
             parseSwitch(filename, tokens, i),
             parseFor(filename, tokens, i),
             parseForIn(filename, tokens, i),
+            parseForOf(filename, tokens, i),
             parseDoWhile(filename, tokens, i),
             parseCatch(filename, tokens, i),
             parseCompound(filename, tokens, i),
@@ -1875,30 +1903,31 @@ public class Parsing {
         return list.toArray(Statement[]::new);
     }
 
-    public static CompileTarget compile(Environment environment, Statement ...statements) {
+    public static CompileResult compile(Statement ...statements) {
-        var subscope = new LocalScopeRecord();
+        var target = new CompileResult(new LocalScopeRecord());
-        var target = new CompileTarget(new HashMap<>(), new TreeSet<>());
         var stm = new CompoundStatement(null, true, statements);
 
-        subscope.define("this");
+        target.scope.define("this");
-        subscope.define("arguments");
+        target.scope.define("arguments");
 
         try {
-            stm.compile(target, subscope, true);
+            stm.compile(target, true);
             FunctionStatement.checkBreakAndCont(target, 0);
         }
         catch (SyntaxException e) {
-            target.target.clear();
+            target = new CompileResult(new LocalScopeRecord());
-            target.add(Instruction.throwSyntax(e.loc, e));
+
+            target.scope.define("this");
+            target.scope.define("arguments");
+
+            target.add(Instruction.throwSyntax(e)).setLocation(stm.loc());
         }
 
-        target.add(Instruction.ret(stm.loc()));
+        target.add(Instruction.ret()).setLocation(stm.loc());
-        target.functions.put(0l, new FunctionBody(subscope.localsCount(), 0, target.array(), subscope.captures(), subscope.locals()));
 
         return target;
     }
-    public static CompileTarget compile(Environment environment, Filename filename, String raw) {
+    public static CompileResult compile(Filename filename, String raw) {
-        try { return compile(environment, parse(filename, raw)); }
+        return compile(parse(filename, raw));
-        catch (SyntaxException e) { return compile(environment, new ThrowSyntaxStatement(e)); }
     }
 }

src/java/me/topchetoeu/jscript/compilation/parsing/RawToken.java

@@ -1,4 +1,4 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 public class RawToken {
     public final String value;

src/java/me/topchetoeu/jscript/compilation/parsing/TestRes.java

@@ -1,7 +1,7 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.parsing.ParseRes.State;
+import me.topchetoeu.jscript.compilation.parsing.ParseRes.State;
 
 public class TestRes {
     public final State state;

src/java/me/topchetoeu/jscript/compilation/parsing/Token.java

@@ -1,21 +1,24 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 public class Token {
     public final Object value;
+    public final String rawValue;
     public final boolean isString;
     public final boolean isRegex;
     public final int line;
     public final int start;
 
-    private Token(int line, int start, Object value, boolean isString, boolean isRegex) {
+    private Token(int line, int start, Object value, String rawValue, boolean isString, boolean isRegex) {
         this.value = value;
+        this.rawValue = rawValue;
         this.line = line;
         this.start = start;
         this.isString = isString;
         this.isRegex = isRegex;
     }
-    private Token(int line, int start, Object value) {
+    private Token(int line, int start, Object value, String rawValue) {
         this.value = value;
+        this.rawValue = rawValue;
         this.line = line;
         this.start = start;
         this.isString = false;
@@ -37,19 +40,19 @@ public class Token {
     public String identifier() { return (String)value; }
     public Operator operator() { return (Operator)value; }
 
-    public static Token regex(int line, int start, String val) {
+    public static Token regex(int line, int start, String val, String rawValue) {
-        return new Token(line, start, val, false, true);
+        return new Token(line, start, val, rawValue, false, true);
     }
-    public static Token string(int line, int start, String val) {
+    public static Token string(int line, int start, String val, String rawValue) {
-        return new Token(line, start, val, true, false);
+        return new Token(line, start, val, rawValue, true, false);
     }
-    public static Token number(int line, int start, double val) {
+    public static Token number(int line, int start, double val, String rawValue) {
-        return new Token(line, start, val);
+        return new Token(line, start, val, rawValue);
     }
     public static Token identifier(int line, int start, String val) {
-        return new Token(line, start, val);
+        return new Token(line, start, val, val);
     }
     public static Token operator(int line, int start, Operator val) {
-        return new Token(line, start, val);
+        return new Token(line, start, val, val.readable);
     }
 }

src/java/me/topchetoeu/jscript/compilation/parsing/TokenType.java

@@ -1,4 +1,4 @@
-package me.topchetoeu.jscript.core.parsing;
+package me.topchetoeu.jscript.compilation.parsing;
 
 enum TokenType {
     REGEX,

src/java/me/topchetoeu/jscript/compilation/scope/LocalScopeRecord.java

@@ -1,4 +1,4 @@
-package me.topchetoeu.jscript.core.engine.scope;
+package me.topchetoeu.jscript.compilation.scope;
 
 import java.util.ArrayList;
 

src/java/me/topchetoeu/jscript/compilation/scope/ScopeRecord.java

@@ -1,4 +1,4 @@
-package me.topchetoeu.jscript.core.engine.scope;
+package me.topchetoeu.jscript.compilation.scope;
 
 public interface ScopeRecord {
     public Object getKey(String name);

src/java/me/topchetoeu/jscript/compilation/values/ArrayStatement.java

@@ -0,0 +1,40 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ArrayStatement extends Statement {
+    public final Statement[] statements;
+
+    @Override public boolean pure() {
+        for (var stm : statements) {
+            if (!stm.pure()) return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.loadArr(statements.length));
+
+        for (var i = 0; i < statements.length; i++) {
+            var el = statements[i];
+            if (el != null) {
+                target.add(Instruction.dup());
+                target.add(Instruction.pushValue(i));
+                el.compile(target, true);
+                target.add(Instruction.storeMember());
+            }
+        }
+
+        if (!pollute) target.add(Instruction.discard());
+    }
+
+    public ArrayStatement(Location loc, Statement[] statements) {
+        super(loc);
+        this.statements = statements;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/CallStatement.java

@@ -0,0 +1,43 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class CallStatement extends Statement {
+    public final Statement func;
+    public final Statement[] args;
+    public final boolean isNew;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute, BreakpointType type) {
+        if (isNew) func.compile(target, true);
+        else if (func instanceof IndexStatement) {
+            ((IndexStatement)func).compile(target, true, true);
+        }
+        else {
+            target.add(Instruction.pushUndefined());
+            func.compile(target, true);
+        }
+
+        for (var arg : args) arg.compile(target, true);
+
+        if (isNew) target.add(Instruction.callNew(args.length)).setLocationAndDebug(loc(), type);
+        else target.add(Instruction.call(args.length)).setLocationAndDebug(loc(), type);
+
+        if (!pollute) target.add(Instruction.discard());
+    }
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        compile(target, pollute, BreakpointType.STEP_IN);
+    }
+
+    public CallStatement(Location loc, boolean isNew, Statement func, Statement ...args) {
+        super(loc);
+        this.isNew = isNew;
+        this.func = func;
+        this.args = args;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/ChangeStatement.java

@@ -0,0 +1,31 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ChangeStatement extends Statement {
+    public final AssignableStatement value;
+    public final double addAmount;
+    public final boolean postfix;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        value.toAssign(new ConstantStatement(loc(), -addAmount), Operation.SUBTRACT).compile(target, true);
+        if (!pollute) target.add(Instruction.discard());
+        else if (postfix) {
+            target.add(Instruction.pushValue(addAmount));
+            target.add(Instruction.operation(Operation.SUBTRACT));
+        }
+    }
+
+    public ChangeStatement(Location loc, AssignableStatement value, double addAmount, boolean postfix) {
+        super(loc);
+        this.value = value;
+        this.addAmount = addAmount;
+        this.postfix = postfix;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/ConstantStatement.java

@@ -0,0 +1,47 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ConstantStatement extends Statement {
+    public final Object value;
+    public final boolean isNull;
+
+    @Override public boolean pure() { return true; }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        if (pollute) {
+            if (isNull) target.add(Instruction.pushNull());
+            else if (value instanceof Double) target.add(Instruction.pushValue((Double)value));
+            else if (value instanceof String) target.add(Instruction.pushValue((String)value));
+            else if (value instanceof Boolean) target.add(Instruction.pushValue((Boolean)value));
+            else target.add(Instruction.pushUndefined());
+        }
+    }
+
+    private ConstantStatement(Location loc, Object val, boolean isNull) {
+        super(loc);
+        this.value = val;
+        this.isNull = isNull;
+    }
+
+    public ConstantStatement(Location loc, boolean val) {
+        this(loc, val, false);
+    }
+    public ConstantStatement(Location loc, String val) {
+        this(loc, val, false);
+    }
+    public ConstantStatement(Location loc, double val) {
+        this(loc, val, false);
+    }
+
+    public static ConstantStatement ofUndefined(Location loc) {
+        return new ConstantStatement(loc, null, false);
+    }
+    public static ConstantStatement ofNull(Location loc) {
+        return new ConstantStatement(loc, null, true);
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/DiscardStatement.java

@@ -0,0 +1,23 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class DiscardStatement extends Statement {
+    public final Statement value;
+
+    @Override public boolean pure() { return value.pure(); }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        value.compile(target, false);
+        if (pollute) target.add(Instruction.pushUndefined());
+    }
+
+    public DiscardStatement(Location loc, Statement val) {
+        super(loc);
+        this.value = val;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/FunctionStatement.java

@@ -0,0 +1,127 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.common.Instruction.Type;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.CompoundStatement;
+import me.topchetoeu.jscript.compilation.Statement;
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
+
+public class FunctionStatement extends Statement {
+    public final CompoundStatement body;
+    public final String varName;
+    public final String[] args;
+    public final boolean statement;
+    public final Location end;
+
+    @Override public boolean pure() { return varName == null && statement; }
+
+    @Override
+    public void declare(CompileResult target) {
+        if (varName != null && statement) target.scope.define(varName);
+    }
+
+    public static void checkBreakAndCont(CompileResult 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") ) {
+                    throw new SyntaxException(target.map.toLocation(i), "Break was placed outside a loop.");
+                }
+                if (target.get(i).is(0, "cont")) {
+                    throw new SyntaxException(target.map.toLocation(i), "Continue was placed outside a loop.");
+                }
+            }
+        }
+    }
+
+    private CompileResult compileBody(CompileResult target, boolean pollute, BreakpointType bp) {
+        for (var i = 0; i < args.length; i++) {
+            for (var j = 0; j < i; j++) {
+                if (args[i].equals(args[j])) {
+                    throw new SyntaxException(loc(), "Duplicate parameter '" + args[i] + "'.");
+                }
+            }
+        }
+
+        var subtarget = new CompileResult(target.scope.child());
+
+        subtarget.scope.define("this");
+        var argsVar = subtarget.scope.define("arguments");
+
+        if (args.length > 0) {
+            for (var i = 0; i < args.length; i++) {
+                subtarget.add(Instruction.loadVar(argsVar));
+                subtarget.add(Instruction.pushValue(i));
+                subtarget.add(Instruction.loadMember());
+                subtarget.add(Instruction.storeVar(subtarget.scope.define(args[i])));
+            }
+        }
+
+        if (!statement && this.varName != null) {
+            subtarget.add(Instruction.storeSelfFunc((int)subtarget.scope.define(this.varName))).setLocationAndDebug(loc(), bp);
+        }
+
+        body.declare(subtarget);
+        body.compile(subtarget, false);
+        subtarget.length = args.length;
+        subtarget.add(Instruction.ret()).setLocation(end);
+        checkBreakAndCont(subtarget, 0);
+
+        if (pollute) target.add(Instruction.loadFunc(target.children.size(), subtarget.scope.getCaptures()));
+        return target.addChild(subtarget);
+    }
+
+    public void compile(CompileResult target, 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, pollute || hasVar || hasName, bp);
+
+        if (hasName) {
+            if (pollute || hasVar) target.add(Instruction.dup());
+            target.add(Instruction.pushValue("name"));
+            target.add(Instruction.pushValue(name));
+            target.add(Instruction.storeMember());
+        }
+
+        if (hasVar) {
+            var key = target.scope.getKey(this.varName);
+
+            if (key instanceof String) target.add(Instruction.makeVar((String)key));
+            target.add(Instruction.storeVar(target.scope.getKey(this.varName), false));
+        }
+    }
+    public void compile(CompileResult target, boolean pollute, String name) {
+        compile(target, pollute, name, BreakpointType.NONE);
+    }
+    @Override public void compile(CompileResult target, boolean pollute, BreakpointType bp) {
+        compile(target, pollute, (String)null, bp);
+    }
+    @Override public void compile(CompileResult target, boolean pollute) {
+        compile(target, pollute, (String)null, BreakpointType.NONE);
+    }
+
+    public FunctionStatement(Location loc, Location end, String varName, String[] args, boolean statement, CompoundStatement body) {
+        super(loc);
+
+        this.end = end;
+        this.varName = varName;
+        this.statement = statement;
+
+        this.args = args;
+        this.body = body;
+    }
+
+    public static void compileWithName(Statement stm, CompileResult target, boolean pollute, String name) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, pollute, name);
+        else stm.compile(target, pollute);
+    }
+    public static void compileWithName(Statement stm, CompileResult target, boolean pollute, String name, BreakpointType bp) {
+        if (stm instanceof FunctionStatement) ((FunctionStatement)stm).compile(target, pollute, name, bp);
+        else stm.compile(target, pollute, bp);
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/GlobalThisStatement.java

@@ -0,0 +1,19 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class GlobalThisStatement extends Statement {
+    @Override public boolean pure() { return true; }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        if (pollute) target.add(Instruction.loadGlob());
+    }
+
+    public GlobalThisStatement(Location loc) {
+        super(loc);
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/IndexAssignStatement.java

@@ -0,0 +1,45 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class IndexAssignStatement extends Statement {
+    public final Statement object;
+    public final Statement index;
+    public final Statement value;
+    public final Operation operation;
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        if (operation != null) {
+            object.compile(target, true);
+            index.compile(target, true);
+            target.add(Instruction.dup(2));
+
+            target.add(Instruction.loadMember());
+            value.compile(target, true);
+            target.add(Instruction.operation(operation));
+
+            target.add(Instruction.storeMember(pollute)).setLocationAndDebug(loc(), BreakpointType.STEP_IN);
+        }
+        else {
+            object.compile(target, true);
+            index.compile(target, true);
+            value.compile(target, true);
+
+            target.add(Instruction.storeMember(pollute)).setLocationAndDebug(loc(), BreakpointType.STEP_IN);;
+        }
+    }
+
+    public IndexAssignStatement(Location loc, Statement object, Statement index, Statement value, Operation operation) {
+        super(loc);
+        this.object = object;
+        this.index = index;
+        this.value = value;
+        this.operation = operation;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/IndexStatement.java

@@ -0,0 +1,37 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.common.Instruction.BreakpointType;
+import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class IndexStatement extends AssignableStatement {
+    public final Statement object;
+    public final Statement index;
+
+    @Override
+    public Statement toAssign(Statement val, Operation operation) {
+        return new IndexAssignStatement(loc(), object, index, val, operation);
+    }
+    public void compile(CompileResult target, boolean dupObj, boolean pollute) {
+        object.compile(target, true);
+        if (dupObj) target.add(Instruction.dup());
+
+        index.compile(target, true);
+        target.add(Instruction.loadMember()).setLocationAndDebug(loc(), BreakpointType.STEP_IN);
+        if (!pollute) target.add(Instruction.discard());
+    }
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        compile(target, false, pollute);
+    }
+
+    public IndexStatement(Location loc, Statement object, Statement index) {
+        super(loc);
+        this.object = object;
+        this.index = index;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/LazyAndStatement.java

@@ -0,0 +1,28 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class LazyAndStatement extends Statement {
+    public final Statement first, second;
+
+    @Override public boolean pure() { return first.pure() && second.pure(); }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        first.compile(target, true);
+        if (pollute) target.add(Instruction.dup());
+        int start = target.temp();
+        if (pollute) target.add(Instruction.discard());
+        second.compile(target, pollute);
+        target.set(start, Instruction.jmpIfNot(target.size() - start));
+    }
+
+    public LazyAndStatement(Location loc, Statement first, Statement second) {
+        super(loc);
+        this.first = first;
+        this.second = second;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/LazyOrStatement.java

@@ -0,0 +1,28 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class LazyOrStatement extends Statement {
+    public final Statement first, second;
+
+    @Override public boolean pure() { return first.pure() && second.pure(); }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        first.compile(target, true);
+        if (pollute) target.add(Instruction.dup());
+        int start = target.temp();
+        if (pollute) target.add(Instruction.discard());
+        second.compile(target, pollute);
+        target.set(start, Instruction.jmpIf(target.size() - start));
+    }
+
+    public LazyOrStatement(Location loc, Statement first, Statement second) {
+        super(loc);
+        this.first = first;
+        this.second = second;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/ObjectStatement.java

@@ -0,0 +1,61 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import java.util.ArrayList;
+import java.util.Map;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class ObjectStatement extends Statement {
+    public final Map<String, Statement> map;
+    public final Map<String, FunctionStatement> getters;
+    public final Map<String, FunctionStatement> setters;
+
+    @Override public boolean pure() {
+        for (var el : map.values()) {
+            if (!el.pure()) return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.loadObj());
+
+        for (var el : map.entrySet()) {
+            target.add(Instruction.dup());
+            target.add(Instruction.pushValue(el.getKey()));
+            var val = el.getValue();
+            FunctionStatement.compileWithName(val, target, true, el.getKey().toString());
+            target.add(Instruction.storeMember());
+        }
+
+        var keys = new ArrayList<Object>();
+        keys.addAll(getters.keySet());
+        keys.addAll(setters.keySet());
+
+        for (var key : keys) {
+            target.add(Instruction.pushValue((String)key));
+
+            if (getters.containsKey(key)) getters.get(key).compile(target, true);
+            else target.add(Instruction.pushUndefined());
+
+            if (setters.containsKey(key)) setters.get(key).compile(target, true);
+            else target.add(Instruction.pushUndefined());
+
+            target.add(Instruction.defProp());
+        }
+
+        if (!pollute) target.add(Instruction.discard());
+    }
+
+    public ObjectStatement(Location loc, Map<String, Statement> map, Map<String, FunctionStatement> getters, Map<String, FunctionStatement> setters) {
+        super(loc);
+        this.map = map;
+        this.getters = getters;
+        this.setters = setters;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/OperationStatement.java

@@ -0,0 +1,36 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class OperationStatement extends Statement {
+    public final Statement[] args;
+    public final Operation operation;
+
+    @Override public boolean pure() {
+        for (var el : args) {
+            if (!el.pure()) return false;
+        }
+
+        return true;
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        for (var arg : args) {
+            arg.compile(target, true);
+        }
+
+        if (pollute) target.add(Instruction.operation(operation));
+        else target.add(Instruction.discard());
+    }
+
+    public OperationStatement(Location loc, Operation operation, Statement ...args) {
+        super(loc);
+        this.operation = operation;
+        this.args = args;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/RegexStatement.java

@@ -0,0 +1,25 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class RegexStatement extends Statement {
+    public final String pattern, flags;
+
+    // Not really pure, since a function is called, but can be ignored.
+    @Override public boolean pure() { return true; }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        target.add(Instruction.loadRegex(pattern, flags));
+        if (!pollute) target.add(Instruction.discard());
+    }
+
+    public RegexStatement(Location loc, String pattern, String flags) {
+        super(loc);
+        this.pattern = pattern;
+        this.flags = flags;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/TypeofStatement.java

@@ -1,10 +1,9 @@
-package me.topchetoeu.jscript.core.compilation.values;
+package me.topchetoeu.jscript.compilation.values;
 
+import me.topchetoeu.jscript.common.Instruction;
 import me.topchetoeu.jscript.common.Location;
-import me.topchetoeu.jscript.core.compilation.CompileTarget;
+import me.topchetoeu.jscript.compilation.CompileResult;
-import me.topchetoeu.jscript.core.compilation.Instruction;
+import me.topchetoeu.jscript.compilation.Statement;
-import me.topchetoeu.jscript.core.compilation.Statement;
-import me.topchetoeu.jscript.core.engine.scope.ScopeRecord;
 
 public class TypeofStatement extends Statement {
     public final Statement value;
@@ -14,16 +13,16 @@ public class TypeofStatement extends Statement {
     @Override public boolean pure() { return true; }
 
     @Override
-    public void compile(CompileTarget target, ScopeRecord scope, boolean pollute) {
+    public void compile(CompileResult target, boolean pollute) {
         if (value instanceof VariableStatement) {
-            var i = scope.getKey(((VariableStatement)value).name);
+            var i = target.scope.getKey(((VariableStatement)value).name);
             if (i instanceof String) {
-                target.add(Instruction.typeof(loc(), (String)i));
+                target.add(Instruction.typeof((String)i));
                 return;
             }
         }
-        value.compile(target, scope, pollute);
+        value.compile(target, pollute);
-        target.add(Instruction.typeof(loc()));
+        target.add(Instruction.typeof());
     }
 
     public TypeofStatement(Location loc, Statement value) {

src/java/me/topchetoeu/jscript/compilation/values/VariableAssignStatement.java

@@ -0,0 +1,37 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class VariableAssignStatement extends Statement {
+    public final String name;
+    public final Statement value;
+    public final Operation operation;
+
+    @Override public boolean pure() { return false; }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        var i = target.scope.getKey(name);
+        if (operation != null) {
+            target.add(Instruction.loadVar(i));
+            FunctionStatement.compileWithName(value, target, true, name);
+            target.add(Instruction.operation(operation));
+            target.add(Instruction.storeVar(i, pollute));
+        }
+        else {
+            FunctionStatement.compileWithName(value, target, true, name);
+            target.add(Instruction.storeVar(i, pollute));
+        }
+    }
+
+    public VariableAssignStatement(Location loc, String name, Statement val, Operation operation) {
+        super(loc);
+        this.name = name;
+        this.value = val;
+        this.operation = operation;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/VariableIndexStatement.java

@@ -0,0 +1,22 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class VariableIndexStatement extends Statement {
+    public final int index;
+
+    @Override public boolean pure() { return true; }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        if (pollute) target.add(Instruction.loadVar(index));
+    }
+
+    public VariableIndexStatement(Location loc, int i) {
+        super(loc);
+        this.index = i;
+    }
+}

src/java/me/topchetoeu/jscript/compilation/values/VariableStatement.java

@@ -0,0 +1,31 @@
+package me.topchetoeu.jscript.compilation.values;
+
+import me.topchetoeu.jscript.common.Instruction;
+import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Operation;
+import me.topchetoeu.jscript.compilation.AssignableStatement;
+import me.topchetoeu.jscript.compilation.CompileResult;
+import me.topchetoeu.jscript.compilation.Statement;
+
+public class VariableStatement extends AssignableStatement {
+    public final String name;
+
+    @Override public boolean pure() { return false; }
+
+    @Override
+    public Statement toAssign(Statement val, Operation operation) {
+        return new VariableAssignStatement(loc(), name, val, operation);
+    }
+
+    @Override
+    public void compile(CompileResult target, boolean pollute) {
+        var i = target.scope.getKey(name);
+        target.add(Instruction.loadVar(i));
+        if (!pollute) target.add(Instruction.discard());
+    }
+
+    public VariableStatement(Location loc, String name) {
+        super(loc);
+        this.name = name;
+    }
+}

src/java/me/topchetoeu/jscript/lib/ArrayLib.java

@@ -3,11 +3,11 @@ package me.topchetoeu.jscript.lib;
 import java.util.Iterator;
 import java.util.Stack;
 
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
-import me.topchetoeu.jscript.core.engine.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
@@ -94,7 +94,7 @@ public class ArrayLib {
             if (arrs.get(i) instanceof ArrayValue) {
                 var arrEl = arrs.convert(i, ArrayValue.class);
                 int n = arrEl.size();
-                arrEl.copyTo(args.ctx, res, 0, j, n);
+                arrEl.copyTo(res, 0, j, n);
                 j += n;
             }
             else {
@@ -382,7 +382,7 @@ public class ArrayLib {
         var end = normalizeI(arr.size(), args.getInt(1, arr.size()), true);
 
         var res = new ArrayValue(end - start);
-        arr.copyTo(args.ctx, res, start, 0, end - start);
+        arr.copyTo(res, start, 0, end - start);
         return res;
     }
 
@@ -396,7 +396,7 @@ public class ArrayLib {
 
         var size = arr.size() - deleteCount + items.length;
         var res = new ArrayValue(deleteCount);
-        arr.copyTo(args.ctx, res, start, 0, deleteCount);
+        arr.copyTo(res, start, 0, deleteCount);
         arr.move(start + deleteCount, start + items.length, arr.size() - start - deleteCount);
         arr.copyFrom(args.ctx, items, 0, start, items.length);
         arr.setSize(size);

src/java/me/topchetoeu/jscript/lib/AsyncFunctionLib.java

@@ -1,23 +1,24 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.Context;
-import me.topchetoeu.jscript.core.engine.frame.CodeFrame;
-import me.topchetoeu.jscript.core.engine.values.CodeFunction;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
-import me.topchetoeu.jscript.core.engine.values.NativeFunction;
-import me.topchetoeu.jscript.core.engine.values.Values;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
 import me.topchetoeu.jscript.lib.PromiseLib.Handle;
+import me.topchetoeu.jscript.runtime.Context;
+import me.topchetoeu.jscript.runtime.Extensions;
+import me.topchetoeu.jscript.runtime.Frame;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.CodeFunction;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
 
 @WrapperName("AsyncFunction")
 public class AsyncFunctionLib extends FunctionValue {
-    public final FunctionValue factory;
+    public final CodeFunction func;
 
     private static class AsyncHelper {
         public PromiseLib promise = new PromiseLib();
-        public CodeFrame frame;
+        public Frame frame;
 
         private boolean awaiting = false;
 
@@ -54,7 +55,7 @@ public class AsyncFunctionLib extends FunctionValue {
                     public void onReject(EngineException err) {
                         next(ctx, Values.NO_RETURN, err);
                     }
-                });
+                }.defer(ctx));
             }
         }
 
@@ -65,17 +66,22 @@ public class AsyncFunctionLib extends FunctionValue {
     }
 
     @Override
-    public Object call(Context ctx, Object thisArg, Object ...args) {
+    public Object call(Extensions ext, Object thisArg, Object ...args) {
         var handler = new AsyncHelper();
-        var func = factory.call(ctx, thisArg, new NativeFunction("await", handler::await));
+        var ctx = Context.of(ext);
-        if (!(func instanceof CodeFunction)) throw EngineException.ofType("Return value of argument must be a js function.");
+
-        handler.frame = new CodeFrame(ctx, thisArg, args, (CodeFunction)func);
+        var newArgs = new Object[args.length + 1];
+        newArgs[0] = new NativeFunction("await", handler::await);
+        System.arraycopy(args, 0, newArgs, 1, args.length);
+
+        handler.frame = new Frame(ctx, thisArg, newArgs, (CodeFunction)func);
         handler.next(ctx, Values.NO_RETURN, null);
         return handler.promise;
     }
 
-    public AsyncFunctionLib(FunctionValue factory) {
+    public AsyncFunctionLib(FunctionValue func) {
-        super(factory.name, factory.length);
+        super(func.name, func.length);
-        this.factory = factory;
+        if (!(func instanceof CodeFunction)) throw EngineException.ofType("Return value of argument must be a js function.");
+        this.func = (CodeFunction)func;
     }
 }

src/java/me/topchetoeu/jscript/lib/AsyncGeneratorFunctionLib.java

@@ -0,0 +1,34 @@
+package me.topchetoeu.jscript.lib;
+
+import me.topchetoeu.jscript.runtime.Context;
+import me.topchetoeu.jscript.runtime.Extensions;
+import me.topchetoeu.jscript.runtime.Frame;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.CodeFunction;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.utils.interop.WrapperName;
+
+@WrapperName("AsyncGeneratorFunction")
+public class AsyncGeneratorFunctionLib extends FunctionValue {
+    public final CodeFunction func;
+
+    @Override
+    public Object call(Extensions ext, Object thisArg, Object ...args) {
+        var handler = new AsyncGeneratorLib();
+
+        var newArgs = new Object[args.length + 2];
+        newArgs[0] = new NativeFunction("await", handler::await);
+        newArgs[1] = new NativeFunction("yield", handler::yield);
+        System.arraycopy(args, 0, newArgs, 2, args.length);
+
+        handler.frame = new Frame(Context.of(ext), thisArg, newArgs, func);
+        return handler;
+    }
+
+    public AsyncGeneratorFunctionLib(CodeFunction func) {
+        super(func.name, func.length);
+        if (!(func instanceof CodeFunction)) throw EngineException.ofType("Return value of argument must be a js function.");
+        this.func = func;
+    }
+}

src/java/me/topchetoeu/jscript/lib/AsyncGeneratorLib.java

@@ -2,12 +2,12 @@ package me.topchetoeu.jscript.lib;
 
 import java.util.Map;
 
-import me.topchetoeu.jscript.core.engine.Context;
-import me.topchetoeu.jscript.core.engine.frame.CodeFrame;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
 import me.topchetoeu.jscript.lib.PromiseLib.Handle;
+import me.topchetoeu.jscript.runtime.Context;
+import me.topchetoeu.jscript.runtime.Frame;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
@@ -17,7 +17,7 @@ public class AsyncGeneratorLib {
     private int state = 0;
     private boolean done = false;
     private PromiseLib currPromise;
-    public CodeFrame frame;
+    public Frame frame;
 
     private void next(Context ctx, Object inducedValue, Object inducedReturn, EngineException inducedError) {
         if (done) {
@@ -62,7 +62,7 @@ public class AsyncGeneratorLib {
                 @Override public void onReject(EngineException err) {
                     next(ctx, Values.NO_RETURN, Values.NO_RETURN, err);
                 }
-            });
+            }.defer(ctx));
         }
         else if (state == 2) {
             var obj = new ObjectValue();
@@ -101,7 +101,7 @@ public class AsyncGeneratorLib {
     }
     @Expose public PromiseLib __throw(Arguments args) {
         this.currPromise = new PromiseLib();
-        next(args.ctx, Values.NO_RETURN, Values.NO_RETURN, new EngineException(args.get(0)).setCtx(args.ctx));
+        next(args.ctx, Values.NO_RETURN, Values.NO_RETURN, new EngineException(args.get(0)).setExtensions(args.ctx));
         return this.currPromise;
     }
 }

src/java/me/topchetoeu/jscript/lib/BooleanLib.java

@@ -1,7 +1,7 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;

src/java/me/topchetoeu/jscript/lib/ConsoleLib.java

@@ -0,0 +1,38 @@
+package me.topchetoeu.jscript.lib;
+
+import java.io.IOException;
+
+import me.topchetoeu.jscript.runtime.values.Values;
+import me.topchetoeu.jscript.utils.filesystem.File;
+import me.topchetoeu.jscript.utils.interop.Arguments;
+import me.topchetoeu.jscript.utils.interop.Expose;
+import me.topchetoeu.jscript.utils.interop.WrapperName;
+
+@WrapperName("Console")
+public class ConsoleLib {
+    public static interface Writer {
+        void writeLine(String val) throws IOException;
+    }
+
+    private File file;
+
+    @Expose
+    public void __log(Arguments args) {
+        var res = new StringBuilder();
+        var first = true;
+        
+        for (var el : args.args) {
+            if (!first) res.append(" ");
+            first = false;
+            res.append(Values.toReadable(args.ctx, el).getBytes());
+        }
+
+        for (var line : res.toString().split("\n", -1)) {
+            file.write(line.getBytes());
+        }
+    }
+
+    public ConsoleLib(File file) {
+        this.file = file;
+    }
+}

src/java/me/topchetoeu/jscript/lib/EncodingLib.java

@@ -3,10 +3,10 @@ package me.topchetoeu.jscript.lib;
 import java.util.ArrayList;
 
 import me.topchetoeu.jscript.common.Buffer;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.compilation.parsing.Parsing;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.parsing.Parsing;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeTarget;

src/java/me/topchetoeu/jscript/lib/ErrorLib.java

@@ -1,10 +1,10 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.exceptions.ConvertException;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue.PlaceholderProto;
+import me.topchetoeu.jscript.runtime.values.Values;
-import me.topchetoeu.jscript.core.exceptions.ConvertException;
+import me.topchetoeu.jscript.runtime.values.ObjectValue.PlaceholderProto;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;

src/java/me/topchetoeu/jscript/lib/FileLib.java

@@ -1,7 +1,7 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.filesystem.File;
 import me.topchetoeu.jscript.utils.filesystem.FilesystemException;
 import me.topchetoeu.jscript.utils.interop.Arguments;
@@ -10,12 +10,12 @@ import me.topchetoeu.jscript.utils.interop.WrapperName;
 
 @WrapperName("File")
 public class FileLib {
-    public final File file;
+    public final File fd;
 
     @Expose public PromiseLib __pointer(Arguments args) {
         return PromiseLib.await(args.ctx, () -> {
             try {
-                return file.seek(0, 1);
+                return fd.seek(0, 1);
             }
             catch (FilesystemException e) { throw e.toEngineException(); }
         });
@@ -23,9 +23,9 @@ public class FileLib {
     @Expose public PromiseLib __length(Arguments args) {
         return PromiseLib.await(args.ctx, () -> {
             try {
-                long curr = file.seek(0, 1);
+                long curr = fd.seek(0, 1);
-                long res = file.seek(0, 2);
+                long res = fd.seek(0, 2);
-                file.seek(curr, 0);
+                fd.seek(curr, 0);
                 return res;
             }
             catch (FilesystemException e) { throw e.toEngineException(); }
@@ -38,8 +38,8 @@ public class FileLib {
             try {
                 var buff = new byte[n];
                 var res = new ArrayValue();
-                int resI = file.read(buff);
+                int resI = fd.read(buff);
-    
+
                 for (var i = resI - 1; i >= 0; i--) res.set(args.ctx, i, (int)buff[i]);
                 return res;
             }
@@ -53,7 +53,7 @@ public class FileLib {
                 var res = new byte[val.size()];
 
                 for (var i = 0; i < val.size(); i++) res[i] = (byte)Values.toNumber(args.ctx, val.get(i));
-                file.write(res);
+                fd.write(res);
 
                 return null;
             }
@@ -62,7 +62,7 @@ public class FileLib {
     }
     @Expose public PromiseLib __close(Arguments args) {
         return PromiseLib.await(args.ctx, () -> {
-            file.close();
+            fd.close();
             return null;
         });
     }
@@ -72,13 +72,13 @@ public class FileLib {
             var whence = args.getInt(1);
 
             try {
-                return file.seek(ptr, whence);
+                return fd.seek(ptr, whence);
             }
             catch (FilesystemException e) { throw e.toEngineException(); }
         });
     }
 
-    public FileLib(File file) {
+    public FileLib(File fd) {
-        this.file = file;
+        this.fd = fd;
     }
 }

src/java/me/topchetoeu/jscript/lib/FilesystemLib.java

@@ -4,17 +4,18 @@ import java.io.IOException;
 import java.util.Iterator;
 import java.util.Stack;
 
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.Values;
+import me.topchetoeu.jscript.utils.filesystem.ActionType;
 import me.topchetoeu.jscript.utils.filesystem.EntryType;
+import me.topchetoeu.jscript.utils.filesystem.ErrorReason;
 import me.topchetoeu.jscript.utils.filesystem.File;
 import me.topchetoeu.jscript.utils.filesystem.FileStat;
 import me.topchetoeu.jscript.utils.filesystem.Filesystem;
 import me.topchetoeu.jscript.utils.filesystem.FilesystemException;
 import me.topchetoeu.jscript.utils.filesystem.Mode;
-import me.topchetoeu.jscript.utils.filesystem.FilesystemException.FSCode;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeField;
@@ -50,11 +51,10 @@ public class FilesystemLib {
 
             try {
                 if (fs.stat(path).type != EntryType.FILE) {
-                    throw new FilesystemException(path, FSCode.NOT_FILE);
+                    throw new FilesystemException(ErrorReason.DOESNT_EXIST, "Not a file").setAction(ActionType.OPEN).setPath(path);
                 }
 
-                var file = fs.open(path, _mode);
+                return new FileLib(fs.open(path, _mode));
-                return new FileLib(file);
             }
             catch (FilesystemException e) { throw e.toEngineException(); }
         });
@@ -75,7 +75,7 @@ public class FilesystemLib {
                         var path = fs.normalize(args.getString(0));
 
                         if (fs.stat(path).type != EntryType.FOLDER) {
-                            throw new FilesystemException(path, FSCode.NOT_FOLDER);
+                            throw new FilesystemException(ErrorReason.DOESNT_EXIST, "Not a directory").setAction(ActionType.OPEN);
                         }
 
                         file = fs.open(path, Mode.READ);

src/java/me/topchetoeu/jscript/lib/FunctionLib.java

@@ -1,21 +1,24 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.common.Location;
+import me.topchetoeu.jscript.common.Filename;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.Compiler;
-import me.topchetoeu.jscript.core.engine.values.CodeFunction;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.scope.ValueVariable;
-import me.topchetoeu.jscript.core.engine.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.CodeFunction;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
+import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
 import me.topchetoeu.jscript.utils.interop.ExposeTarget;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
 
 @WrapperName("Function")
 public class FunctionLib {
-    @Expose public static Object __location(Arguments args) {
+    private static int i;
-        if (args.self instanceof CodeFunction) return ((CodeFunction)args.self).loc().toString();
+
-        else return Location.INTERNAL.toString();
-    }
     @Expose public static Object __apply(Arguments args) {
         return args.self(FunctionValue.class).call(args.ctx, args.get(0), args.convert(1, ArrayValue.class).toArray());
     }
@@ -50,10 +53,31 @@ public class FunctionLib {
     }
     @Expose(target = ExposeTarget.STATIC)
     public static FunctionValue __asyncGenerator(Arguments args) {
-        return new AsyncGeneratorFunctionLib(args.convert(0, FunctionValue.class));
+        return new AsyncGeneratorFunctionLib(args.convert(0, CodeFunction.class));
     }
     @Expose(target = ExposeTarget.STATIC)
     public static FunctionValue __generator(Arguments args) {
-        return new GeneratorFunctionLib(args.convert(0, FunctionValue.class));
+        return new GeneratorFunctionLib(args.convert(0, CodeFunction.class));
+    }
+
+    @ExposeConstructor
+    public static Object __constructor(Arguments args) {
+        var compiler = Compiler.get(args);
+
+        var parts = args.convert(String.class);
+        if (parts.length == 0) parts = new String[] { "" };
+
+        var src = "return function(";
+
+        for (var i = 0; i < parts.length - 1; i++) {
+            if (i != 0) src += ",";
+            src += parts[i];
+        }
+
+        src += "){" + parts[parts.length - 1] + "}";
+
+        var body = compiler.compile(new Filename("jscript", "func/" + i++), src);
+        var func = new CodeFunction(Context.clean(args.ctx), "", body, new ValueVariable[0]);
+        return Values.call(args, func, null);
     }
 }

src/java/me/topchetoeu/jscript/lib/GeneratorFunctionLib.java

@@ -0,0 +1,32 @@
+package me.topchetoeu.jscript.lib;
+
+import me.topchetoeu.jscript.runtime.Context;
+import me.topchetoeu.jscript.runtime.Extensions;
+import me.topchetoeu.jscript.runtime.Frame;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.CodeFunction;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.utils.interop.WrapperName;
+
+@WrapperName("GeneratorFunction")
+public class GeneratorFunctionLib extends FunctionValue {
+    public final CodeFunction func;
+
+    @Override public Object call(Extensions ext, Object thisArg, Object ...args) {
+        var handler = new GeneratorLib();
+
+        var newArgs = new Object[args.length + 1];
+        newArgs[0] = new NativeFunction("yield", handler::yield);
+        System.arraycopy(args, 0, newArgs, 1, args.length);
+
+        handler.frame = new Frame(Context.of(ext), thisArg, newArgs, func);
+        return handler;
+    }
+
+    public GeneratorFunctionLib(CodeFunction func) {
+        super(func.name, func.length);
+        if (!(func instanceof CodeFunction)) throw EngineException.ofType("Return value of argument must be a js function.");
+        this.func = func;
+    }
+}

src/java/me/topchetoeu/jscript/lib/GeneratorLib.java

@@ -1,10 +1,10 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.frame.CodeFrame;
+import me.topchetoeu.jscript.runtime.Frame;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
@@ -13,7 +13,7 @@ import me.topchetoeu.jscript.utils.interop.WrapperName;
 public class GeneratorLib {
     private boolean yielding = true;
     private boolean done = false;
-    public CodeFrame frame;
+    public Frame frame;
 
     private ObjectValue next(Context ctx, Object inducedValue, Object inducedReturn, EngineException inducedError) {
         if (done) {
@@ -59,7 +59,7 @@ public class GeneratorLib {
         else return next(args.ctx, args.get(0), Values.NO_RETURN, null);
     }
     @Expose public ObjectValue __throw(Arguments args) {
-        return next(args.ctx, Values.NO_RETURN, Values.NO_RETURN, new EngineException(args.get(0)).setCtx(args.ctx));
+        return next(args.ctx, Values.NO_RETURN, Values.NO_RETURN, new EngineException(args.get(0)).setExtensions(args.ctx));
     }
     @Expose public ObjectValue __return(Arguments args) {
         return next(args.ctx, Values.NO_RETURN, args.get(0), null);

src/java/me/topchetoeu/jscript/lib/Internals.java

@@ -1,25 +1,28 @@
 package me.topchetoeu.jscript.lib;
 
-import java.io.IOException;
 import java.util.HashMap;
 
-import me.topchetoeu.jscript.common.Reading;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Environment;
-import me.topchetoeu.jscript.core.engine.Environment;
+import me.topchetoeu.jscript.runtime.EventLoop;
-import me.topchetoeu.jscript.core.engine.scope.GlobalScope;
+import me.topchetoeu.jscript.runtime.Key;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.engine.values.Symbol;
+import me.topchetoeu.jscript.runtime.scope.GlobalScope;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.Values;
+import me.topchetoeu.jscript.utils.filesystem.Filesystem;
+import me.topchetoeu.jscript.utils.filesystem.Mode;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeField;
 import me.topchetoeu.jscript.utils.interop.ExposeTarget;
+import me.topchetoeu.jscript.utils.interop.ExposeType;
+import me.topchetoeu.jscript.utils.interop.NativeWrapperProvider;
 import me.topchetoeu.jscript.utils.modules.ModuleRepo;
 
 public class Internals {
-    private static final Symbol THREADS = new Symbol("Internals.threads");
+    private static final Key<HashMap<Integer, Thread>> THREADS = new Key<>();
-    private static final Symbol I = new Symbol("Internals.i");
+    private static final Key<Integer> I = new Key<>();
 
     @Expose(target = ExposeTarget.STATIC)
     public static Object __require(Arguments args) {
@@ -34,33 +37,14 @@ public class Internals {
         else throw EngineException.ofError("Modules are not supported.");
     }
 
-    @Expose(target = ExposeTarget.STATIC)
-    public static Object __log(Arguments args) {
-        for (var arg : args.args) {
-            Values.printValue(args.ctx, arg);
-            System.out.print(" ");
-        }
-        System.out.println();
-
-        return args.get(0);
-    }
-    @Expose(target = ExposeTarget.STATIC)
-    public static String __readline() {
-        try {
-            return Reading.readline();
-        }
-        catch (IOException e) {
-            e.printStackTrace();
-            return null;
-        }
-    }
-
     @Expose(target = ExposeTarget.STATIC)
     public static Thread __setTimeout(Arguments args) {
         var func = args.convert(0, FunctionValue.class);
         var delay = args.getDouble(1);
         var arguments = args.slice(2).args;
 
+        if (!args.ctx.hasNotNull(EventLoop.KEY)) throw EngineException.ofError("No event loop");
+
         var thread = new Thread(() -> {
             var ms = (long)delay;
             var ns = (int)((delay - ms) * 10000000);
@@ -68,7 +52,7 @@ public class Internals {
             try { Thread.sleep(ms, ns); }
             catch (InterruptedException e) { return; }
 
-            args.ctx.engine.pushMsg(false, args.ctx.environment, func, null, arguments);
+            args.ctx.get(EventLoop.KEY).pushMsg(() -> func.call(new Context(args.ctx.extensions), null, arguments), false);
         });
 
         thread.start();
@@ -84,6 +68,8 @@ public class Internals {
         var delay = args.getDouble(1);
         var arguments = args.slice(2).args;
 
+        if (!args.ctx.hasNotNull(EventLoop.KEY)) throw EngineException.ofError("No event loop");
+
         var thread = new Thread(() -> {
             var ms = (long)delay;
             var ns = (int)((delay - ms) * 10000000);
@@ -94,7 +80,7 @@ public class Internals {
                 }
                 catch (InterruptedException e) { return; }
 
-                args.ctx.engine.pushMsg(false, args.ctx.environment, func, null, arguments);
+                args.ctx.get(EventLoop.KEY).pushMsg(() -> func.call(new Context(args.ctx.extensions), null, arguments), false);
             }
         });
         thread.start();
@@ -144,6 +130,19 @@ public class Internals {
         return NumberLib.__isInfinite(args);
     }
 
+    @Expose(target = ExposeTarget.STATIC, type = ExposeType.GETTER)
+    public static FileLib __stdin(Arguments args) {
+        return new FileLib(Filesystem.get(args.ctx).open("std://in", Mode.READ));
+    }
+    @Expose(target = ExposeTarget.STATIC, type = ExposeType.GETTER)
+    public static FileLib __stdout(Arguments args) {
+        return new FileLib(Filesystem.get(args.ctx).open("std://out", Mode.READ));
+    }
+    @Expose(target = ExposeTarget.STATIC, type = ExposeType.GETTER)
+    public static FileLib __stderr(Arguments args) {
+        return new FileLib(Filesystem.get(args.ctx).open("std://err", Mode.READ));
+    }
+
     @ExposeField(target = ExposeTarget.STATIC)
     public static double __NaN = Double.NaN;
     @ExposeField(target = ExposeTarget.STATIC)
@@ -167,33 +166,35 @@ public class Internals {
     }
 
     public static Environment apply(Environment env) {
-        var wp = env.wrappers;
+        var wp = new NativeWrapperProvider();
-        var glob = env.global = new GlobalScope(wp.getNamespace(Internals.class));
+        var glob = new GlobalScope(wp.getNamespace(Internals.class));
 
         glob.define(null, "Math", false, wp.getNamespace(MathLib.class));
         glob.define(null, "JSON", false, wp.getNamespace(JSONLib.class));
         glob.define(null, "Encoding", false, wp.getNamespace(EncodingLib.class));
         glob.define(null, "Filesystem", false, wp.getNamespace(FilesystemLib.class));
 
-        glob.define(false, wp.getConstr(DateLib.class));
+        glob.define(null, false, wp.getConstr(FileLib.class));
-        glob.define(false, wp.getConstr(ObjectLib.class));
-        glob.define(false, wp.getConstr(FunctionLib.class));
-        glob.define(false, wp.getConstr(ArrayLib.class));
 
-        glob.define(false, wp.getConstr(BooleanLib.class));
+        glob.define(null, false, wp.getConstr(DateLib.class));
-        glob.define(false, wp.getConstr(NumberLib.class));
+        glob.define(null, false, wp.getConstr(ObjectLib.class));
-        glob.define(false, wp.getConstr(StringLib.class));
+        glob.define(null, false, wp.getConstr(FunctionLib.class));
-        glob.define(false, wp.getConstr(SymbolLib.class));
+        glob.define(null, false, wp.getConstr(ArrayLib.class));
 
-        glob.define(false, wp.getConstr(PromiseLib.class));
+        glob.define(null, false, wp.getConstr(BooleanLib.class));
-        glob.define(false, wp.getConstr(RegExpLib.class));
+        glob.define(null, false, wp.getConstr(NumberLib.class));
-        glob.define(false, wp.getConstr(MapLib.class));
+        glob.define(null, false, wp.getConstr(StringLib.class));
-        glob.define(false, wp.getConstr(SetLib.class));
+        glob.define(null, false, wp.getConstr(SymbolLib.class));
 
-        glob.define(false, wp.getConstr(ErrorLib.class));
+        glob.define(null, false, wp.getConstr(PromiseLib.class));
-        glob.define(false, wp.getConstr(SyntaxErrorLib.class));
+        glob.define(null, false, wp.getConstr(RegExpLib.class));
-        glob.define(false, wp.getConstr(TypeErrorLib.class));
+        glob.define(null, false, wp.getConstr(MapLib.class));
-        glob.define(false, wp.getConstr(RangeErrorLib.class));
+        glob.define(null, false, wp.getConstr(SetLib.class));
+
+        glob.define(null, false, wp.getConstr(ErrorLib.class));
+        glob.define(null, false, wp.getConstr(SyntaxErrorLib.class));
+        glob.define(null, false, wp.getConstr(TypeErrorLib.class));
+        glob.define(null, false, wp.getConstr(RangeErrorLib.class));
 
         env.add(Environment.OBJECT_PROTO, wp.getProto(ObjectLib.class));
         env.add(Environment.FUNCTION_PROTO, wp.getProto(FunctionLib.class));
@@ -209,8 +210,12 @@ public class Internals {
         env.add(Environment.TYPE_ERR_PROTO, wp.getProto(TypeErrorLib.class));
         env.add(Environment.RANGE_ERR_PROTO, wp.getProto(RangeErrorLib.class));
 
-        Values.setPrototype(Context.NULL, wp.getProto(ObjectLib.class), null);
         env.add(Environment.REGEX_CONSTR, wp.getConstr(RegExpLib.class));
+        Values.setPrototype(new Context(), wp.getProto(ObjectLib.class), null);
+
+        env.add(NativeWrapperProvider.KEY, wp);
+        env.add(GlobalScope.KEY, glob);
+
 
         return env;
     }

src/java/me/topchetoeu/jscript/lib/JSONLib.java

@@ -1,8 +1,8 @@
 package me.topchetoeu.jscript.lib;
 
 import me.topchetoeu.jscript.common.json.JSON;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.exceptions.SyntaxException;
+import me.topchetoeu.jscript.runtime.exceptions.SyntaxException;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeTarget;

src/java/me/topchetoeu/jscript/lib/MapLib.java

@@ -4,10 +4,10 @@ import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.stream.Collectors;
 
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;

src/java/me/topchetoeu/jscript/lib/NumberLib.java

@@ -1,7 +1,9 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import java.text.NumberFormat;
-import me.topchetoeu.jscript.core.engine.values.Values;
+
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
@@ -85,6 +87,15 @@ public class NumberLib {
     @Expose public static String __toString(Arguments args) {
         return Values.toString(args.ctx, args.self);
     }
+    @Expose public static String __toFixed(Arguments args) {
+        var digits = args.getInt(0, 0);
+
+        var nf = NumberFormat.getNumberInstance();
+        nf.setMinimumFractionDigits(digits);
+        nf.setMaximumFractionDigits(digits);
+
+        return nf.format(args.getDouble(-1));
+    }
     @Expose public static double __valueOf(Arguments args) {
         if (Values.isWrapper(args.self, NumberLib.class)) return Values.wrapper(args.self, NumberLib.class).value;
         else return Values.toNumber(args.ctx, args.self);

src/java/me/topchetoeu/jscript/lib/ObjectLib.java

@@ -1,11 +1,11 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
-import me.topchetoeu.jscript.core.engine.values.Symbol;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Symbol;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;

src/java/me/topchetoeu/jscript/lib/PromiseLib.java

@@ -4,14 +4,16 @@ import java.util.ArrayList;
 import java.util.List;
 
 import me.topchetoeu.jscript.common.ResultRunnable;
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.EventLoop;
+import me.topchetoeu.jscript.runtime.EventLoop;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.Extensions;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.exceptions.EngineException;
-import me.topchetoeu.jscript.core.engine.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.exceptions.InterruptException;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
-import me.topchetoeu.jscript.core.exceptions.EngineException;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
@@ -24,14 +26,17 @@ public class PromiseLib {
         void onFulfil(Object val);
         void onReject(EngineException err);
 
-        default Handle defer(EventLoop loop) {
+        default Handle defer(Extensions loop) {
             var self = this;
+
             return new Handle() {
                 @Override public void onFulfil(Object val) {
-                    loop.pushMsg(() -> self.onFulfil(val), true);
+                    if (!loop.hasNotNull(EventLoop.KEY)) throw EngineException.ofError("No event loop");
+                    loop.get(EventLoop.KEY).pushMsg(() -> self.onFulfil(val), true);
                 }
                 @Override public void onReject(EngineException val) {
-                    loop.pushMsg(() -> self.onReject(val), true);
+                    if (!loop.hasNotNull(EventLoop.KEY)) throw EngineException.ofError("No event loop");
+                    loop.get(EventLoop.KEY).pushMsg(() -> self.onReject(val), true);
                 }
             };
         }
@@ -48,24 +53,29 @@ public class PromiseLib {
     private Object val;
 
     private void resolveSynchronized(Context ctx, Object val, int newState) {
-        ctx.engine.pushMsg(() -> {
+        this.val = val;
-            this.val = val;
+        this.state = newState;
-            this.state = newState;
+    
-
+        for (var handle : handles) {
-            for (var handle : handles) {
+            if (newState == STATE_FULFILLED) handle.onFulfil(val);
-                if (newState == STATE_FULFILLED) handle.onFulfil(val);
+            if (newState == STATE_REJECTED) {
-                if (newState == STATE_REJECTED) {
+                handle.onReject((EngineException)val);
-                    handle.onReject((EngineException)val);
+                handled = true;
-                    handled = true;
-                }
             }
+        }
 
-            if (state == STATE_REJECTED && !handled) {
+        if (state == STATE_REJECTED && !handled) {
-                Values.printError(((EngineException)val).setCtx(ctx.environment, ctx.engine), "(in promise)");
+            Values.printError(((EngineException)val).setExtensions(ctx), "(in promise)");
-            }
+        }
 
-            handles = null;
+        handles = null;
-        }, true);
+
+        // ctx.get(EventLoop.KEY).pushMsg(() -> {
+        //     if (!ctx.hasNotNull(EventLoop.KEY)) throw EngineException.ofError("No event loop");
+
+
+        //     handles = null;
+        // }, true);
         
     }
     private synchronized void resolve(Context ctx, Object val, int newState) {
@@ -118,6 +128,12 @@ public class PromiseLib {
             catch (EngineException e) {
                 res.reject(ctx, e);
             }
+            catch (Exception e) {
+                if (e instanceof InterruptException) throw e;
+                else {
+                    res.reject(ctx, EngineException.ofError("Native code failed with " + e.getMessage()));
+                }
+            }
         }, "Promisifier").start();
 
         return res;
@@ -144,7 +160,8 @@ public class PromiseLib {
 
         try {
             var then = Values.getMember(ctx, obj, "then");
-            Values.call(ctx, then, obj,
+
+            if (then instanceof FunctionValue) Values.call(ctx, then, obj,
                 new NativeFunction(args -> {
                     try { handle.onFulfil(args.get(0)); }
                     catch (Exception e) {
@@ -162,6 +179,7 @@ public class PromiseLib {
                     return null;
                 })
             );
+            else handle.onFulfil(obj);
 
             return;
         }
@@ -189,7 +207,7 @@ public class PromiseLib {
     }
     @Expose(value = "reject", target = ExposeTarget.STATIC)
     public static PromiseLib __ofRejected(Arguments args) {
-        return ofRejected(args.ctx, new EngineException(args.get(0)).setCtx(args.ctx));
+        return ofRejected(args.ctx, new EngineException(args.get(0)).setExtensions(args.ctx));
     }
 
     @Expose(target = ExposeTarget.STATIC)
@@ -197,7 +215,7 @@ public class PromiseLib {
         if (!(args.get(0) instanceof ArrayValue)) throw EngineException.ofType("Expected argument for any to be an array.");
         var promises = args.convert(0, ArrayValue.class); 
 
-        if (promises.size() == 0) return ofRejected(args.ctx, EngineException.ofError("No promises passed to 'Promise.any'.").setCtx(args.ctx));
+        if (promises.size() == 0) return ofRejected(args.ctx, EngineException.ofError("No promises passed to 'Promise.any'.").setExtensions(args.ctx));
         var n = new int[] { promises.size() };
         var res = new PromiseLib();
         var errors = new ArrayValue();
@@ -212,7 +230,7 @@ public class PromiseLib {
                 public void onReject(EngineException err) {
                     errors.set(args.ctx, index, err.value);
                     n[0]--;
-                    if (n[0] <= 0) res.reject(args.ctx, new EngineException(errors).setCtx(args.ctx));
+                    if (n[0] <= 0) res.reject(args.ctx, new EngineException(errors).setExtensions(args.ctx));
                 }
             });
         }
@@ -325,7 +343,7 @@ public class PromiseLib {
                 try { res.fulfill(args.ctx, onReject.call(args.ctx, null, err.value)); }
                 catch (EngineException e) { res.reject(args.ctx, e); }
             }
-        }.defer(args.ctx.engine));
+        }.defer(args.ctx));
 
         return res;
     }
@@ -354,7 +372,7 @@ public class PromiseLib {
                 }
                 catch (EngineException e) { res.reject(args.ctx, e); }
             }
-        }.defer(args.ctx.engine));
+        }.defer(args.ctx));
 
         return res;
     }
@@ -372,7 +390,7 @@ public class PromiseLib {
                     return null;
                 }),
                 new NativeFunction(null, _args -> {
-                    res.reject(_args.ctx, new EngineException(_args.get(0)).setCtx(_args.ctx));
+                    res.reject(_args.ctx, new EngineException(_args.get(0)).setExtensions(_args.ctx));
                     return null;
                 })
             );

src/java/me/topchetoeu/jscript/lib/RangeErrorLib.java

@@ -1,7 +1,7 @@
 package me.topchetoeu.jscript.lib;
 
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue.PlaceholderProto;
+import me.topchetoeu.jscript.runtime.values.ObjectValue.PlaceholderProto;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
 import me.topchetoeu.jscript.utils.interop.ExposeField;

src/java/me/topchetoeu/jscript/lib/RegExpLib.java

@@ -4,12 +4,12 @@ import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.regex.Pattern;
 
-import me.topchetoeu.jscript.core.engine.Context;
+import me.topchetoeu.jscript.runtime.Context;
-import me.topchetoeu.jscript.core.engine.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.ArrayValue;
-import me.topchetoeu.jscript.core.engine.values.FunctionValue;
+import me.topchetoeu.jscript.runtime.values.FunctionValue;
-import me.topchetoeu.jscript.core.engine.values.NativeWrapper;
+import me.topchetoeu.jscript.runtime.values.NativeWrapper;
-import me.topchetoeu.jscript.core.engine.values.ObjectValue;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
-import me.topchetoeu.jscript.core.engine.values.Values;
+import me.topchetoeu.jscript.runtime.values.Values;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.ExposeConstructor;
@@ -78,13 +78,13 @@ public class RegExpLib {
         }
 
         var obj = new ArrayValue();
-        var groups = new ObjectValue();
+        ObjectValue groups = null;
 
         for (var el : namedGroups) {
+            if (groups == null) groups = new ObjectValue();
             try { groups.defineProperty(null, el, matcher.group(el)); }
             catch (IllegalArgumentException e) { }
         }
-        if (groups.values.size() == 0) groups = null;
 
 
         for (int i = 0; i < matcher.groupCount() + 1; i++) {