asajs 4.0.4 → 4.0.6-indev

package/config.d.ts

@@ -7,6 +7,7 @@ export interface Config {
 		importToPreview?: boolean
 		autoEnable?: boolean
 		gdkUserId?: string
+		fixInventoryItemRenderer?: boolean
 	}
 	packinfo?: {
 		name?: string

package/dist/js/compilers/FormatProperties.js

@@ -1,4 +1,6 @@
 import { AnimationKeyframe } from "../components/AnimationKeyframe.js";
+import { BagBinding } from "../types/enums/BagBinding.js";
+import { config } from "./Configuration.js";
 export function FormatProperties(properties) {
     const property_bag = {};
     for (const key in properties) {
@@ -8,6 +10,9 @@ export function FormatProperties(properties) {
             delete properties[key];
         }
     }
+    if (config.compiler?.fixInventoryItemRenderer && property_bag[BagBinding.ITEM_ID_AUX]) {
+        property_bag[BagBinding.ITEM_ID_AUX] = `(${property_bag[BagBinding.ITEM_ID_AUX]} / 1)`;
+    }
     if (properties.anchor) {
         properties.anchor_from = properties.anchor_to = properties.anchor;
         delete properties.anchor;

package/dist/js/compilers/bindings/Binary.js

@@ -2,7 +2,7 @@ import { RandomBindingString } from "../../components/Utils.js";
 import { defaultFunctions } from "./Function.js";
 export function intToBin(input) {
     const { abs, negabs } = defaultFunctions;
-    const ret = RandomBindingString(16);
+    const ret = RandomBindingString();
     const bindings = [];
     // negative bit
     bindings.push({
@@ -15,7 +15,7 @@ export function intToBin(input) {
     };
 }
 export function binToInt(input) {
-    const ret = RandomBindingString(16);
+    const ret = RandomBindingString();
     const bindings = [];
     const nevBind = (input + "0");
     // Is reverse to positive

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

@@ -19,3 +19,6 @@ export function isOctalChar(char) {
 export function isCompileBinding(input) {
     return input.startsWith("[") && input.endsWith("]");
 }
+export function isHasBinding(input) {
+    return /#\w+/.test(input);
+}

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

@@ -1,8 +1,5 @@
 import { RandomBindingString } from "../../components/Utils.js";
 export const FunctionMap = new Map();
-function callFn(name, ...args) {
-    return FunctionMap.get(name)(...args);
-}
 export const defaultFunctions = {
     /**
      * Returns the absolute value of a number (the value without regard to whether it is positive or negative). For example, the absolute value of -5 is the same as the absolute value of 5.
@@ -10,7 +7,7 @@ export const defaultFunctions = {
      * @returns
      */
     abs: number => {
-        const randomBinding = RandomBindingString(16);
+        const randomBinding = RandomBindingString();
         return {
             genBindings: [{ source: `((-1 + (${number} > 0) * 2) * ${number})`, target: randomBinding }],
             value: randomBinding,
@@ -22,7 +19,7 @@ export const defaultFunctions = {
      * @returns
      */
     negabs: number => {
-        const randomBinding = RandomBindingString(16);
+        const randomBinding = RandomBindingString();
         return {
             genBindings: [{ source: `((-1 + (${number} < 0) * 2) * ${number})`, target: randomBinding }],
             value: randomBinding,
@@ -34,37 +31,88 @@ export const defaultFunctions = {
      * @returns
      */
     new: expression => {
-        const randomBinding = RandomBindingString(16);
+        const randomBinding = RandomBindingString();
         return {
             genBindings: [{ source: expression, target: randomBinding }],
             value: randomBinding,
         };
     },
-    /**
-     * Returns the square root of a number.
-     * @param number
-     * @returns
-     */
-    sqrt: number => {
-        const rtn = RandomBindingString(16), $1 = RandomBindingString(16), $2 = RandomBindingString(16);
-        const { genBindings: absValue, value: absRtn } = callFn("abs", number);
+    sqrt: input => {
+        const ret = RandomBindingString();
+        const isNegative = RandomBindingString();
+        const isLowerThanTwo = RandomBindingString();
+        const next = RandomBindingString();
+        const nextEqualOrGreaterThan = RandomBindingString();
+        const isNextEqualOrGreaterThanRet = `(${nextEqualOrGreaterThan} * ${ret})`;
+        const isNotNextEqualOrGreaterThanRet = `((not ${nextEqualOrGreaterThan}) * ${next})`;
+        const lowerThanTwoPart = `(${isLowerThanTwo} * ${input})`;
+        const notLowerThanTwoPart = `((not ${isLowerThanTwo}) * (${isNextEqualOrGreaterThanRet} + ${isNotNextEqualOrGreaterThanRet}))`;
+        const negativePart = `(${isNegative} * -1)`;
+        const notNegativePart = `((not ${isNegative}) * (${lowerThanTwoPart} + ${notLowerThanTwoPart}))`;
+        return {
+            genBindings: [
+                {
+                    source: `(${input} < 0)`,
+                    target: isNegative,
+                },
+                {
+                    source: `(${input} < 2)`,
+                    target: isLowerThanTwo,
+                },
+                {
+                    source: input,
+                    target: ret,
+                },
+                {
+                    source: `(${ret} + ${input} / ${ret}) / 2`,
+                    target: next,
+                },
+                {
+                    source: `(${next} = ${ret}) or (${next} > ${ret})`,
+                    target: nextEqualOrGreaterThan,
+                },
+                {
+                    source: `${negativePart} + ${notNegativePart}`,
+                    target: ret,
+                },
+            ],
+            value: ret,
+        };
+    },
+    cache_value: (cache_binding, override_binding, is_read) => {
+        return {
+            value: `((${is_read} * ${cache_binding}) + ((not ${is_read}) * ${override_binding}))`,
+        };
+    },
+    vector_length: (x, y, z) => {
+        const newBind = defaultFunctions.new(`${y} * ${y} + ${x} * ${x} + ${z} * ${z}`);
+        const sqrtBind = defaultFunctions.sqrt(newBind.value);
+        return {
+            genBindings: [newBind.genBindings[0], ...sqrtBind.genBindings],
+            value: sqrtBind.value,
+        };
+    },
+    strlen: str => {
+        if (!/\#\w+/.test(str))
+            throw new Error("Invalid string");
+        const count = RandomBindingString();
+        const inputStr = RandomBindingString();
         return {
             genBindings: [
                 {
-                    source: `${number} * 100 / 2`,
-                    target: $1,
+                    source: `0 * (${str} = 'a')`,
+                    target: count,
                 },
-                ...absValue,
                 {
-                    source: `${absRtn} > 1`,
-                    target: $2,
+                    source: `'a' + ${str}`,
+                    target: inputStr,
                 },
                 {
-                    source: `(${number} < 0) * -1 + (${number} > -1) * (${$2} * ((${rtn} + ${number} / ${rtn}) / 2) + (not ${$2}) * ${rtn})`,
-                    target: rtn,
+                    source: `${count} + (not ((('%.' + (${count} + 1) + 's') * ${inputStr}) = ${inputStr}))`,
+                    target: count,
                 },
             ],
-            value: rtn,
+            value: count,
         };
     },
     /**
@@ -74,6 +122,7 @@ export const defaultFunctions = {
      */
     translatable: key => {
         return {
+            genBindings: [],
             value: `'%' + ${key}`,
         };
     },
@@ -96,7 +145,7 @@ export const defaultFunctions = {
      * @returns
      */
     bind: (value, bait) => {
-        const ret = RandomBindingString(16);
+        const ret = RandomBindingString();
         if (!bait) {
             throw new Error("Bait is required");
         }
@@ -111,7 +160,7 @@ export const defaultFunctions = {
      * @returns
      */
     int: input => {
-        const ret = RandomBindingString(16);
+        const ret = RandomBindingString();
         return {
             genBindings: [{ source: `${input}`, target: ret }],
             value: ret,

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

@@ -40,6 +40,8 @@ export function Lexer(input, start = 0, end) {
             case "/":
             case "%":
             case "^":
+            case "?":
+            case ":":
                 tokens.push(makeToken(input, TokenKind.OPERATOR, index));
                 break;
             case "(":

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

@@ -3,6 +3,7 @@ import { BindingType } from "../../types/enums/BindingType.js";
 import { FunctionMap } from "./Function.js";
 import { Lexer } from "./Lexer.js";
 import { RandomBindingString } from "../../components/Utils.js";
+import { isHasBinding } from "./Checker.js";
 export class Parser {
     input;
     cache;
@@ -26,7 +27,7 @@ export class Parser {
     }
     static intToBin(input) {
         const bindings = [];
-        const rtn = RandomBindingString(16);
+        const rtn = RandomBindingString();
         for (let i = 0; i < 30; i++) {
             bindings.push({
                 source: `(${input} / ${2 ** i} - (${input} / ${2 ** (i + 1)}) * 2)`,
@@ -60,11 +61,56 @@ export class Parser {
         return this.tokens[this.tokens.length - 1];
     }
     parseExpression() {
-        return this.parseOrExpression();
+        return this.parseBinaryExpression();
+    }
+    parseBinaryExpression() {
+        let left = this.parseOrExpression(), current;
+        while ((current = this.at()) && current.kind === TokenKind.OPERATOR && current.value === "?") {
+            this.eat();
+            let middle = this.parseExpression(), right;
+            if ((current = this.at()) && current.kind === TokenKind.OPERATOR && current.value === ":") {
+                this.eat();
+                right = this.parseExpression();
+            }
+            else
+                this.expect(TokenKind.OPERATOR, "Unexpected token!");
+            let leftBind, middleBind, rightBind;
+            if (isHasBinding(left)) {
+                leftBind = RandomBindingString();
+                this.genBindings.push({
+                    source: `((0 + ${left}) > 0)`,
+                    target: leftBind,
+                });
+            }
+            else
+                this.expect(TokenKind.WORD, "Unexpected token!");
+            if (isHasBinding(middle)) {
+                middleBind = RandomBindingString();
+                this.genBindings.push({
+                    source: middle,
+                    target: middleBind,
+                });
+            }
+            else
+                this.expect(TokenKind.WORD, "Unexpected token!");
+            if (isHasBinding(right)) {
+                rightBind = RandomBindingString();
+                this.genBindings.push({
+                    source: right,
+                    target: rightBind,
+                });
+            }
+            else
+                this.expect(TokenKind.WORD, "Unexpected token!");
+            const ifTrueExpression = `(('prefix' + ${leftBind} + ${middleBind}) - ('prefixfalse' + ${middleBind})) - 'prefixtrue')`;
+            const ifFalseExpression = `(('prefix' + ${leftBind} + ${rightBind}) - ('prefixtrue' + ${rightBind})) - 'prefixfalse')`;
+            return `(${ifTrueExpression} + ${ifFalseExpression})`;
+        }
+        return left;
     }
     parseOrExpression() {
         let left = this.parseAndExpression(), current;
-        while ((current = this.at()) && this.at().kind === TokenKind.OPERATOR && current.value === "||") {
+        while ((current = this.at()) && current.kind === TokenKind.OPERATOR && current.value === "||") {
             this.eat();
             left = `(${left} or ${this.parseAndExpression()})`;
         }
@@ -72,7 +118,7 @@ export class Parser {
     }
     parseAndExpression() {
         let left = this.parseComparisonExpression(), current;
-        while ((current = this.at()) && this.at().kind === TokenKind.OPERATOR && current.value === "&&") {
+        while ((current = this.at()) && current.kind === TokenKind.OPERATOR && current.value === "&&") {
             this.eat();
             left = `(${left} and ${this.parseComparisonExpression()})`;
         }
@@ -81,7 +127,7 @@ export class Parser {
     parseComparisonExpression() {
         let left = this.parseAdditiveExpression(), current;
         while ((current = this.at()) &&
-            this.at().kind === TokenKind.OPERATOR &&
+            current.kind === TokenKind.OPERATOR &&
             ["==", ">", "<", ">=", "<=", "!="].includes(current.value)) {
             const operator = this.eat();
             const right = this.parseAdditiveExpression();
@@ -106,7 +152,7 @@ export class Parser {
     parseAdditiveExpression() {
         let left = this.parseMultiplicativeExpression(), current;
         while ((current = this.at()) &&
-            this.at()?.kind === TokenKind.OPERATOR &&
+            current?.kind === TokenKind.OPERATOR &&
             ["+", "-"].includes(current.value)) {
             const operator = this.eat();
             const right = this.parseMultiplicativeExpression();
@@ -117,7 +163,7 @@ export class Parser {
     parseMultiplicativeExpression() {
         let left = this.parseBitwiseLogicExpression(), current;
         while ((current = this.at()) &&
-            this.at()?.kind === TokenKind.OPERATOR &&
+            current?.kind === TokenKind.OPERATOR &&
             ["*", "/", "%"].includes(current.value)) {
             const operator = this.eat();
             const right = this.parsePrimaryExpression();
@@ -126,7 +172,7 @@ export class Parser {
                 if (this.cache.has(cacheStr)) {
                     return (left = this.cache.get(cacheStr));
                 }
-                const ret = RandomBindingString(16);
+                const ret = RandomBindingString();
                 this.genBindings.push({
                     source: `(${left} - (${left} / ${right} * ${right}))`,
                     target: ret,

package/dist/js/compilers/ui/installer.js

@@ -143,6 +143,14 @@ export function getGamedataPath() {
                 }
             }
         }
+        case "linux": {
+            const gamedata = path.join(process.env.HOME, "\\.local\\share\\mcpelauncher\\games\\com.mojang");
+            if (fs.existsSync(gamedata))
+                return (pathinfo.gamepath = gamedata);
+            else {
+                return (pathinfo.gamepath = path.join(process.env.HOME, "\\.var\\app\\io.mrarm.mcpelauncher\\data\\mcpelauncher\\games\\com.mojang"));
+            }
+        }
         default: {
             console.warn(`Your platform is not supported the install feature yet! \nYour OS version: ${os.version()}`);
         }

package/dist/js/components/Utils.js

@@ -56,7 +56,7 @@ export function ResolveBinding(cache, ...bindings) {
                                 };
                             }
                             else {
-                                const ret = RandomBindingString(16);
+                                const ret = RandomBindingString();
                                 cache.set(mapkey, ret);
                                 result.push({
                                     source_property_name: token.value,
@@ -127,7 +127,7 @@ export function RandomString(length, base = 32) {
     }
     return out.join("");
 }
-export function RandomBindingString(length, base = 32) {
+export function RandomBindingString(length = 16, base = 32) {
     return `#${RandomString(length, base)}`;
 }
 export function GetItemByAuxID(auxID) {