@foxystar/molang 0.1.0

package/esm/parser/parser.js

@@ -0,0 +1,490 @@
+import { MolangParseError } from "../diagnostics/error.js";
+import { MolangRuntime } from "../runtime/runtime.js";
+import { TOKEN_REGEX, } from "./expression.js";
+export class MolangParser {
+    constructor(input) {
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: input
+        });
+        Object.defineProperty(this, "tokens", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "position", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.tokenize();
+    }
+    tokenize() {
+        let str = this.input;
+        let offset = 0;
+        while (str.length > 0) {
+            const match = TOKEN_REGEX.exec(str);
+            if (match === null || match.index !== 0) {
+                throw new MolangParseError(`Unexpected token '${str[0]}'`, offset, this.input);
+            }
+            const raw = match[0];
+            for (const type of Object.keys(match.groups)) {
+                if (match.groups[type]) {
+                    if (type !== "whitespace") {
+                        this.tokens.push({
+                            type: type, value: raw,
+                            start: offset,
+                            end: offset + raw.length
+                        });
+                    }
+                    offset += raw.length;
+                    str = str.slice(raw.length);
+                    break;
+                }
+            }
+        }
+        this.tokens.push({
+            type: "eof", value: "",
+            start: offset, end: offset
+        });
+    }
+    peek() {
+        return this.tokens[this.position];
+    }
+    consume(expectedType) {
+        const token = this.tokens[this.position++];
+        if (expectedType && token.type !== expectedType) {
+            throw new Error(`Expected token type ${expectedType}, but got ${token.type}`);
+        }
+        return token;
+    }
+    parseProgram() {
+        const body = [];
+        const start = this.peek().start;
+        while (this.peek().type !== "eof") {
+            body.push(this.parseStatement());
+            if (this.peek().type === "semicolon") {
+                this.consume("semicolon");
+            }
+            else if (this.peek().type !== "eof") {
+                throw new MolangParseError("Expected ';' between statements", this.peek().start, this.input);
+            }
+        }
+        const end = this.peek().end;
+        return { type: "Program", body, start, end };
+    }
+    parseStatement() {
+        const token = this.peek();
+        // loop(...)
+        if (token.type === "identifier" && token.value === "loop") {
+            const start = token.start;
+            this.consume("identifier"); // loop
+            this.consume("parenthesis"); // (
+            const count = this.parseExpression();
+            if (this.peek().type !== "comma") {
+                throw new MolangParseError("Expected ',' after loop count", this.peek().start, this.input);
+            }
+            this.consume("comma");
+            // body is a STATEMENT, not an expression
+            const body = this.parseStatement();
+            this.consume("parenthesis"); // )
+            return {
+                type: "LoopStatement",
+                count,
+                body,
+                start,
+                end: body.end
+            };
+        }
+        // for_each(...)
+        if (token.type === "identifier" && token.value === "for_each") {
+            const start = token.start;
+            this.consume("identifier"); // for_each
+            this.consume("parenthesis"); // (
+            // iterator (must be assignable)
+            const iterator = this.parseExpression();
+            if (iterator.type !== "Identifier" &&
+                iterator.type !== "IndexExpression") {
+                throw new MolangParseError("'for_each' iterator must be an assignable variable", iterator.start, this.input);
+            }
+            if (this.peek().type !== "comma") {
+                throw new MolangParseError("Expected ',' after for_each iterator", this.peek().start, this.input);
+            }
+            this.consume("comma");
+            const iterable = this.parseExpression();
+            if (this.peek().type !== "comma") {
+                throw new MolangParseError("Expected ',' after for_each iterable", this.peek().start, this.input);
+            }
+            this.consume("comma");
+            // body is a STATEMENT
+            const body = this.parseStatement();
+            this.consume("parenthesis"); // )
+            return {
+                type: "ForEachStatement",
+                iterator,
+                iterable,
+                body,
+                start,
+                end: body.end
+            };
+        }
+        if (token.type === "brace" && token.value === "{") {
+            const start = token.start;
+            this.consume("brace"); // {
+            const body = [];
+            while (!(this.peek().type === "brace" && this.peek().value === "}")) {
+                body.push(this.parseStatement());
+                if (this.peek().type === "semicolon") {
+                    this.consume("semicolon");
+                }
+            }
+            const end = this.consume("brace").end; // }
+            return { type: "BlockStatement", body, start, end };
+        }
+        if (token.type === "identifier" && token.value === "return") {
+            const start = token.start;
+            this.consume("identifier");
+            // return;
+            if (this.peek().type === "semicolon" || this.peek().type === "eof") {
+                return {
+                    type: "ReturnStatement",
+                    start,
+                    end: token.end
+                };
+            }
+            // return <expr>
+            const value = this.parseExpression();
+            return {
+                type: "ReturnStatement",
+                value,
+                start,
+                end: value.end
+            };
+        }
+        // break
+        if (token.type === "identifier" && token.value === "break") {
+            const t = this.consume("identifier");
+            return { type: "BreakStatement", start: t.start, end: t.end };
+        }
+        // continue
+        if (token.type === "identifier" && token.value === "continue") {
+            const t = this.consume("identifier");
+            return { type: "ContinueStatement", start: t.start, end: t.end };
+        }
+        const expr = this.parseBinaryExpression();
+        if (this.peek().type === "operator" && this.peek().value === "?") {
+            this.consume("operator");
+            // Only allow a STATEMENT here
+            const thenStmt = this.parseStatement();
+            let elseStmt;
+            if (this.peek().type === "operator" && this.peek().value === ":") {
+                this.consume("operator"); // :
+                elseStmt = this.parseStatement();
+            }
+            return {
+                type: "ConditionalStatement",
+                condition: expr,
+                then: thenStmt,
+                else: elseStmt,
+                start: expr.start,
+                end: (elseStmt ?? thenStmt).end
+            };
+        }
+        // Assignment
+        if (this.peek().type === "assignment") {
+            this.consume("assignment");
+            const value = this.parseExpression();
+            return {
+                type: "AssignStatement",
+                target: expr,
+                value,
+                start: expr.start,
+                end: value.end
+            };
+        }
+        // Expression statement
+        return {
+            type: "ExprStatement",
+            expr,
+            start: expr.start,
+            end: expr.end
+        };
+    }
+    parseExpression() {
+        return this.parseConditionalExpression();
+    }
+    parseBinaryExpression(precedence = 0) {
+        let left = this.parsePrimaryExpression();
+        while (true) {
+            const token = this.peek();
+            if (token.type === "comma" || token.type === "parenthesis" || token.type === "eof") {
+                break;
+            }
+            const tokenPrecedence = this.getOperatorPrecedence(token.value);
+            if (tokenPrecedence < precedence) {
+                break;
+            }
+            this.consume("operator");
+            const right = this.parseBinaryExpression(tokenPrecedence + 1);
+            if (token.value === "->") {
+                left = {
+                    type: "ArrowExpression",
+                    left, right,
+                    start: left.start,
+                    end: right.end
+                };
+                continue; // Skip
+            }
+            if (left.type === "Literal" && right.type === "Literal") {
+                const folded = this.tryFold(token.value, left.value, right.value);
+                if (folded !== undefined) {
+                    left = {
+                        type: "Literal",
+                        value: folded,
+                        start: left.start,
+                        end: right.end
+                    };
+                    continue; // keep parsing higher-precedence ops
+                }
+            }
+            left = {
+                type: "BinaryExpression",
+                operator: token.value,
+                left, right,
+                start: left.start,
+                end: right.end
+            };
+        }
+        return left;
+    }
+    tryFold(op, left, right) {
+        if (typeof left !== "number" || typeof right !== "number") {
+            return;
+        }
+        switch (op) {
+            case "+": return left + right;
+            case "-": return left - right;
+            case "*": return left * right;
+            case "/": return left / right;
+            case "<": return left < right;
+            case ">": return left > right;
+            case "<=": return left <= right;
+            case ">=": return left >= right;
+        }
+        return;
+    }
+    getOperatorPrecedence(operator) {
+        switch (operator) {
+            case "?": return -1; // handled outside binary parsing
+            case ":": return -1;
+            case "||": return 1;
+            case "&&": return 2;
+            case "??": return 0;
+            case "|": return 2;
+            case "^": return 3;
+            case "&": return 4;
+            case "==":
+            case "!=":
+            case "<":
+            case ">":
+            case "<=":
+            case ">=":
+                return 5;
+            case "<<":
+            case ">>":
+            case ">>>":
+                return 6;
+            case "+":
+            case "-":
+                return 7;
+            case "*":
+            case "/":
+                return 8;
+            case "->":
+                return 9;
+            default:
+                return -1;
+        }
+    }
+    parseConditionalExpression() {
+        const condition = this.parseBinaryExpression();
+        if (this.peek().type === "operator" &&
+            this.peek().value === "?") {
+            this.consume("operator"); // ?
+            const then = this.parseExpression();
+            // A ? B : C
+            if (this.peek().type === "operator" &&
+                this.peek().value === ":") {
+                this.consume("operator"); // :
+                const elseStmt = this.parseExpression();
+                return {
+                    type: "ConditionalExpression",
+                    condition,
+                    then,
+                    else: elseStmt,
+                    start: condition.start,
+                    end: elseStmt.end
+                };
+            }
+            // Binary condition (A ? B)
+            return {
+                type: "ConditionalExpression",
+                condition,
+                then,
+                start: condition.start,
+                end: then.end
+            };
+        }
+        return condition;
+    }
+    parsePrimaryExpression() {
+        return this.parseUnary();
+    }
+    parseUnary() {
+        const token = this.peek();
+        if (token.type === "operator" && (token.value === "-" || token.value === "!")) {
+            this.consume("operator");
+            const expr = this.parseUnary();
+            return {
+                type: "UnaryExpression",
+                operator: token.value,
+                expression: expr,
+                start: token.start,
+                end: expr.end
+            };
+        }
+        return this.parseAtom();
+    }
+    parseAtom() {
+        const token = this.peek();
+        if (token.type === "number") {
+            this.consume("number");
+            return {
+                type: "Literal",
+                value: Number(token.value),
+                start: token.start,
+                end: token.end
+            };
+        }
+        if (token.type === "string") {
+            this.consume("string");
+            return {
+                type: "Literal",
+                value: token.value.slice(1, -1),
+                start: token.start,
+                end: token.end
+            };
+        }
+        if (token.type === "bracket" && token.value === "[") {
+            const start = token.start;
+            this.consume("bracket");
+            const elements = [];
+            while (!(this.peek().type === "bracket" && this.peek().value === "]")) {
+                elements.push(this.parseExpression());
+                if (this.peek().type !== "comma") {
+                    break;
+                }
+                this.consume("comma");
+            }
+            const close = this.consume("bracket");
+            return {
+                type: "ArrayLiteral",
+                elements,
+                start, end: close.end
+            };
+        }
+        if (token.type === "identifier" && (token.value === "true" || token.value === "false")) {
+            this.consume("identifier");
+            return {
+                type: "Literal",
+                value: token.value === "true",
+                start: token.start,
+                end: token.end
+            };
+        }
+        if (token.type === "identifier") {
+            this.consume("identifier");
+            const path = MolangRuntime.normalizePath(token.value);
+            let expr = {
+                type: "Identifier",
+                name: token.value,
+                path,
+                start: token.start,
+                end: token.end
+            };
+            // Check if this is a function call
+            if (this.peek().type === "parenthesis" && this.peek().value === "(") {
+                this.consume("parenthesis");
+                const args = [];
+                while (true) {
+                    const next = this.peek();
+                    if (next.type === "eof") {
+                        throw new MolangParseError("Unclosed function call", token.start, this.input);
+                    }
+                    if (next.type === "parenthesis" && next.value === ")") {
+                        break;
+                    }
+                    if (next.type === "comma") {
+                        throw new MolangParseError(`Unexpected token ','`, next.start, this.input);
+                    }
+                    args.push(this.parseExpression());
+                    const afterArg = this.peek();
+                    if (afterArg.type === "comma") {
+                        this.consume("comma");
+                        const lookahead = this.peek();
+                        if (lookahead.type === "parenthesis" && lookahead.value === ")") {
+                            throw new MolangParseError(`Unexpected token ')'`, lookahead.start, this.input);
+                        }
+                    }
+                    else if (!(afterArg.type === "parenthesis" && afterArg.value === ")")) {
+                        throw new MolangParseError(`Unexpected token '${afterArg.value}'`, afterArg.start, this.input);
+                    }
+                }
+                this.consume("parenthesis");
+                expr = {
+                    type: "CallExpression",
+                    callee: expr,
+                    arguments: args,
+                    start: expr.start,
+                    end: this.tokens[this.position - 1].end
+                };
+            }
+            while (this.peek().type === "bracket" && this.peek().value === "[") {
+                this.consume("bracket");
+                const index = this.parseExpression();
+                const close = this.consume("bracket");
+                expr = {
+                    type: "IndexExpression",
+                    array: expr,
+                    index,
+                    start: expr.start,
+                    end: close.end
+                };
+            }
+            return expr;
+        }
+        if (token.type === "parenthesis" && token.value === "(") {
+            this.consume("parenthesis");
+            let expr = this.parseExpression();
+            this.consume("parenthesis");
+            while (this.peek().type === "bracket" && this.peek().value === "[") {
+                this.consume("bracket");
+                const index = this.parseExpression();
+                const close = this.consume("bracket");
+                expr = {
+                    type: "IndexExpression",
+                    array: expr,
+                    index,
+                    start: expr.start,
+                    end: close.end
+                };
+            }
+            return expr;
+        }
+        throw new Error(`Unexpected token: ${token.value}`);
+    }
+}

