asajs 4.0.4 → 4.0.5-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/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/Parser.js

@@ -26,7 +26,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)`,
@@ -126,7 +126,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/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) {