asajs 4.0.0-indev-2 → 4.0.0-indev-3

package/config.d.ts

@@ -0,0 +1,26 @@
+import { Variable } from "./src/types/properties/value.ts"
+
+export interface Config {
+	compiler?: {
+		enabled?: boolean
+		linked?: boolean
+	}
+	packinfo?: {
+		name?: string
+		description?: string
+		version?: [number, number, number]
+
+		metadata?: {
+			authors?: string[]
+			license?: string
+			url?: string
+		}
+
+		subpacks?: {
+			folder_name?: string
+			name?: string
+			memory_performance_tier?: number
+		}[]
+	}
+	global_variables?: Record<Variable, string>
+}

package/dist/js/compilers/Configuration.js

@@ -1 +1,20 @@
-export const isBuildMode = process.argv.includes("--build");
+import fs from "fs";
+import path from "path";
+if (!fs.existsSync("asajs.config.cjs")) {
+    fs.copyFileSync("node_modules/asajs/resources/asajs.config.cjs", "asajs.config.cjs");
+}
+if (!fs.existsSync(".gitignore")) {
+    fs.writeFileSync(".gitignore", `node_modules`, "utf-8");
+}
+export const config = require(path.resolve(process.cwd(), "asajs.config.cjs")).config;
+export let isBuildMode = config.compiler?.enabled ?? false;
+export let isLinkMode = config.compiler?.linked ?? false;
+export let unLinked = !(config.compiler?.linked ?? true);
+for (const arg of process.argv) {
+    if (arg === "--build")
+        isBuildMode = true;
+    if (arg === "--link")
+        isLinkMode = true;
+    else if (arg === "--unlink")
+        unLinked = true;
+}

package/dist/js/compilers/bindings/Checker.js