package/esm/runtime/context.d.ts

@@ -0,0 +1,19 @@
+export type MolangPrimitive = number | string | boolean;
+export type MolangArray = MolangPrimitive[];
+export type MolangValue = MolangPrimitive | MolangArray;
+export type MolangFunction = (...args: never[]) => unknown;
+export type MolangBinding = MolangValue | MolangFunction | MolangNamespace | undefined;
+export type MolangNamespace = {
+    [key: string]: MolangBinding;
+};
+export interface MolangContext extends MolangNamespace {
+    math?: MolangNamespace;
+    variable?: MolangNamespace;
+    temp?: MolangNamespace;
+    query?: MolangNamespace;
+    context?: MolangNamespace;
+}
+export declare const DEFAULT_CONTEXT: MolangContext;
+export declare function createMolangContext(initial?: MolangContext): MolangContext;
+export declare function isNamespace(value: unknown): value is MolangNamespace;
+export declare function mergeContext(base: MolangNamespace, user: MolangNamespace): MolangNamespace;

package/esm/runtime/context.js

@@ -0,0 +1,51 @@
+import { MolangMath } from "./math.js";
+import { PerlinNoise } from "@foxystar/math";
+;
+const PERLIN = new PerlinNoise();
+export const DEFAULT_CONTEXT = {
+    math: MolangMath,
+    variable: {},
+    temp: {},
+    context: {},
+    query: {
+        block_state: (_name) => {
+            throw new Error("This function call can only be used in block context");
+        },
+        noise: (x, y) => {
+            return PERLIN.noise({ x, y });
+        },
+    },
+};
+export function createMolangContext(initial) {
+    const ctx = mergeContext(DEFAULT_CONTEXT, initial ?? {});
+    ctx.variable = {
+        ...(initial?.variable ?? {}),
+    };
+    ctx.temp = {
+        ...(initial?.temp ?? {}),
+    };
+    return ctx;
+}
+const LOCKED_KEYS = new Set(["math"]);
+export function isNamespace(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function mergeContext(base, user) {
+    const out = Object.create(base);
+    for (const key in user) {
+        if (base === DEFAULT_CONTEXT && LOCKED_KEYS.has(key)) {
+            throw new Error(`Cannot override core Molang namespace '${key}'`);
+        }
+        const userValue = user[key];
+        const baseValue = base[key];
+        const baseIsNamespace = isNamespace(baseValue);
+        const userIsNamespace = isNamespace(userValue);
+        if (baseIsNamespace && userIsNamespace) {
+            out[key] = mergeContext(baseValue, userValue);
+        }
+        else {
+            out[key] = userValue;
+        }
+    }
+    return out;
+}

package/esm/runtime/math.d.ts

@@ -0,0 +1,32 @@
+export declare const MolangMath: {
+    pi: number;
+    abs: (x: number) => number;
+    ceil: (x: number) => number;
+    exp: (x: number) => number;
+    ln: (x: number) => number;
+    floor: (x: number) => number;
+    pow: (x: number, y: number) => number;
+    round: (x: number) => number;
+    sign: (x: number) => number;
+    sqrt: (x: number) => number;
+    trunc: (x: number) => number;
+    clamp: (value: number, min: number, max: number) => number;
+    max: (...values: number[]) => number;
+    min: (...values: number[]) => number;
+    cos: (v: number) => number;
+    acos: (v: number) => number;
+    sin: (v: number) => number;
+    asin: (v: number) => number;
+    atan: (v: number) => number;
+    atan2: (y: number, x: number) => number;
+    copy_sign: (x: number, y: number) => number;
+    random: (low: number, high: number) => number;
+    random_integer: (low: number, high: number) => number;
+    die_roll: (num: number, low: number, high: number) => number;
+    die_roll_integer: (num: number, low: number, high: number) => number;
+    hermite_blend: (t: number) => number;
+    lerp: (start: number, end: number, t: number) => number;
+    lerprotate: (start: number, end: number, t: number) => number;
+    min_angle: (value: number) => number;
+    mod: (value: number, denom: number) => number;
+};

package/esm/runtime/math.js

@@ -0,0 +1,89 @@
+import { XoroshiroRandom } from "@foxystar/math";
+const rng = new XoroshiroRandom();
+const DEG_TO_RAD = Math.PI / 180;
+const RAD_TO_DEG = 180 / Math.PI;
+function randomRange(low, high) {
+    return low + rng.nextDouble() * (high - low);
+}
+function randomIntRange(low, high) {
+    if (high < low) {
+        return low;
+    }
+    return low + rng.nextInt(high - low + 1);
+}
+export const MolangMath = {
+    pi: Math.PI,
+    abs: Math.abs,
+    ceil: Math.ceil,
+    exp: Math.exp,
+    ln: Math.log,
+    floor: Math.floor,
+    pow: Math.pow,
+    round: Math.round,
+    sign: Math.sign,
+    sqrt: Math.sqrt,
+    trunc: Math.trunc,
+    clamp: (value, min, max) => {
+        return Math.min(Math.max(value, min), max);
+    },
+    max: Math.max,
+    min: Math.min,
+    cos: (v) => {
+        return Math.cos(v * DEG_TO_RAD);
+    },
+    acos: (v) => {
+        return Math.acos(v) * RAD_TO_DEG;
+    },
+    sin: (v) => {
+        return Math.sin(v * DEG_TO_RAD);
+    },
+    asin: (v) => {
+        return Math.asin(v) * RAD_TO_DEG;
+    },
+    atan: (v) => {
+        return Math.atan(v) * RAD_TO_DEG;
+    },
+    atan2: (y, x) => {
+        return Math.atan2(y, x) * RAD_TO_DEG;
+    },
+    copy_sign: (x, y) => {
+        return Math.abs(x) * Math.sign(y);
+    },
+    random: (low, high) => {
+        return randomRange(low, high);
+    },
+    random_integer: (low, high) => {
+        return randomIntRange(low, high);
+    },
+    die_roll: (num, low, high) => {
+        let sum = 0;
+        for (let i = 0; i < num; i++) {
+            sum += randomRange(low, high);
+        }
+        return sum;
+    },
+    die_roll_integer: (num, low, high) => {
+        let sum = 0;
+        for (let i = 0; i < num; i++) {
+            sum += randomIntRange(low, high);
+        }
+        return sum;
+    },
+    hermite_blend: (t) => {
+        return 3 * t * t - 2 * t * t * t;
+    },
+    lerp: (start, end, t) => {
+        return start + (end - start) * t;
+    },
+    lerprotate: (start, end, t) => {
+        const diff = ((end - start + 540) % 360) - 180;
+        return start + diff * t;
+    },
+    min_angle: (value) => {
+        const angle = ((value + 180) % 360 + 360) % 360 - 180;
+        return angle;
+    },
+    mod: (value, denom) => {
+        return ((value % denom) + denom) % denom;
+    },
+};