finshline

.gitignore

@@ -3,6 +3,8 @@
 !/src
 !/src/**/*
 
+/src/test-mod/dst
+
 !/doc
 !/doc/**/*
 

src/java/me/topchetoeu/mcscript/MessageQueue.java

@@ -88,15 +88,20 @@ public class MessageQueue {
     }
 
     public <T> T await(DataNotifier<T> notif) {
+        if (thread != Thread.currentThread()) {
+            runQueue();
+            System.out.println("Tried to await outside the queue's thread, ignoring...");
+            return null;
+        }
         if (awaiting) {
+            runQueue();
             System.out.println("Tried to double-await, ignoring...");
             return null;
         }
 
         synchronized (Thread.currentThread()) {
-            runQueue();
-
             while (true) {
+                runQueue();
                 try {
                     awaiting = true;
                     return (T)notif.await();

src/java/me/topchetoeu/mcscript/lib/MCInternals.java

@@ -29,7 +29,7 @@ import net.minecraft.server.world.ServerWorld;
 
 public class MCInternals {
     @ExposeField(target = ExposeTarget.STATIC)
-    public static final EventLib __serverLoad = new EventLib();
+    public static final EventLib __serverLoad = new EventLib(null);
 
     static {
         ServerLifecycleEvents.SERVER_STARTED.register(server -> {

src/java/me/topchetoeu/mcscript/lib/common/entities/EntityLib.java

@@ -10,7 +10,6 @@ import me.topchetoeu.mcscript.lib.server.ServerLib;
 import me.topchetoeu.mcscript.lib.utils.LocationLib;
 import net.minecraft.entity.Entity;
 import net.minecraft.nbt.NbtCompound;
-import net.minecraft.server.network.ServerPlayerEntity;
 import net.minecraft.text.Text;
 import net.minecraft.world.World;
 
@@ -50,7 +49,7 @@ public class EntityLib {
 
     @Expose(type = ExposeType.GETTER)
     public static String __uuid(Arguments args) {
-        return args.self(ServerPlayerEntity.class).getUuidAsString();
+        return args.self(Entity.class).getUuidAsString();
     }
 
     @Expose public static void __clearName(Arguments args) {

src/java/me/topchetoeu/mcscript/lib/server/ServerLib.java

@@ -4,6 +4,7 @@ import static net.minecraft.server.command.CommandManager.argument;
 import static net.minecraft.server.command.CommandManager.literal;
 
 import java.util.Map;
+import java.util.UUID;
 import java.util.WeakHashMap;
 
 import com.mojang.brigadier.Command;
@@ -25,6 +26,7 @@ import me.topchetoeu.jscript.utils.interop.ExposeTarget;
 import me.topchetoeu.jscript.utils.interop.ExposeType;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
 import me.topchetoeu.mcscript.MessageQueue;
+import me.topchetoeu.mcscript.core.Data;
 import me.topchetoeu.mcscript.events.PlayerBlockPlaceEvent;
 import me.topchetoeu.mcscript.events.ScreenHandlerEvents;
 import me.topchetoeu.mcscript.lib.utils.EventLib;
@@ -33,6 +35,8 @@ import net.fabricmc.fabric.api.entity.event.v1.ServerEntityWorldChangeEvents;
 import net.fabricmc.fabric.api.entity.event.v1.ServerLivingEntityEvents;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerTickEvents;
 import net.fabricmc.fabric.api.event.player.PlayerBlockBreakEvents;
+import net.fabricmc.fabric.api.event.player.UseEntityCallback;
+import net.fabricmc.fabric.api.event.player.UseItemCallback;
 import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
 import net.minecraft.entity.Entity;
 import net.minecraft.registry.Registries;
@@ -41,7 +45,10 @@ import net.minecraft.server.command.CommandOutput;
 import net.minecraft.server.command.ServerCommandSource;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.text.Text;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Hand;
 import net.minecraft.util.Identifier;
+import net.minecraft.util.TypedActionResult;
 import net.minecraft.util.math.Vec2f;
 import net.minecraft.util.math.Vec3d;
 
@@ -49,22 +56,44 @@ import net.minecraft.util.math.Vec3d;
 @SuppressWarnings("resource") // for crying outloud
 public class ServerLib {
     public static class EventCtx {
-        @ExposeField public final EventLib blockPlace = new EventLib();
+        @ExposeField public final EventLib blockPlace;
-        @ExposeField public final EventLib blockBreak = new EventLib();
+        @ExposeField public final EventLib blockBreak;
-        @ExposeField public final EventLib tickStart = new EventLib();
+
-        @ExposeField public final EventLib tickEnd = new EventLib();
+        @ExposeField public final EventLib tickStart;
-        @ExposeField public final EventLib playerJoin = new EventLib();
+        @ExposeField public final EventLib tickEnd;
-        @ExposeField public final EventLib playerLeave = new EventLib();
+
-        @ExposeField public final EventLib playerChangeWorld = new EventLib();
+        @ExposeField public final EventLib playerJoin;
-        @ExposeField public final EventLib entityDamage = new EventLib();
+        @ExposeField public final EventLib playerLeave;
-        @ExposeField public final EventLib inventoryScreenClicked = new EventLib();
+        @ExposeField public final EventLib playerChangeWorld;
-        @ExposeField public final EventLib inventoryScreenClosed = new EventLib();
+
+        @ExposeField public final EventLib entityDamage;
+        @ExposeField public final EventLib entityUse;
+
+        @ExposeField public final EventLib itemUse;
+
+        @ExposeField public final EventLib inventoryScreenClicked;
+        @ExposeField public final EventLib inventoryScreenClosed;
+
+        public EventCtx(Thread thread) {
+            blockPlace = new EventLib(thread);
+            blockBreak = new EventLib(thread);
+            tickStart = new EventLib(thread);
+            tickEnd = new EventLib(thread);
+            playerJoin = new EventLib(thread);
+            playerLeave = new EventLib(thread);
+            playerChangeWorld = new EventLib(thread);
+            entityDamage = new EventLib(thread);
+            entityUse = new EventLib(thread);
+            itemUse = new EventLib(thread);
+            inventoryScreenClicked = new EventLib(thread);
+            inventoryScreenClosed = new EventLib(thread);
+        }
     }
 
     private static final WeakHashMap<MinecraftServer, EventCtx> ctxs = new WeakHashMap<>();
 
     public static EventCtx events(MinecraftServer server) {
-        ctxs.putIfAbsent(server, new EventCtx());
+        ctxs.putIfAbsent(server, new EventCtx(server.getThread()));
         return ctxs.get(server);
     }
     public static MessageQueue queue(MinecraftServer server) {
@@ -124,6 +153,15 @@ public class ServerLib {
     public static EventLib __entityDamage(Arguments args) {
         return events(args.self(MinecraftServer.class)).entityDamage;
     }
+    @Expose(type = ExposeType.GETTER)
+    public static EventLib __entityUse(Arguments args) {
+        return events(args.self(MinecraftServer.class)).entityUse;
+    }
+
+    @Expose(type = ExposeType.GETTER)
+    public static EventLib __itemUse(Arguments args) {
+        return events(args.self(MinecraftServer.class)).itemUse;
+    }
 
     @Expose(type = ExposeType.GETTER)
     public static EventLib __inventoryScreenClicked(Arguments args) {
@@ -208,6 +246,18 @@ public class ServerLib {
         server.sendMessage(Text.of(text));
     }
 
+    @Expose public static Entity __getByUUID(Arguments args) {
+        var server = args.self(MinecraftServer.class);
+        var uuid = args.getString(0);
+
+        for (var world : server.getWorlds()) {
+            var entity = world.getEntity(UUID.fromString(uuid));
+            if (entity != null) return entity;
+        }
+
+        return null;
+    }
+
     @Expose public static ObjectValue __cmd(Arguments args) {
         var server = args.self(MinecraftServer.class);
         var cmd = args.getString(0);
@@ -305,15 +355,20 @@ public class ServerLib {
                 handler, player, slotIndex < 0 ? null : slotIndex, rawButton, actType
             );
         });
-        // .ALLOW_DAMAGE.register((entity, damageSource, damageAmount) -> {
+        UseEntityCallback.EVENT.register((player, world, hand, entity, hitResult) -> {
-        //     var dmgSrc = new ObjectValue();
+            if (!events(player.getServer()).entityUse.invokeCancellable(
+                player, entity
+            )) return ActionResult.FAIL;
 
-        //     dmgSrc.defineProperty(null, "damager", damageSource.getAttacker());
+            else return ActionResult.PASS;
-        //     dmgSrc.defineProperty(null, "location", LocationLib.of(damageSource.getPosition()));
+        });
-        //     dmgSrc.defineProperty(null, "type", damageSource.getType().msgId());
+        UseItemCallback.EVENT.register((player, world, hand) -> {
-
+            if (!events(player.getServer()).itemUse.invokeCancellable(
-        //     return events(entity.getServer()).entityDamage.invokeCancellable(entity, damageAmount, dmgSrc);
+                Data.toJS(null, Data.toNBT(player.getStackInHand(hand))),
-        // });
+                player, hand == Hand.MAIN_HAND ? "main" : "off"
+            )) return TypedActionResult.fail(player.getStackInHand(hand));
+            else return TypedActionResult.pass(player.getStackInHand(hand));
+        });
     }
 
     @Expose(target = ExposeTarget.STATIC)

src/java/me/topchetoeu/mcscript/lib/server/inventory/InventoryScreenLib.java

@@ -3,9 +3,12 @@ package me.topchetoeu.mcscript.lib.server.inventory;
 import java.util.HashSet;
 
 import me.topchetoeu.jscript.runtime.values.ArrayValue;
+import me.topchetoeu.jscript.runtime.values.NativeFunction;
+import me.topchetoeu.jscript.runtime.values.ObjectValue;
 import me.topchetoeu.jscript.utils.interop.Arguments;
 import me.topchetoeu.jscript.utils.interop.Expose;
 import me.topchetoeu.jscript.utils.interop.WrapperName;
+import me.topchetoeu.mcscript.core.Data;
 import net.minecraft.inventory.Inventory;
 import net.minecraft.screen.ScreenHandler;
 
@@ -26,6 +29,33 @@ public class InventoryScreenLib {
             if (tmp.add(inv)) res.set(args, res.size(), inv);
         }
 
+        return res;
+    }
+    @Expose public static ObjectValue __cursorItem(Arguments args) {
+        return Data.toJS(args, Data.toNBT(args.self(ScreenHandler.class).getCursorStack()));
+    }
+    @Expose public static ObjectValue __getSlot(Arguments args) {
+        var self = args.self(ScreenHandler.class);
+        var i = args.getInt(0);
+
+        var slot = self.getSlot(i);
+
+        var res = new ObjectValue();
+        res.defineProperty(args, "i", slot.getIndex());
+        res.defineProperty(args, "x", slot.x);
+        res.defineProperty(args, "y", slot.y);
+        res.defineProperty(args, "inventory", slot.inventory);
+        res.defineProperty(args, "item",
+            new NativeFunction(_args -> {
+                return Data.toJS(args, Data.toNBT(slot.getStack()));
+            }),
+            new NativeFunction(_args -> {
+                var item = Data.toItemStack(Data.toCompound(_args, 0));
+                slot.setStack(item);
+                return null;
+            }),
+        true, true);
+
         return res;
     }
 }

src/java/me/topchetoeu/mcscript/lib/utils/EventLib.java

@@ -24,6 +24,7 @@ import me.topchetoeu.mcscript.MessageQueue;
 public class EventLib {
     private HashMap<FunctionValue, Extensions> handles = new HashMap<>();
     private HashMap<FunctionValue, Extensions> onceHandles = new HashMap<>();
+    private Thread thread;
 
     public void invoke(Object ...args) {
         List<Map.Entry<FunctionValue, Extensions>> arr;
@@ -40,7 +41,8 @@ public class EventLib {
             var func = handle.getKey();
 
             try {
-                MessageQueue.get().await(EventLoop.get(env).pushMsg(false, env, func, null, args));
+                var awaitable = EventLoop.get(env).pushMsg(false, env, func, null, args);
+                if (thread != null) MessageQueue.get(thread).await(awaitable);
             }
             catch (EngineException e) { Values.printError(e, "in event handler"); }
         }
@@ -77,4 +79,8 @@ public class EventLib {
 
         return promise;
     }
+
+    public EventLib(Thread thread) {
+        this.thread = thread;
+    }
 }

src/test-mod/libs/lib.d.ts

@@ -0,0 +1,632 @@
+type PropertyDescriptor<T, ThisT> = {
+    value: any;
+    writable?: boolean;
+    enumerable?: boolean;
+    configurable?: boolean;
+} | {
+    get?(this: ThisT): T;
+    set(this: ThisT, val: T): void;
+    enumerable?: boolean;
+    configurable?: boolean;
+} | {
+    get(this: ThisT): T;
+    set?(this: ThisT, val: T): void;
+    enumerable?: boolean;
+    configurable?: boolean;
+};
+type Exclude<T, U> = T extends U ? never : T;
+type Extract<T, U> = T extends U ? T : never;
+type Record<KeyT extends string | number | symbol, ValT> = { [x in KeyT]: ValT }
+type ReplaceFunc = (match: string, ...args: any[]) => string;
+
+type PromiseResult<T> = { type: 'fulfilled'; value: T; } | { type: 'rejected'; reason: any; }
+
+// wippidy-wine, this code is now mine :D
+type Awaited<T> =
+    T extends null | undefined ? T : // special case for `null | undefined` when not in `--strictNullChecks` mode
+        T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ? // `await` only unwraps object types with a callable `then`. Non-object types are not unwrapped
+            F extends ((value: infer V, ...args: infer _) => any) ? // if the argument to `then` is callable, extracts the first argument
+                Awaited<V> : // recursively unwrap the value
+                never : // the argument to `then` was not callable
+        T;
+
+type IteratorYieldResult<TReturn> =
+    { done?: false; } &
+    (TReturn extends undefined ? { value?: undefined; } : { value: TReturn; });
+
+type IteratorReturnResult<TReturn> =
+    { done: true } &
+    (TReturn extends undefined ? { value?: undefined; } : { value: TReturn; });
+
+type IteratorResult<T, TReturn = any> = IteratorYieldResult<T> | IteratorReturnResult<TReturn>;
+
+interface Thenable<T> {
+    then<NextT = void>(onFulfilled?: (val: T) => NextT, onRejected?: (err: any) => NextT): Promise<Awaited<NextT>>;
+}
+
+interface RegExpResultIndices extends Array<[number, number]> {
+    groups?: { [name: string]: [number, number]; };
+}
+interface RegExpResult extends Array<string> {
+    groups?: { [name: string]: string; };
+    index: number;
+    input: string;
+    indices?: RegExpResultIndices;
+    escape(raw: string, flags: string): RegExp;
+}
+
+interface Matcher {
+    [Symbol.match](target: string): RegExpResult | string[] | null;
+    [Symbol.matchAll](target: string): IterableIterator<RegExpResult>;
+}
+interface Splitter {
+    [Symbol.split](target: string, limit?: number, sensible?: boolean): string[];
+}
+interface Replacer {
+    [Symbol.replace](target: string, replacement: string | ReplaceFunc): string;
+}
+interface Searcher {
+    [Symbol.search](target: string, reverse?: boolean, start?: number): number;
+}
+
+type FlatArray<Arr, Depth extends number> = {
+    "done": Arr,
+    "recur": Arr extends Array<infer InnerArr>
+        ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
+        : Arr
+}[Depth extends -1 ? "done" : "recur"];
+
+interface IArguments {
+    [i: number]: any;
+    length: number;
+}
+
+interface Iterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): IteratorResult<T, TReturn>;
+    return?(value?: TReturn): IteratorResult<T, TReturn>;
+    throw?(e?: any): IteratorResult<T, TReturn>;
+}
+interface Iterable<T> {
+    [Symbol.iterator](): Iterator<T>;
+}
+interface IterableIterator<T> extends Iterator<T> {
+    [Symbol.iterator](): IterableIterator<T>;
+}
+
+interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+    next(...args: [] | [TNext]): Promise<IteratorResult<T, TReturn>>;
+    return?(value?: TReturn | Thenable<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw?(e?: any): Promise<IteratorResult<T, TReturn>>;
+}
+interface AsyncIterable<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+interface AsyncIterableIterator<T> extends AsyncIterator<T> {
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+interface Generator<T = unknown, TReturn = void, TNext = unknown> extends Iterator<T, TReturn, TNext> {
+    [Symbol.iterator](): Generator<T, TReturn, TNext>;
+    return(value: TReturn): IteratorResult<T, TReturn>;
+    throw(e: any): IteratorResult<T, TReturn>;
+}
+interface GeneratorFunction {
+    new (...args: any[]): Generator;
+    (...args: any[]): Generator;
+    readonly length: number;
+    readonly name: string;
+    readonly prototype: Generator;
+}
+
+interface AsyncGenerator<T = unknown, TReturn = void, TNext = unknown> extends AsyncIterator<T, TReturn, TNext> {
+    return(value: TReturn | Thenable<TReturn>): Promise<IteratorResult<T, TReturn>>;
+    throw(e: any): Promise<IteratorResult<T, TReturn>>;
+    [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+interface AsyncGeneratorFunction {
+    new (...args: any[]): AsyncGenerator;
+    (...args: any[]): AsyncGenerator;
+    readonly length: number;
+    readonly name: string;
+    readonly prototype: AsyncGenerator;
+}
+
+
+interface MathObject {
+    readonly E: number;
+    readonly PI: number;
+    readonly SQRT2: number;
+    readonly SQRT1_2: number;
+    readonly LN2: number;
+    readonly LN10: number;
+    readonly LOG2E: number;
+    readonly LOG10E: number;
+
+    asin(x: number): number;
+    acos(x: number): number;
+    atan(x: number): number;
+    atan2(y: number, x: number): number;
+    asinh(x: number): number;
+    acosh(x: number): number;
+    atanh(x: number): number;
+    sin(x: number): number;
+    cos(x: number): number;
+    tan(x: number): number;
+    sinh(x: number): number;
+    cosh(x: number): number;
+    tanh(x: number): number;
+    sqrt(x: number): number;
+    cbrt(x: number): number;
+    hypot(...vals: number[]): number;
+    imul(a: number, b: number): number;
+    exp(x: number): number;
+    expm1(x: number): number;
+    pow(x: number, y: number): number;
+    log(x: number): number;
+    log10(x: number): number;
+    log1p(x: number): number;
+    log2(x: number): number;
+    ceil(x: number): number;
+    floor(x: number): number;
+    round(x: number): number;
+    fround(x: number): number;
+    trunc(x: number): number;
+    abs(x: number): number;
+    max(...vals: number[]): number;
+    min(...vals: number[]): number;
+    sign(x: number): number;
+    random(): number;
+    clz32(x: number): number;
+}
+interface JSONObject {
+    stringify(val: unknown): string;
+    parse(val: string): unknown;
+}
+
+interface Array<T> extends IterableIterator<T> {
+    [i: number]: T;
+
+    length: number;
+
+    toString(): string;
+    // toLocaleString(): string;
+    join(separator?: string): string;
+    fill(val: T, start?: number, end?: number): T[];
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    concat(...items: (T | T[])[]): T[];
+    concat(...items: (T | T[])[]): T[];
+    join(separator?: string): string;
+    reverse(): T[];
+    shift(): T | undefined;
+    slice(start?: number, end?: number): T[];
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number | undefined, ...items: T[]): T[];
+    unshift(...items: T[]): number;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+    includes(el: any, start?: number): boolean;
+
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+    find(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T | undefined;
+    findIndex(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): number;
+    findLast(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): T[];
+    findLastIndex(predicate: (value: T, index: number, array: T[]) => boolean, thisArg?: any): number;
+
+    flat<D extends number = 1>(depth?: D): FlatArray<T, D>[];
+    flatMap(func: (val: T, i: number, arr: T[]) => T | T[], thisAarg?: any): FlatArray<T[], 1>;
+    sort(func?: (a: T, b: T) => number): this;
+
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
+    reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
+
+    entries(): IterableIterator<[number, T]>;
+    values(): IterableIterator<T>;
+    keys(): IterableIterator<number>;
+}
+interface ArrayConstructor {
+    new <T>(arrayLength?: number): T[];
+    new <T>(...items: T[]): T[];
+    <T>(arrayLength?: number): T[];
+    <T>(...items: T[]): T[];
+    isArray(arg: unknown): arg is unknown[];
+    prototype: Array<any>;
+}
+
+interface Boolean {
+    toString(): string;
+    valueOf(): boolean;
+}
+interface BooleanConstructor {
+    (val: any): boolean;
+    new (val: any): Boolean;
+    prototype: Boolean;
+}
+
+interface Error {
+    name: string;
+    message: string;
+    stack: string[];
+    toString(): string;
+}
+interface ErrorConstructor {
+    (msg?: any): Error;
+    new (msg?: any): Error;
+    prototype: Error;
+}
+
+interface TypeErrorConstructor extends ErrorConstructor {
+    (msg?: any): TypeError;
+    new (msg?: any): TypeError;
+    prototype: Error;
+}
+interface TypeError extends Error {
+    name: 'TypeError';
+}
+
+interface RangeErrorConstructor extends ErrorConstructor {
+    (msg?: any): RangeError;
+    new (msg?: any): RangeError;
+    prototype: Error;
+}
+interface RangeError extends Error {
+    name: 'RangeError';
+}
+
+interface SyntaxErrorConstructor extends ErrorConstructor {
+    (msg?: any): RangeError;
+    new (msg?: any): RangeError;
+    prototype: Error;
+}
+interface SyntaxError extends Error {
+    name: 'SyntaxError';
+}
+
+interface Function {
+    apply(this: Function, thisArg: any, argArray?: any): any;
+    call(this: Function, thisArg: any, ...argArray: any[]): any;
+    bind(this: Function, thisArg: any, ...argArray: any[]): Function;
+
+    toString(): string;
+
+    prototype: any;
+    readonly length: number;
+    name: string;
+}
+interface CallableFunction extends Function {
+    (...args: any[]): any;
+    apply<ThisArg, Args extends any[], RetT>(this: (this: ThisArg, ...args: Args) => RetT, thisArg: ThisArg, argArray?: Args): RetT;
+    call<ThisArg, Args extends any[], RetT>(this: (this: ThisArg, ...args: Args) => RetT, thisArg: ThisArg, ...argArray: Args): RetT;
+    bind<ThisArg, Args extends any[], Rest extends any[], RetT>(this: (this: ThisArg, ...args: [ ...Args, ...Rest ]) => RetT, thisArg: ThisArg, ...argArray: Args): (this: void, ...args: Rest) => RetT;
+}
+interface NewableFunction extends Function {
+    new(...args: any[]): any;
+    apply<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, argArray?: Args): RetT;
+    call<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, ...argArray: Args): RetT;
+    bind<Args extends any[], RetT>(this: new (...args: Args) => RetT, thisArg: any, ...argArray: Args): new (...args: Args) => RetT;
+}
+interface FunctionConstructor extends Function {
+    (...args: string[]): (...args: any[]) => any;
+    new (...args: string[]): (...args: any[]) => any;
+    prototype: Function;
+    async<ArgsT extends any[], RetT>(
+        func: (await: <T>(val: T) => Awaited<T>) => (...args: ArgsT) => RetT
+    ): (...args: ArgsT) => Promise<RetT>;
+    asyncGenerator<ArgsT extends any[], RetT>(
+        func: (await: <T>(val: T) => Awaited<T>, _yield: <T>(val: T) => void) => (...args: ArgsT) => RetT
+    ): (...args: ArgsT) => AsyncGenerator<RetT>;
+    generator<ArgsT extends any[], T = unknown, RetT = unknown, TNext = unknown>(
+        func: (_yield: <T>(val: T) => TNext) => (...args: ArgsT) => RetT
+    ): (...args: ArgsT) => Generator<T, RetT, TNext>;
+}
+
+interface Number {
+    toString(): string;
+    toFixed(i: number): string;
+    valueOf(): number;
+}
+interface NumberConstructor {
+    (val: unknown): number;
+    new (val: unknown): Number;
+    prototype: Number;
+    parseInt(val: unknown): number;
+    parseFloat(val: unknown): number;
+}
+
+interface Object {
+    constructor: NewableFunction;
+    [Symbol.typeName]: string;
+
+    valueOf(): this;
+    toString(): string;
+    hasOwnProperty(key: any): boolean;
+}
+interface ObjectConstructor {
+    (arg: string): String;
+    (arg: number): Number;
+    (arg: boolean): Boolean;
+    (arg?: undefined | null): {};
+    <T extends object>(arg: T): T;
+
+    new (arg: string): String;
+    new (arg: number): Number;
+    new (arg: boolean): Boolean;
+    new (arg?: undefined | null): {};
+    new <T extends object>(arg: T): T;
+
+    prototype: Object;
+
+    assign<T extends object>(target: T, ...src: object[]): T;
+    create<T extends object>(proto: T, props?: { [key: string]: PropertyDescriptor<any, T> }): T;
+
+    keys<T extends object>(obj: T, onlyString?: true): (keyof T)[];
+    keys<T extends object>(obj: T, onlyString: false): any[];
+    entries<T extends object>(obj: T, onlyString?: true): [keyof T, T[keyof T]][];
+    entries<T extends object>(obj: T, onlyString: false): [any, any][];
+    values<T extends object>(obj: T, onlyString?: true): (T[keyof T])[];
+    values<T extends object>(obj: T, onlyString: false): any[];
+
+    fromEntries(entries: Iterable<[any, any]>): object;
+
+    defineProperty<T, ThisT extends object>(obj: ThisT, key: any, desc: PropertyDescriptor<T, ThisT>): ThisT;
+    defineProperties<ThisT extends object>(obj: ThisT, desc: { [key: string]: PropertyDescriptor<any, ThisT> }): ThisT;
+
+    getOwnPropertyNames<T extends object>(obj: T): (keyof T)[];
+    getOwnPropertySymbols<T extends object>(obj: T): (keyof T)[];
+    hasOwn<T extends object, KeyT>(obj: T, key: KeyT): boolean;
+
+    getOwnPropertyDescriptor<T extends object, KeyT extends keyof T>(obj: T, key: KeyT): PropertyDescriptor<T[KeyT], T>;
+    getOwnPropertyDescriptors<T extends object>(obj: T): { [x in keyof T]: PropertyDescriptor<T[x], T> };
+
+    getPrototypeOf(obj: any): object | null;
+    setPrototypeOf<T>(obj: T, proto: object | null): T;
+
+    preventExtensions<T extends object>(obj: T): T;
+    seal<T extends object>(obj: T): T;
+    freeze<T extends object>(obj: T): T;
+
+    isExtensible(obj: object): boolean;
+    isSealed(obj: object): boolean;
+    isFrozen(obj: object): boolean;
+}
+
+interface String {
+    [i: number]: string;
+
+    toString(): string;
+    valueOf(): string;
+
+    charAt(pos: number): string;
+    charCodeAt(pos: number): number;
+    substring(start?: number, end?: number): string;
+    slice(start?: number, end?: number): string;
+    substr(start?: number, length?: number): string;
+
+    startsWith(str: string, pos?: number): string;
+    endsWith(str: string, pos?: number): string;
+
+    replace(pattern: string | Replacer, val: string | ReplaceFunc): string;
+    replaceAll(pattern: string | Replacer, val: string | ReplaceFunc): string;
+
+    match(pattern: string | Matcher): RegExpResult | string[] | null;
+    matchAll(pattern: string | Matcher): IterableIterator<RegExpResult>;
+
+    split(pattern: string | Splitter, limit?: number, sensible?: boolean): string[];
+
+    concat(...others: string[]): string;
+    indexOf(term: string | Searcher, start?: number): number;
+    lastIndexOf(term: string | Searcher, start?: number): number;
+
+    toLowerCase(): string;
+    toUpperCase(): string;
+
+    trim(): string;
+
+    includes(term: string, start?: number): boolean;
+
+    length: number;
+}
+interface StringConstructor {
+    (val: any): string;
+    new (val: any): String;
+
+    fromCharCode(val: number): string;
+
+    prototype: String;
+}
+
+interface Symbol {
+    valueOf(): symbol;
+}
+interface SymbolConstructor {
+    (val?: any): symbol;
+    new(...args: any[]): never;
+    prototype: Symbol;
+    for(key: string): symbol;
+    keyFor(sym: symbol): string;
+
+    readonly typeName: unique symbol;
+    readonly match: unique symbol;
+    readonly matchAll: unique symbol;
+    readonly split: unique symbol;
+    readonly replace: unique symbol;
+    readonly search: unique symbol;
+    readonly iterator: unique symbol;
+    readonly asyncIterator: unique symbol;
+}
+
+
+interface Promise<T> extends Thenable<T> {
+    catch<ResT = void>(func: (err: unknown) => ResT): Promise<ResT>;
+    finally(func: () => void): Promise<T>;
+    constructor: PromiseConstructor;
+}
+interface PromiseConstructorLike {
+    new <T>(func: (res: (val: T) => void, rej: (err: unknown) => void) => void): Thenable<Awaited<T>>;
+}
+interface PromiseConstructor extends PromiseConstructorLike {
+    prototype: Promise<any>;
+
+    new <T>(func: (res: (val: T) => void, rej: (err: unknown) => void) => void): Promise<Awaited<T>>;
+    resolve<T>(val: T): Promise<Awaited<T>>;
+    reject(val: any): Promise<never>;
+
+    isAwaitable(val: unknown): val is Thenable<any>;
+    any<T>(promises: T[]): Promise<Awaited<T>>;
+    race<T>(promises: (Promise<T>|T)[]): Promise<T>;
+    all<T extends any[]>(promises: T): Promise<{ [Key in keyof T]: Awaited<T[Key]> }>;
+    allSettled<T extends any[]>(...promises: T): Promise<[...{ [P in keyof T]: PromiseResult<Awaited<T[P]>>}]>;
+}
+
+interface FileStat {
+    type: 'file' | 'folder' | 'none';
+    mode: '' | 'r' | 'rw';
+}
+interface File {
+    pointer(): Promise<number>;
+    length(): Promise<number>;
+
+    read(n: number): Promise<number[]>;
+    write(buff: number[]): Promise<void>;
+    close(): Promise<void>;
+    seek(offset: number, whence: number): Promise<void>;
+}
+interface Filesystem {
+    readonly SEEK_SET: 0;
+    readonly SEEK_CUR: 1;
+    readonly SEEK_END: 2;
+
+    open(path: string, mode: 'r' | 'w' | 'rw'): Promise<File>;
+    ls(path: string): AsyncIterableIterator<string>;
+    mkdir(path: string): Promise<void>;
+    mkfile(path: string): Promise<void>;
+    rm(path: string, recursive?: boolean): Promise<void>;
+    stat(path: string): Promise<FileStat>;
+    exists(path: string): Promise<boolean>;
+    normalize(...paths: string[]): string;
+}
+
+interface Encoding {
+    encode(val: string): number[];
+    decode(val: number[]): string;
+}
+
+declare var String: StringConstructor;
+//@ts-ignore
+declare const arguments: IArguments;
+declare var NaN: number;
+declare var Infinity: number;
+
+declare var setTimeout: <T extends any[]>(handle: (...args: [ ...T, ...any[] ]) => void, delay?: number, ...args: T) => number;
+declare var setInterval: <T extends any[]>(handle: (...args: [ ...T, ...any[] ]) => void, delay?: number, ...args: T) => number;
+
+declare var clearTimeout: (id: number) => void;
+declare var clearInterval: (id: number) => void;
+
+declare var parseInt: typeof Number.parseInt;
+declare var parseFloat: typeof Number.parseFloat;
+
+declare function require(name: string): any;
+
+declare var Array: ArrayConstructor;
+declare var Boolean: BooleanConstructor;
+declare var Promise: PromiseConstructor;
+declare var Function: FunctionConstructor;
+declare var Number: NumberConstructor;
+declare var Object: ObjectConstructor;
+declare var Symbol: SymbolConstructor;
+declare var Promise: PromiseConstructor;
+declare var Math: MathObject;
+declare var JSON: JSONObject;
+declare var Encoding: Encoding;
+declare var Filesystem: Filesystem;
+
+declare var Error: ErrorConstructor;
+declare var RangeError: RangeErrorConstructor;
+declare var TypeError: TypeErrorConstructor;
+declare var SyntaxError: SyntaxErrorConstructor;
+declare var self: typeof globalThis;
+
+declare var stdin: File;
+declare var stdout: File;
+declare var stderr: File;
+
+declare class Map<KeyT, ValueT> {
+    public [Symbol.iterator](): IterableIterator<[KeyT, ValueT]>;
+
+    public clear(): void;
+    public delete(key: KeyT): boolean;
+
+    public entries(): IterableIterator<[KeyT, ValueT]>;
+    public keys(): IterableIterator<KeyT>;
+    public values(): IterableIterator<ValueT>;
+
+    public get(key: KeyT): ValueT;
+    public set(key: KeyT, val: ValueT): this;
+    public has(key: KeyT): boolean;
+
+    public get size(): number;
+
+    public forEach(func: (val: ValueT, key: KeyT, map: Map<KeyT, ValueT>) => void, thisArg?: any): void;
+
+    public constructor();
+}
+declare class Set<T> {
+    public [Symbol.iterator](): IterableIterator<T>;
+
+    public entries(): IterableIterator<[T, T]>;
+    public keys(): IterableIterator<T>;
+    public values(): IterableIterator<T>;
+
+    public clear(): void;
+
+    public add(val: T): this;
+    public delete(val: T): boolean;
+    public has(key: T): boolean;
+
+    public get size(): number;
+
+    public forEach(func: (key: T, value: T, set: Set<T>) => void, thisArg?: any): void;
+
+    public constructor();
+}
+
+declare class RegExp implements Matcher, Splitter, Replacer, Searcher {
+    static escape(raw: any, flags?: string): RegExp;
+
+    prototype: RegExp;
+
+    exec(val: string): RegExpResult | null;
+    test(val: string): boolean;
+    toString(): string;
+
+    [Symbol.match](target: string): RegExpResult | string[] | null;
+    [Symbol.matchAll](target: string): IterableIterator<RegExpResult>;
+    [Symbol.split](target: string, limit?: number, sensible?: boolean): string[];
+    [Symbol.replace](target: string, replacement: string | ReplaceFunc): string;
+    [Symbol.search](target: string, reverse?: boolean, start?: number): number;
+
+    readonly dotAll: boolean;
+    readonly global: boolean;
+    readonly hasIndices: boolean;
+    readonly ignoreCase: boolean;
+    readonly multiline: boolean;
+    readonly sticky: boolean;
+    readonly unicode: boolean;
+
+    readonly source: string;
+    readonly flags: string;
+
+    lastIndex: number;
+
+    constructor(pattern?: string, flags?: string);
+    constructor(pattern?: RegExp, flags?: string);
+}

src/test-mod/libs/mc.d.ts

@@ -0,0 +1,174 @@
+declare interface Event<T extends (...args: any[]) => void> {
+    on(handle: T): () => void;
+}
+declare type CancelEvent<T extends (...args: any[]) => void> = Event<T extends (...args: infer ArgT) => any ? (cancel: () => void, ...args: ArgT) => void : T>;
+declare interface CommandHandle {
+    execute(args: string, sender: Entity | undefined, sendInfo: (text: any) => void, sendError: (text: any) => void): void;
+}
+declare interface TitleConfig {
+    title?: string;
+    subtitle?: string;
+    fadeIn?: number;
+    fadeOut?: number;
+    duration?: number;
+}
+
+declare type NbtTypeFromKey<T extends string> =
+    T extends `${string}$${'l'|'i'|'s'|'f'|'d'}` ? (number | number[]) :
+    T extends `${string}$${'b'}` ? (number | boolean | number[]) :
+    (NbtElement | NbtElement[]);
+
+declare type NbtElement = NbtCompound | number | string | boolean;
+
+declare interface NbtCompound {
+    [key: string]: NbtElement | NbtElement[];
+}
+
+
+declare interface DamageSource {
+    damager?: Entity;
+    location?: Location;
+    type: string;
+}
+
+declare interface ItemStack extends Item {
+    count: number;
+}
+
+declare interface Item extends NbtCompound {
+    id: string;
+}
+
+declare class Location {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+
+    add(...locations: [...([Location] | [number, number, number])]): Location;
+    subtract(...locations: [...([Location] | [number, number, number])]): Location;
+
+    dot(location: Location): Location;
+    distance(loc: Location): number;
+
+    dot(x: number, y: number, z: number): number;
+    distance(x: number, y: number, z: number): number;
+    length(): number;
+
+    setX(x: number): Location;
+    setY(y: number): Location;
+    setZ(z: number): Location;
+
+    toString(): `[${number} ${number} ${number}]`;
+
+    constructor(x: number, y: number, z: number);
+    constructor(val: Location);
+}
+
+declare interface BlockState {
+    id: string;
+    [prop: string]: string | number | boolean;
+}
+
+declare class ServerWorld {
+    setBlock(loc: Location, state: BlockState, update?: boolean): void;
+    getBlock(loc: Location): BlockState;
+    summon(loc: Location, nbt: NbtCompound & { id: string; }): Entity;
+}
+
+declare class Server {
+    registerCommand(name: string, handle: CommandHandle): void;
+    cmd(command: string, opts?: { at?: Location, pitch?: number, yaw?: number, as?: Entity, world?: ServerWorld }): { output: string[], code: number };
+    sendMessage(text: string): void;
+
+    getByUUID(uuid: string): Entity;
+
+    readonly tickStart: Event<() => void>;
+    readonly tickEnd: Event<() => void>;
+
+    readonly blockBreak: CancelEvent<(loc: Location, player: ServerPlayer) => void>;
+    readonly blockPlace: CancelEvent<(loc: Location, player: ServerPlayer) => void>;
+
+    readonly playerJoin: Event<(player: ServerPlayer) => void>;
+    readonly playerLeave: Event<(player: ServerPlayer) => void>;
+
+    readonly entityDamage: CancelEvent<(entity: Entity, damage: number, source: DamageSource) => void>;
+    readonly entityUse: CancelEvent<(player: ServerPlayer, entity: Entity) => void>;
+
+    readonly itemUse: CancelEvent<(item: ItemStack, player: ServerPlayer, hand: 'main' | 'off') => void>;
+
+    readonly inventoryScreenClicked: CancelEvent<(screen: InventoryScreen, player: ServerPlayer, index: number, button: number, action: ActionType) => void>;
+    readonly inventoryScreenClosed: CancelEvent<(screen: InventoryScreen, player: ServerPlayer) => void>;
+
+    readonly players: ServerPlayer[];
+    readonly worlds: ServerWorld[];
+
+    static maxStack(id: string): number;
+}
+
+declare class Entity {
+    location: Location;
+    name: string;
+    readonly uuid: string;
+    readonly world: ServerWorld;
+
+    discard(): void;
+}
+declare class LivingEntity extends Entity {
+    health: number;
+    readonly maxHealth: number;
+}
+
+declare type Gamemode = 'survival' | 'creative' | 'adventure' | 'spectator';
+declare type InvType = '3x3' | '9x1' | '9x2' | '9x3' | '9x4' | '9x5' | '9x6';
+declare type ActionType = 'clone' | 'pickup' | 'pickupAll' | 'quickCraft' | 'quickMove' | 'swap' | 'throw';
+
+declare class Player extends LivingEntity {
+    sendMessage(text: any): void;
+}
+
+declare class ServerPlayer extends Player {
+    readonly inventory: Inventory;
+    readonly screen: InventoryScreen | undefined;
+
+    gamemode: Gamemode;
+    foodLevel: number;
+    saturation: number;
+    sendTitle(title: TitleConfig): void;
+
+    openInventory(name: string, type: InvType, inv: Inventory): InventoryScreen;
+    closeInventory(): void;
+}
+
+declare class Inventory implements Iterable<ItemStack> {
+    readonly size: number;
+
+    get(i: number): ItemStack;
+    set(i: number, item?: ItemStack): void;
+    clear(): void;
+
+    clone(): Inventory;
+    copyFrom(inv: Inventory): void;
+
+    [Symbol.iterator](): Iterator<ItemStack>;
+
+    constructor(n: number);
+}
+
+declare interface Slot {
+    readonly i: number;
+    readonly x: number;
+    readonly y: number;
+    readonly inventory: Inventory;
+
+    get item(): ItemStack;
+    set item(val: ItemStack);
+}
+
+declare class InventoryScreen {
+    readonly inventories: Inventory[];
+    readonly id: number;
+    readonly cursorStack: ItemStack | undefined;
+    getSlot(i: number): Slot;
+}
+
+declare var serverLoad: Event<(server: Server) => void>;

src/test-mod/manifest.json

@@ -0,0 +1,6 @@
+{
+    "name": "test",
+    "author": "TopchetoEU",
+    "version": "1.0.0",
+    "main": "dst/main.js"
+}

src/test-mod/tsconfig.json

@@ -0,0 +1,10 @@
+{
+    "include": [ "./**.ts", "src/main.ts", "libs/mc.d.ts", "libs/lib.d.ts" ],
+    "compilerOptions": {
+        "downlevelIteration": true,
+        "strict": true,
+        "lib": [ ],
+        "outDir": "dst",
+        "target": "ES5"
+    }
+}