@@ -7,6 +7,15 @@ export function isWordChar(char) {
 export function isNumberChar(char) {
     return /\d/.test(char);
 }
+export function isHexChar(char) {
+    return /[0-9a-fA-F]/.test(char);
+}
+export function isBinaryChar(char) {
+    return /[01]/.test(char);
+}
+export function isOctalChar(char) {
+    return /[0-7]/.test(char);
+}
 export function isCompileBinding(input) {
     return input.startsWith("[") && input.endsWith("]");
 }

package/dist/js/compilers/bindings/Function.js

@@ -0,0 +1,71 @@
+import { RandomBindingString } from "../../components/Utils.js";
+import { Parser } from "./Parser.js";
+export const FunctionMap = new Map();
+function callFn(name, ...args) {
+    return FunctionMap.get(name)(...args);
+}
+// Default Functions
+FunctionMap.set("abs", number => {
+    const randomBinding = RandomBindingString(16);
+    return {
+        genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
+        value: randomBinding,
+    };
+});
+FunctionMap.set("new", expression => {
+    const randomBinding = RandomBindingString(16);
+    return {
+        genBindings: [{ source: expression, target: randomBinding }],
+        value: randomBinding,
+    };
+});
+FunctionMap.set("sqrt", number => {
+    const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
+    const { genBindings: absValue, value: absRtn } = callFn("abs", number);
+    return {
+        genBindings: [
+            {
+                source: `${number} * 100 / 2`,
+                target: $1,
+            },
+            ...absValue,
+            {
+                source: `${absRtn} > 1`,
+                target: $2,
+            },
+            {
+                source: `(${number} < 0) * -1 + (${number} > -1) * (${$2} * ((${rtn} + ${number} / ${rtn}) / 2) + (not ${$2}) * ${rtn})`,
+                target: rtn,
+            },
+        ],
+        value: rtn,
+    };
+});
+FunctionMap.set("translatable", key => {
+    return {
+        value: `'%' + ${key}`,
+    };
+});
+FunctionMap.set("bin", input => {
+    const { ret, bindings } = Parser.intToBin(input);
+    bindings.push({
+        source: `'§z' + ${Array.from({ length: 30 }, (_, i) => `${ret}${30 - i - 1}`).join(" + ")}`,
+        target: ret,
+    });
+    return { genBindings: bindings, value: ret };
+});
+FunctionMap.set("bind", (value, bait) => {
+    const ret = RandomBindingString(16);
+    if (!bait) {
+        throw new Error("Bait is required");
+    }
+    return {
+        genBindings: [{ source: `((${bait} - ${bait}) + ${value})`, target: ret }],
+        value: ret,
+    };
+});
+FunctionMap.set("int", input => {
+    return {
+        value: input,
+    };
+});

package/dist/js/compilers/bindings/Funtion.js

@@ -1,24 +1,25 @@
 import { RandomBindingString } from "../../components/Utils.js";
-export const FuntionMap = new Map();
+import { Parser } from "./Parser.js";
+export const FunctionMap = new Map();
 function callFn(name, ...args) {
-    return FuntionMap.get(name)(...args);
+    return FunctionMap.get(name)(...args);
 }
 // Default Functions
-FuntionMap.set("abs", number => {
+FunctionMap.set("abs", number => {
     const randomBinding = RandomBindingString(16);
     return {
         genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
         value: randomBinding,
     };
 });
-FuntionMap.set("new", expression => {
+FunctionMap.set("new", expression => {
     const randomBinding = RandomBindingString(16);
     return {
         genBindings: [{ source: expression, target: randomBinding }],
         value: randomBinding,
     };
 });
-FuntionMap.set("sqrt", number => {
+FunctionMap.set("sqrt", number => {
     const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
     const { genBindings: absValue, value: absRtn } = callFn("abs", number);
     return {
@@ -40,8 +41,31 @@ FuntionMap.set("sqrt", number => {
         value: rtn,
     };
 });
-FuntionMap.set("translatable", key => {
+FunctionMap.set("translatable", key => {
     return {
         value: `'%' + ${key}`,
     };
 });
+FunctionMap.set("bin", input => {
+    const { ret, bindings } = Parser.intToBin(input);
+    bindings.push({
+        source: `'§z' + ${Array.from({ length: 30 }, (_, i) => `${ret}${30 - i - 1}`).join(" + ")}`,
+        target: ret,
+    });
+    return { genBindings: bindings, value: ret };
+});
+FunctionMap.set("bind", (value, bait) => {
+    const ret = RandomBindingString(16);
+    if (!bait) {
+        throw new Error("Bait is required");
+    }
+    return {
+        genBindings: [{ source: `((${bait} - ${bait}) + ${value})`, target: ret }],
+        value: ret,
+    };
+});
+FunctionMap.set("int", input => {
+    return {
+        value: input,
+    };
+});

package/dist/js/compilers/bindings/Lexer.js

@@ -39,6 +39,7 @@ export function Lexer(input, start = 0, end) {
             case "*":
             case "/":
             case "%":
+            case "^":
                 tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                 break;
             case "(":
@@ -53,18 +54,24 @@ export function Lexer(input, start = 0, end) {
             case "=":
                 if (input[index + 1] === input[index])
                     tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
-                else {
-                    console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 7) + "^"}\nInvalid character.\x1b[0m`);
-                    throw new Error();
-                }
+                else
+                    tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                 break;
             case "!":
             case ">":
             case "<":
                 if (input[index + 1] === "=")
                     tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
-                else
-                    tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                else {
+                    if (input[index] === input[index + 1]) {
+                        if (input[index] !== "!")
+                            tokens.push(makeToken(input, TokenKind.OPERATOR, index++, 2));
+                        else
+                            tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                    }
+                    else
+                        tokens.push(makeToken(input, TokenKind.OPERATOR, index));
+                }
                 break;
             // string
             case "'": {
@@ -168,6 +175,42 @@ export function Lexer(input, start = 0, end) {
             default: {
                 let start = index;
                 if (Checker.isNumberChar(token)) {
+                    if (token === "0") {
+                        const numType = input[index + 1];
+                        if (numType === "x") {
+                            index += 2;
+                            while (Checker.isHexChar(input[index + 1]))
+                                index++;
+                            if (start + 2 === index) {
+                                console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
+                                throw new Error();
+                            }
+                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            break;
+                        }
+                        else if (numType === "b") {
+                            index += 2;
+                            while (Checker.isBinaryChar(input[index + 1]))
+                                index++;
+                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            if (start + 2 === index) {
+                                console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
+                                throw new Error();
+                            }
+                            break;
+                        }
+                        else if (numType === "o") {
+                            index += 2;
+                            while (Checker.isOctalChar(input[index + 1]))
+                                index++;
+                            tokens.push(makeToken(input, TokenKind.NUMBER, start, index - start + 1));
+                            if (start + 2 === index) {
+                                console.error(`\x1b[31merror: ${input + "\n" + " ".repeat(index + 6) + "^"}\nInvalid character.\x1b[0m`);
+                                throw new Error();
+                            }
+                            break;
+                        }
+                    }
                     while (Checker.isNumberChar(input[index + 1]))
                         index++;
                     if (input[index + 1] === "e") {

package/dist/js/compilers/bindings/Parser.js

@@ -1,21 +1,55 @@
 import { TokenKind, TSTokenKind } from "./types.js";
 import { BindingType } from "../../types/enums/BindingType.js";
-import { FuntionMap } from "./Funtion.js";
+import { FunctionMap } from "./Function.js";
 import { Lexer } from "./Lexer.js";
+import { RandomBindingString } from "../../components/Utils.js";
 export class Parser {
     input;
+    cache;
     position = 0;
-    tokens;
     genBindings = [];
     output;
-    constructor(input) {
+    tokens;
+    constructor(input, cache = new Map(), tokens) {
         this.input = input;
-        this.tokens = Lexer(this.input);
+        this.cache = cache;
+        if (tokens) {
+            this.tokens = tokens;
+            tokens = undefined;
+        }
+        else
+            this.tokens = Lexer(input);
         this.output = this.parseExpression();
         if (this.at()) {
             this.expect(TokenKind.EOF, "Unexpected token!");
         }
     }
+    static intToBin(input) {
+        const bindings = [];
+        const rtn = RandomBindingString(16);
+        for (let i = 0; i < 30; i++) {
+            bindings.push({
+                source: `(${input} / ${2 ** i} - (${input} / ${2 ** (i + 1)}) * 2)`,
+                target: `${rtn}${i}`,
+            });
+        }
+        return {
+            ret: rtn,
+            bindings,
+        };
+    }
+    intToBin(input) {
+        const inStr = `expr:${input}`;
+        if (this.cache.has(inStr)) {
+            return this.cache.get(inStr);
+        }
+        else {
+            const { ret, bindings } = Parser.intToBin(input);
+            this.cache.set(inStr, ret);
+            this.genBindings.push(...bindings);
+            return ret;
+        }
+    }
     at() {
         return this.tokens[this.position];
     }
@@ -81,19 +115,106 @@ export class Parser {
         return left;
     }
     parseMultiplicativeExpression() {
-        let left = this.parsePrimaryExpression(), current;
+        let left = this.parseBitwiseLogicExpression(), current;
         while ((current = this.at()) &&
             this.at()?.kind === TokenKind.OPERATOR &&
             ["*", "/", "%"].includes(current.value)) {
             const operator = this.eat();
             const right = this.parsePrimaryExpression();
-            if (current.value === "%")
-                left = `(${left} - (${left} / ${right} * ${right}))`;
+            if (current.value === "%") {
+                const cacheStr = `expr:${left}${operator.value}${right}`;
+                if (this.cache.has(cacheStr)) {
+                    return (left = this.cache.get(cacheStr));
+                }
+                const ret = RandomBindingString(16);
+                this.genBindings.push({
+                    source: `(${left} - (${left} / ${right} * ${right}))`,
+                    target: ret,
+                });
+                this.cache.set(cacheStr, ret);
+                left = ret;
+            }
             else
                 left = `(${left} ${operator.value} ${right})`;
         }
         return left;
     }
+    parseBitwiseLogicExpression() {
+        let left = this.parseBitwiseShiftExpression(), current;
+        while ((current = this.at()) &&
+            this.at()?.kind === TokenKind.OPERATOR &&
+            ["&", "|", "^"].includes(current.value)) {
+            const operator = this.eat();
+            const right = this.parsePrimaryExpression();
+            const cacheStr = `expr:${left}${operator.value}${right}`;
+            if (this.cache.has(cacheStr)) {
+                return (left = this.cache.get(cacheStr));
+            }
+            const ret = RandomBindingString(16);
+            this.cache.set(cacheStr, ret);
+            const leftBin = this.intToBin(left);
+            const rightBin = this.intToBin(right);
+            if (operator.value === "&") {
+                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
+                    return {
+                        source: `(${leftBin}${i} * ${rightBin}${i})`,
+                        target: `${ret}${i}`,
+                    };
+                }));
+            }
+            else if (operator.value === "|") {
+                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
+                    return {
+                        source: `(${leftBin}${i} + ${rightBin}${i} - (${leftBin}${i} * ${rightBin}${i}))`,
+                        target: `${ret}${i}`,
+                    };
+                }));
+            }
+            else {
+                this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
+                    return {
+                        source: `(${leftBin}${i} + ${rightBin}${i} - 2 * (${leftBin}${i} * ${rightBin}${i}))`,
+                        target: `${ret}${i}`,
+                    };
+                }));
+            }
+            this.genBindings.push({
+                source: `(${Array.from({ length: 30 }, (_, i) => `(${ret}${i} * ${2 ** i})`).join(" + ")})`,
+                target: ret,
+            });
+            left = ret;
+        }
+        return left;
+    }
+    parseBitwiseShiftExpression() {
+        let left = this.parsePrimaryExpression(), current;
+        while ((current = this.at()) &&
+            this.at()?.kind === TokenKind.OPERATOR &&
+            [">>", "<<"].includes(current.value)) {
+            const operator = this.eat();
+            const right = this.parsePrimaryExpression();
+            const cacheStr = `expr:${left}${operator.value}${right}`;
+            if (this.cache.has(cacheStr)) {
+                return (left = this.cache.get(cacheStr));
+            }
+            const ret = RandomBindingString(16);
+            this.cache.set(cacheStr, ret);
+            const leftBind = this.intToBin(left);
+            const op = operator.value === "<<" ? "-" : "+";
+            this.genBindings.push(...Array.from({ length: 30 }, (_, i) => {
+                return {
+                    source: `((0 * ${left}) + ('${leftBind}' + (${i} ${op} ${right})))`,
+                    target: `${ret}${i}`,
+                };
+            }));
+            this.genBindings.push({
+                source: `(${Array.from({ length: 30 }, (_, i) => `(${ret}${i} * ${2 ** i})`).join(" + ")})`,
+                target: ret,
+            });
+            left = ret;
+        }
+        return left;
+    }
     parsePrimaryExpression() {
         const left = this.at();
         switch (left?.kind) {
@@ -107,8 +228,18 @@ export class Parser {
                 return `(${value})`;
             }
             case TokenKind.NUMBER: {
-                const [num, exp] = this.eat().value.split("e");
-                return "" + (exp ? +num * 10 ** +exp : num);
+                const numberToken = this.eat();
+                switch (numberToken.value[1]) {
+                    case "x":
+                        return "" + parseInt(numberToken.value.slice(2), 16);
+                    case "o":
+                        return "" + parseInt(numberToken.value.slice(2), 8);
+                    case "b":
+                        return "" + parseInt(numberToken.value.slice(2), 2);
+                    default:
+                        const [num, exp] = numberToken.value.split("e");
+                        return "" + (exp ? +num * 10 ** +exp : num);
+                }
             }
             case TokenKind.VARIABLE:
             case TokenKind.STRING:
@@ -184,7 +315,15 @@ export class Parser {
                 }
             }
             this.eat();
-            return this.funtionCall(callerToken.value, ...args);
+            const inputStr = `func:${callerToken.value}(${args.join(", ")})`;
+            if (this.cache.has(inputStr)) {
+                return this.cache.get(inputStr);
+            }
+            else {
+                const ret = this.functionCall(callerToken.value, ...args);
+                this.cache.set(inputStr, ret);
+                return ret;
+            }
         }
         else if (left?.kind === TokenKind.OPERATOR) {
             this.warn(`Implicit string literal '${callerToken.value}'. Use quoted string ('${callerToken.value}') for clarity!`, callerToken);
@@ -198,8 +337,8 @@ export class Parser {
             return callerToken.value;
         }
     }
-    funtionCall(name, ...params) {
-        const func = FuntionMap.get(name.toLowerCase());
+    functionCall(name, ...params) {
+        const func = FunctionMap.get(name.toLowerCase());
         if (!func) {
             return this.expect(TokenKind.WORD, "Function not found!");
         }
@@ -226,6 +365,7 @@ export class Parser {
     out() {
         return {
             out: `(${this.output})`,
+            cache: this.cache,
             gen: this.genBindings.map(({ source, target }) => ({
                 binding_type: BindingType.VIEW,
                 source_property_name: `(${source})`,

package/dist/js/compilers/ui/builder.js

@@ -1,18 +1,18 @@
-import { isBuildMode } from "../Configuration.js";
+import { config, isBuildMode, isLinkMode, unLinked } from "../Configuration.js";
 import { Memory } from "../Memory.js";
-import { createBuildFolder, linkToGame } from "./linker.js";
+import { createBuildFolder, linkToGame, unlink } from "./linker.js";
 import { genManifest } from "./manifest.js";
 import fs from "fs/promises";
+import { BuildCache } from "./buildcache.js";
 async function buildUI() {
     const build = Memory.build();
     build.set("ui/_ui_defs.json", {
         ui_defs: Array.from(build.keys()),
     });
-    build.set("build.json", {
-        files: Array.from(build.keys()),
-    });
+    if (config.global_variables)
+        build.set("ui/_global_variables.json", config.global_variables);
     const out = await Promise.all(build.entries().map(async ([file, value]) => {
-        const outFile = `build/build/${file}`;
+        const outFile = `build/${file}`;
         await fs
             .stat(outFile.split(/\\|\//g).slice(0, -1).join("/"))
             .catch(async () => await fs.mkdir(outFile.split(/\\|\//g).slice(0, -1).join("/"), { recursive: true }));
@@ -24,11 +24,12 @@ async function buildUI() {
         return file;
     }));
     await Promise.all([
-        fs.writeFile("build/build/manifest.json", await genManifest(), "utf-8"),
-        fs.writeFile("build/build/.gitignore", [...out, "manifest.json"].join("\n"), "utf-8"),
+        fs.writeFile("build/manifest.json", await genManifest(), "utf-8"),
+        fs.writeFile("build/.gitignore", [...out, "manifest.json"].join("\n"), "utf-8"),
+        BuildCache.set("build-files", [...out, "manifest.json"]),
         fs
-            .stat("build/build/pack_icon.png")
-            .catch(() => fs.copyFile("node_modules/asajs/resources/pack_icon.png", "build/build/pack_icon.png")),
+            .stat("build/pack_icon.png")
+            .catch(() => fs.copyFile("node_modules/asajs/resources/pack_icon.png", "build/pack_icon.png")),
     ]);
     return out.length;
 }
@@ -38,8 +39,13 @@ if (isBuildMode) {
         if (first) {
             await createBuildFolder();
             await buildUI();
-            await linkToGame();
+            if (isLinkMode)
+                await linkToGame();
         }
         first = false;
     });
 }
+else if (isLinkMode)
+    linkToGame();
+else if (unLinked)
+    unlink();

package/dist/js/compilers/ui/linker.js

@@ -1,7 +1,6 @@
 import fs from "fs/promises";
 import { BuildCache } from "./buildcache.js";
 import { RandomString } from "../../components/Utils.js";
-import { prevData } from "./prevdata.js";
 import path from "path";
 import { getGamedataPath } from "./installer.js";
 const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
@@ -18,7 +17,8 @@ function genUUID() {
         `${HEX[b[10]]}${HEX[b[11]]}${HEX[b[12]]}${HEX[b[13]]}${HEX[b[14]]}${HEX[b[15]]}`);
 }
 export async function clearBuild() {
-    await Promise.all(prevData.files.map(file => fs.rm(`build/build/${file}`).catch(() => null)));
+    const files = (await BuildCache.get("build-files")) || [];
+    await Promise.all(files.map(file => fs.rm(`build/${file}`).catch(() => null)));
 }
 export async function createBuildFolder() {
     return fs
@@ -30,12 +30,21 @@ export async function getBuildFolderName() {
     return await BuildCache.getWithSetDefault("build-key", () => RandomString(16));
 }
 export async function linkToGame() {
-    const sourcePath = path.resolve("build/build");
+    const sourcePath = path.resolve("build");
     const targetPath = path.resolve(getGamedataPath(), "development_resource_packs", await getBuildFolderName());
     await fs.stat(targetPath).catch(async () => {
         await fs.symlink(sourcePath, targetPath, "junction");
     });
 }
+export async function unlink() {
+    const targetPath = path.resolve(getGamedataPath(), "development_resource_packs", await getBuildFolderName());
+    try {
+        await fs.unlink(targetPath);
+    }
+    catch (error) {
+        console.error(error);
+    }
+}
 export async function getUUID() {
     return await BuildCache.getWithSetDefault("uuid", () => {
         return [genUUID(), genUUID()];

package/dist/js/compilers/ui/manifest.js

@@ -1,14 +1,15 @@
+import { config } from "../Configuration.js";
 import { getUUID } from "./linker.js";
 export async function genManifest() {
     const [uuid1, uuid2] = await getUUID();
     return JSON.stringify({
         format_version: 2,
         header: {
-            name: "AsaJS UI",
-            description: "A framework for creating UIs for AsaJS.",
+            name: config.packinfo?.name || "AsaJS",
+            description: config.packinfo?.description || "Create your Minecraft JSON-UI resource packs using JavaScript.",
             uuid: uuid1,
-            version: [4, 0, 0],
-            min_engine_version: [1, 21, 132],
+            version: config.packinfo?.version || [4, 0, 0],
+            min_engine_version: [1, 21, 80],
         },
         modules: [
             {
@@ -18,5 +19,7 @@ export async function genManifest() {
                 version: [4, 0, 0],
             },
         ],
+        subpacks: config.packinfo?.subpacks,
+        metadata: config.packinfo?.metadata,
     });
 }

package/dist/js/compilers/ui/prevdata.js

@@ -1,7 +1,7 @@
 import fs from "fs";
 export let prevData;
 try {
-    prevData = JSON.parse(fs.readFileSync("build/build/build.json", "utf-8"));
+    prevData = JSON.parse(fs.readFileSync("build/build.json", "utf-8"));
 }
 catch (error) {
     prevData = { files: [] };

package/dist/js/components/AnimationKeyframe.js

@@ -25,7 +25,7 @@ export class AnimationKeyframe extends Class {
         }
         this.name = name || RandomString(16);
         this.namespace = namespace || RandomNamespace();
-        this.path = path || `@/${this.namespace}.json`;
+        this.path = path || `asajs/${this.namespace}.json`;
         Memory.add(this);
     }
     setNext(keyframe) {

package/dist/js/components/UI.js

@@ -20,6 +20,7 @@ export class UI extends Class {
     anims = [];
     extendType;
     properties = {};
+    bindCache = new Map();
     constructor(type, name, namespace, path) {
         super();
         this.type = type;
@@ -55,7 +56,7 @@ export class UI extends Class {
      * @returns
      */
     addBindings(...bindings) {
-        this.bindings.push(...ResolveBinding(...bindings));
+        this.bindings.push(...ResolveBinding(this.bindCache, ...bindings));
         return this;
     }
     /**
@@ -270,14 +271,14 @@ export class ModifyUI extends UI {
         return this.addModifications({
             array_name: ArrayName.BINDINGS,
             operation: Operation.INSERT_BACK,
-            value: ResolveBinding(...bindings),
+            value: ResolveBinding(this.bindCache, ...bindings),
         });
     }
     insertFrontBindings(...bindings) {
         return this.addModifications({
             array_name: ArrayName.BINDINGS,
             operation: Operation.INSERT_FRONT,
-            value: ResolveBinding(...bindings),
+            value: ResolveBinding(this.bindCache, ...bindings),
         });
     }
     insertBindings(...bindings) {

package/dist/js/components/Utils.js

@@ -9,6 +9,8 @@ import { AnimType } from "../types/enums/AnimType.js";
 import { AnimationKeyframe } from "./AnimationKeyframe.js";
 import { Animation } from "./Animation.js";
 import { MemoryModify } from "../compilers/Memory.js";
+import { Lexer } from "../compilers/bindings/Lexer.js";
+import { TokenKind, TSTokenKind } from "../compilers/bindings/types.js";
 export function Color(hex) {
     if (typeof hex === "number") {
         return [((hex >> 16) & 0xff) / 0xff, ((hex >> 8) & 0xff) / 0xff, (hex & 0xff) / 0xff];
@@ -36,15 +38,69 @@ export function Color(hex) {
         }
     }
 }
-export function ResolveBinding(...bindings) {
+export function ResolveBinding(cache, ...bindings) {
     const result = [];
     for (const binding of bindings) {
         if (binding.source_property_name) {
             if (isCompileBinding(binding.source_property_name)) {
-                const { gen, out } = new Parser(binding.source_property_name.slice(1, -1)).out();
-                if (gen)
-                    result.push(...gen);
-                binding.source_property_name = out;
+                const inputBindings = binding.source_property_name.slice(1, -1);
+                if (binding.source_control_name) {
+                    // @ts-ignore
+                    const tokensMapping = (token) => {
+                        if (token.kind === TokenKind.VARIABLE) {
+                            const mapkey = `mapping:${binding.source_control_name}:${token.value}`;
+                            if (cache.has(mapkey)) {
+                                return {
+                                    ...token,
+                                    value: cache.get(mapkey),
+                                };
+                            }
+                            else {
+                                const ret = RandomBindingString(16);
+                                cache.set(mapkey, ret);
+                                result.push({
+                                    source_property_name: token.value,
+                                    source_control_name: binding.source_control_name,
+                                    target_property_name: ret,
+                                    binding_type: BindingType.VIEW,
+                                });
+                                return {
+                                    ...token,
+                                    value: ret,
+                                };
+                            }
+                        }
+                        else if (token.kind === TokenKind.TEMPLATE_STRING) {
+                            return {
+                                ...token,
+                                // @ts-ignore
+                                value: token.value.map((tstoken) => {
+                                    if (tstoken.kind === TSTokenKind.STRING)
+                                        return tstoken;
+                                    else {
+                                        return {
+                                            ...tstoken,
+                                            tokens: tstoken.tokens.map(tokensMapping),
+                                        };
+                                    }
+                                }),
+                            };
+                        }
+                        else
+                            return token;
+                    };
+                    const { gen, out } = new Parser(inputBindings, cache, Lexer(inputBindings).map(tokensMapping)).out();
+                    delete binding.source_control_name;
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
+                else {
+                    const { gen, out } = new Parser(inputBindings, cache).out();
+                    if (gen)
+                        result.push(...gen);
+                    binding.source_property_name = out;
+                }
             }
             binding.binding_type = BindingType.VIEW;
             if (!binding.target_property_name)
@@ -107,6 +163,13 @@ export function Modify(namespace, name) {
     // @ts-ignore
     if (memoryUI)
         return memoryUI;
+    if (!paths[namespace]) {
+        throw new Error(`Namespace '${namespace}' does not exist`);
+        // @ts-ignore
+    }
+    else if (!paths[namespace][name]) {
+        throw new Error(`Element '${name}' does not exist in namespace '${namespace}'`);
+    }
     // @ts-ignore
     const modifyUI = new ModifyUI(namespace, name, 
     // @ts-ignore
@@ -205,49 +268,49 @@ properties, namespace, name) {
     return ui;
 }
 // Quick Keyframe
-export function KeyframeOffset(properties, namespace, name) {
+export function OffsetKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.OFFSET, properties || {}, name, namespace);
 }
-export function KeyframeSize(properties, namespace, name) {
+export function SizeKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.SIZE, properties || {}, name, namespace);
 }
-export function KeyframeUV(properties, namespace, name) {
+export function UVKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.UV, properties || {}, name, namespace);
 }
-export function KeyframeClip(properties, namespace, name) {
+export function ClipKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.CLIP, properties || {}, name, namespace);
 }
-export function KeyframeColor(properties, namespace, name) {
+export function ColorKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.COLOR, properties || {}, name, namespace);
 }
-export function KeyframeAlpha(properties, namespace, name) {
+export function AlphaKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.ALPHA, properties || {}, name, namespace);
 }
-export function KeyframeWait(properties, namespace, name) {
+export function WaitKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.WAIT, properties || {}, name, namespace);
 }
-export function KeyframeFlipBook(properties, namespace, name) {
+export function FlipBookKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.FLIP_BOOK, properties || {}, name, namespace);
 }
-export function KeyframeAsepriteFlipBook(properties, namespace, name) {
+export function AsepriteFlipBookKeyframe(properties, namespace, name) {
     return new AnimationKeyframe(AnimType.ASEPRITE_FLIP_BOOK, properties || {}, name, namespace);
 }
-export function AnimationOffset(...keyframes) {
+export function OffsetAnimation(...keyframes) {
     return new Animation(AnimType.OFFSET, ...keyframes);
 }
-export function AnimationSize(...keyframes) {
+export function SizeAnimation(...keyframes) {
     return new Animation(AnimType.SIZE, ...keyframes);
 }
-export function AnimationUV(...keyframes) {
+export function UVAnimation(...keyframes) {
     return new Animation(AnimType.UV, ...keyframes);
 }
-export function AnimationClip(...keyframes) {
+export function ClipAnimation(...keyframes) {
     return new Animation(AnimType.CLIP, ...keyframes);
 }
-export function AnimationColor(...keyframes) {
+export function ColorAnimation(...keyframes) {
     return new Animation(AnimType.COLOR, ...keyframes);
 }
-export function AnimationAlpha(...keyframes) {
+export function AlphaAnimation(...keyframes) {
     return new Animation(AnimType.ALPHA, ...keyframes);
 }
 // Animation ExtendsOf

package/dist/js/config..js

@@ -0,0 +1 @@
+export {};

package/dist/js/config.js

@@ -0,0 +1 @@
+export {};

package/dist/js/index.js

@@ -1,3 +1,4 @@
+import "./compilers/Configuration.js";
 import "./compilers/PreCompile.js";
 import "./compilers/ui/builder.js";
 import "./compilers/ui/installer.js";
@@ -8,3 +9,5 @@ export * from "./components/Utils.js";
 export * from "./types/enums/index.js";
 export * as Properties from "./types/properties/index.js";
 export { ItemAuxID } from "./types/enums/Items.js";
+export { ArrayName, Operation } from "./types/properties/index.js";
+export { Lexer } from "./compilers/bindings/Lexer.js";

package/dist/js/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/types/compilers/Configuration.d.ts

@@ -1 +1,5 @@
-export declare const isBuildMode: boolean;
+import { Config } from "../../config.js";
+export declare const config: Config;
+export declare let isBuildMode: boolean;
+export declare let isLinkMode: boolean;
+export declare let unLinked: boolean;

package/dist/types/compilers/bindings/Checker.d.ts

@@ -1,4 +1,7 @@
 export declare function isBlankChar(char: string): boolean;
 export declare function isWordChar(char: string): boolean | "";
 export declare function isNumberChar(char: string): boolean;
+export declare function isHexChar(char: string): boolean;
+export declare function isBinaryChar(char: string): boolean;
+export declare function isOctalChar(char: string): boolean;
 export declare function isCompileBinding(input: string): boolean;

package/dist/types/compilers/bindings/Function.d.ts

@@ -0,0 +1,7 @@
+import { Expression, GenBinding } from "./types.js";
+type Callback = (...args: Expression[]) => {
+    genBindings?: GenBinding[];
+    value: Expression;
+};
+export declare const FunctionMap: Map<string, Callback>;
+export {};

package/dist/types/compilers/bindings/Funtion.d.ts

@@ -3,5 +3,5 @@ type Callback = (...args: Expression[]) => {
     genBindings?: GenBinding[];
     value: Expression;
 };
-export declare const FuntionMap: Map<string, Callback>;
+export declare const FunctionMap: Map<string, Callback>;
 export {};

package/dist/types/compilers/bindings/Parser.d.ts

@@ -2,11 +2,17 @@ import { Expression, GenBinding, Token } from "./types.js";
 import { BindingItem } from "../../types/properties/value.js";
 export declare class Parser {
     private input;
+    private cache;
     position: number;
-    tokens: Token[];
     genBindings: GenBinding[];
     output: Expression;
-    constructor(input: string);
+    tokens: Token[];
+    constructor(input: string, cache?: Map<string, unknown>, tokens?: Token[]);
+    static intToBin(input: string): {
+        ret: `#${string}`;
+        bindings: GenBinding[];
+    };
+    intToBin(input: string): string;
     at(): Token;
     eat(): Token;
     last(): Token;
@@ -16,14 +22,17 @@ export declare class Parser {
     private parseComparisonExpression;
     private parseAdditiveExpression;
     private parseMultiplicativeExpression;
+    private parseBitwiseLogicExpression;
+    private parseBitwiseShiftExpression;
     private parsePrimaryExpression;
     private parseCallableOrLiteral;
-    private funtionCall;
+    private functionCall;
     private expect;
     private warn;
     private getPointer;
     out(): {
         gen?: BindingItem[];
         out: Expression;
+        cache: Map<string, unknown>;
     };
 }

package/dist/types/compilers/ui/linker.d.ts

@@ -2,4 +2,5 @@ export declare function clearBuild(): Promise<void>;
 export declare function createBuildFolder(): Promise<void>;
 export declare function getBuildFolderName(): Promise<string>;
 export declare function linkToGame(): Promise<void>;
+export declare function unlink(): Promise<void>;
 export declare function getUUID(): Promise<[string, string]>;

package/dist/types/components/AnimationKeyframe.d.ts

@@ -15,8 +15,8 @@ export declare class AnimationKeyframe<T extends AnimType> extends Class {
     clearNext(): this;
     protected toJsonUI(): KeyframeAnimationProperties<AnimType>;
     protected toJSON(): (Partial<import("../types/properties/element/Animation.js").DurationAnimation> & import("../types/properties/element/Animation.js").KeyframeAnimationPropertiesItem) | (Partial<import("../types/properties/element/Animation.js").AsepriteFlipBookAnimation> & import("../types/properties/element/Animation.js").KeyframeAnimationPropertiesItem) | {
-        from?: import("../types/properties/value.js").Array2<string | number> | undefined;
-        to?: import("../types/properties/value.js").Array2<string | number> | undefined;
+        from?: import("../types/properties/value.js").Value<number> | undefined;
+        to?: import("../types/properties/value.js").Value<number> | undefined;
         duration?: import("../types/properties/value.js").Value<number> | undefined;
         easing?: import("../types/properties/value.js").Value<string | import("../index.js").Easing> | undefined;
         next?: import("../types/properties/value.js").Value<string | AnimationKeyframe<AnimType> | Animation<AnimType>>;
@@ -33,8 +33,8 @@ export declare class AnimationKeyframe<T extends AnimType> extends Class {
         wait_until_rendered_to_play?: import("../types/properties/value.js").Value<boolean>;
         anim_type: T;
     } | {
-        from?: import("../types/properties/value.js").Value<number> | undefined;
-        to?: import("../types/properties/value.js").Value<number> | undefined;
+        from?: import("../types/properties/value.js").Array2<string | number> | undefined;
+        to?: import("../types/properties/value.js").Array2<string | number> | undefined;
         duration?: import("../types/properties/value.js").Value<number> | undefined;
         easing?: import("../types/properties/value.js").Value<string | import("../index.js").Easing> | undefined;
         next?: import("../types/properties/value.js").Value<string | AnimationKeyframe<AnimType> | Animation<AnimType>>;

package/dist/types/components/UI.d.ts

@@ -26,6 +26,7 @@ export declare class UI<T extends Type, K extends Renderer | null = null> extend
     protected readonly anims: (Animation<AnimType> | AnimationKeyframe<AnimType>)[];
     protected readonly extendType?: Type;
     protected properties: Properties<T, K>;
+    protected bindCache: Map<string, unknown>;
     constructor(type?: T | undefined, name?: string, namespace?: string, path?: string);
     /**
      * Set properties for this element

package/dist/types/components/Utils.d.ts

@@ -11,7 +11,7 @@ import { Animation } from "./Animation.js";
 import { SmartAnimation } from "../types/enums/SmartAnimation.js";
 type CompileBinding = `[${string}]`;
 export declare function Color(hex: string | number): Array3<number>;
-export declare function ResolveBinding(...bindings: BindingItem[]): BindingItem[];
+export declare function ResolveBinding(cache: Map<string, unknown>, ...bindings: BindingItem[]): BindingItem[];
 export declare function RandomString(length: number, base?: number): string;
 export declare function RandomBindingString(length: number, base?: number): Binding;
 export declare function GetItemByAuxID(auxID: number): string | undefined;
@@ -50,22 +50,22 @@ export declare function Slider(properties?: Slider, namespace?: string, name?: s
 export declare function SliderBox(properties?: SliderBox, namespace?: string, name?: string): UI<Type.SLIDER_BOX, null>;
 export declare function ExtendsOf<T extends Type, K extends Renderer | null>(element: UI<T, K>, properties?: Properties<T, K>, namespace?: string, name?: string): typeof element;
 export declare function VanillaExtendsOf<T extends Namespace, K extends Exclude<Element<T>, `${string}/${string}`>>(originNamespace: T, originName: K, properties?: Properties<VanillaType<T, K>, null>, namespace?: string, name?: string): UI<VanillaType<T, K>, null>;
-export declare function KeyframeOffset(properties?: KeyframeAnimationProperties<AnimType.OFFSET>, namespace?: string, name?: string): AnimationKeyframe<AnimType.OFFSET>;
-export declare function KeyframeSize(properties?: KeyframeAnimationProperties<AnimType.SIZE>, namespace?: string, name?: string): AnimationKeyframe<AnimType.SIZE>;
-export declare function KeyframeUV(properties?: KeyframeAnimationProperties<AnimType.UV>, namespace?: string, name?: string): AnimationKeyframe<AnimType.UV>;
-export declare function KeyframeClip(properties?: KeyframeAnimationProperties<AnimType.CLIP>, namespace?: string, name?: string): AnimationKeyframe<AnimType.CLIP>;
-export declare function KeyframeColor(properties?: KeyframeAnimationProperties<AnimType.COLOR>, namespace?: string, name?: string): AnimationKeyframe<AnimType.COLOR>;
-export declare function KeyframeAlpha(properties?: KeyframeAnimationProperties<AnimType.ALPHA>, namespace?: string, name?: string): AnimationKeyframe<AnimType.ALPHA>;
-export declare function KeyframeWait(properties?: KeyframeAnimationProperties<AnimType.WAIT>, namespace?: string, name?: string): AnimationKeyframe<AnimType.WAIT>;
-export declare function KeyframeFlipBook(properties?: KeyframeAnimationProperties<AnimType.FLIP_BOOK>, namespace?: string, name?: string): AnimationKeyframe<AnimType.FLIP_BOOK>;
-export declare function KeyframeAsepriteFlipBook(properties?: KeyframeAnimationProperties<AnimType.ASEPRITE_FLIP_BOOK>, namespace?: string, name?: string): AnimationKeyframe<AnimType.ASEPRITE_FLIP_BOOK>;
+export declare function OffsetKeyframe(properties?: KeyframeAnimationProperties<AnimType.OFFSET>, namespace?: string, name?: string): AnimationKeyframe<AnimType.OFFSET>;
+export declare function SizeKeyframe(properties?: KeyframeAnimationProperties<AnimType.SIZE>, namespace?: string, name?: string): AnimationKeyframe<AnimType.SIZE>;
+export declare function UVKeyframe(properties?: KeyframeAnimationProperties<AnimType.UV>, namespace?: string, name?: string): AnimationKeyframe<AnimType.UV>;
+export declare function ClipKeyframe(properties?: KeyframeAnimationProperties<AnimType.CLIP>, namespace?: string, name?: string): AnimationKeyframe<AnimType.CLIP>;
+export declare function ColorKeyframe(properties?: KeyframeAnimationProperties<AnimType.COLOR>, namespace?: string, name?: string): AnimationKeyframe<AnimType.COLOR>;
+export declare function AlphaKeyframe(properties?: KeyframeAnimationProperties<AnimType.ALPHA>, namespace?: string, name?: string): AnimationKeyframe<AnimType.ALPHA>;
+export declare function WaitKeyframe(properties?: KeyframeAnimationProperties<AnimType.WAIT>, namespace?: string, name?: string): AnimationKeyframe<AnimType.WAIT>;
+export declare function FlipBookKeyframe(properties?: KeyframeAnimationProperties<AnimType.FLIP_BOOK>, namespace?: string, name?: string): AnimationKeyframe<AnimType.FLIP_BOOK>;
+export declare function AsepriteFlipBookKeyframe(properties?: KeyframeAnimationProperties<AnimType.ASEPRITE_FLIP_BOOK>, namespace?: string, name?: string): AnimationKeyframe<AnimType.ASEPRITE_FLIP_BOOK>;
 type Anim<T extends AnimType> = AnimationProperties<T> | number;
 type AnimWithSmartAnim<T extends AnimType> = [SmartAnimation | Anim<T>, ...Anim<T>[]];
-export declare function AnimationOffset(...keyframes: AnimWithSmartAnim<AnimType.OFFSET>): Animation<AnimType.OFFSET>;
-export declare function AnimationSize(...keyframes: AnimWithSmartAnim<AnimType.SIZE>): Animation<AnimType.SIZE>;
-export declare function AnimationUV(...keyframes: AnimWithSmartAnim<AnimType.UV>): Animation<AnimType.UV>;
-export declare function AnimationClip(...keyframes: AnimWithSmartAnim<AnimType.CLIP>): Animation<AnimType.CLIP>;
-export declare function AnimationColor(...keyframes: AnimWithSmartAnim<AnimType.COLOR>): Animation<AnimType.COLOR>;
-export declare function AnimationAlpha(...keyframes: AnimWithSmartAnim<AnimType.ALPHA>): Animation<AnimType.ALPHA>;
+export declare function OffsetAnimation(...keyframes: AnimWithSmartAnim<AnimType.OFFSET>): Animation<AnimType.OFFSET>;
+export declare function SizeAnimation(...keyframes: AnimWithSmartAnim<AnimType.SIZE>): Animation<AnimType.SIZE>;
+export declare function UVAnimation(...keyframes: AnimWithSmartAnim<AnimType.UV>): Animation<AnimType.UV>;
+export declare function ClipAnimation(...keyframes: AnimWithSmartAnim<AnimType.CLIP>): Animation<AnimType.CLIP>;
+export declare function ColorAnimation(...keyframes: AnimWithSmartAnim<AnimType.COLOR>): Animation<AnimType.COLOR>;
+export declare function AlphaAnimation(...keyframes: AnimWithSmartAnim<AnimType.ALPHA>): Animation<AnimType.ALPHA>;
 export declare function AnimationExtendsOf<T extends AnimType>(animation: AnimationKeyframe<T> | Animation<T>, properties?: AnimationProperties<T>): AnimationKeyframe<T>;
 export {};

package/dist/types/config..d.ts

@@ -0,0 +1,2 @@
+export interface Config {
+}

package/dist/types/config.d.ts

@@ -0,0 +1,13 @@
+import { Variable } from "./src/types/properties/value.js";
+export interface Config {
+    compiler?: {
+        enabled?: boolean;
+        linked?: boolean;
+    };
+    packinfo?: {
+        name?: string;
+        description?: string;
+        version?: [number, number, number];
+    };
+    global_variables?: Record<Variable, string>;
+}

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
+import "./compilers/Configuration.js";
 import "./compilers/PreCompile.js";
 import "./compilers/ui/builder.js";
 import "./compilers/ui/installer.js";
@@ -8,3 +9,5 @@ export * from "./components/Utils.js";
 export * from "./types/enums/index.js";
 export * as Properties from "./types/properties/index.js";
 export { ItemAuxID } from "./types/enums/Items.js";
+export { ArrayName, Operation } from "./types/properties/index.js";
+export { Lexer } from "./compilers/bindings/Lexer.js";

package/dist/types/types/config.d.ts

@@ -0,0 +1,13 @@
+import { Variable } from "./properties/value.js";
+export interface Config {
+    compiler?: {
+        enabled?: boolean;
+        linked?: boolean;
+    };
+    packinfo?: {
+        name?: string;
+        description?: string;
+        version?: [number, number, number];
+    };
+    global_variables?: Record<Variable, string>;
+}

package/dist/types/types/enums/index.d.ts

@@ -28,4 +28,3 @@ export { SliderName } from "./SliderName.js";
 export { ToggleName } from "./ToggleName.js";
 export { BagBinding } from "./BagBinding.js";
 export { Binding } from "./Binding.js";
-export { SmartAnimation } from "./SmartAnimation.js";

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "asajs",
-	"version": "4.0.0-indev-2",
+	"version": "4.0.0-indev-3",
 	"description": "Create your Minecraft JSON-UI resource packs using JavaScript",
 	"keywords": [
 		"Minecraft",

package/resources/asajs.config.cjs

@@ -0,0 +1,14 @@
+/**
+ * Configuration object for the AsaJS build process.
+ * @type {import('asajs/config.d.ts').Config}
+ */
+export const config = {
+	packinfo: {
+		name: "AsaJS",
+		description: "Create your Minecraft JSON-UI resource packs using JavaScript.",
+	},
+	compiler: {
+		enabled: true,
+		linked: false,
+	},
+}