@foxystar/molang 0.1.0

package/script/diagnostics/error.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MolangRuntimeError = exports.MolangParseError = void 0;
+class MolangError extends Error {
+    constructor(message, start, end, source) {
+        super(MolangError.formatError(message, start, end, source));
+        this.name = this.constructor.name;
+    }
+    static formatError(message, pos, end, src) {
+        let line = 1;
+        let lastLineStart = 0;
+        for (let i = 0; i < pos; i++) {
+            if (src[i] === "\n") {
+                line++;
+                lastLineStart = i + 1;
+            }
+        }
+        const column = pos - lastLineStart + 1;
+        const lines = src.split("\n");
+        const lineText = lines[line - 1] ?? "";
+        //const pointer = " ".repeat(column - 1) + "^";
+        const span = Math.max(1, end - pos);
+        const underlineLength = Math.min(span, Math.max(1, lineText.length - column + 1));
+        const pointer = " ".repeat(column - 1) +
+            "^".repeat(underlineLength);
+        return (`${message} at line ${line - 1}, column ${column}\n` +
+            `${lineText}\n` +
+            `${pointer}`);
+    }
+}
+class MolangParseError extends MolangError {
+    constructor(message, position, source) {
+        super(message, position, position + 1, source);
+    }
+}
+exports.MolangParseError = MolangParseError;
+class MolangRuntimeError extends MolangError {
+    constructor(message, expr, source) {
+        super(message, expr.start, expr.end, source);
+    }
+}
+exports.MolangRuntimeError = MolangRuntimeError;

package/script/diagnostics/suggestions.d.ts

@@ -0,0 +1,2 @@
+export declare function levenshtein(a: string, b: string): number;
+export declare function findBestMatch(name: string, candidates: string[]): string | null;

package/script/diagnostics/suggestions.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findBestMatch = exports.levenshtein = void 0;
+function levenshtein(a, b) {
+    const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = 0; i <= a.length; i++) {
+        dp[i][0] = i;
+    }
+    for (let j = 0; j <= b.length; j++) {
+        dp[0][j] = j;
+    }
+    for (let i = 1; i <= a.length; i++) {
+        for (let j = 1; j <= b.length; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, // deletion
+            dp[i][j - 1] + 1, // insertion
+            dp[i - 1][j - 1] + cost // substitution
+            );
+        }
+    }
+    return dp[a.length][b.length];
+}
+exports.levenshtein = levenshtein;
+function findBestMatch(name, candidates) {
+    let best = null;
+    let bestScore = Infinity;
+    for (const c of candidates) {
+        const d = levenshtein(name.toLowerCase(), c.toLowerCase());
+        if (d < bestScore) {
+            bestScore = d;
+            best = c;
+        }
+    }
+    // Heuristic: only suggest if it's "close enough"
+    if (best !== null && bestScore <= 2) {
+        return best;
+    }
+    return null;
+}
+exports.findBestMatch = findBestMatch;

package/script/index.d.ts

@@ -0,0 +1,8 @@
+export { evaluate } from "./molang.js";
+export { MolangParser } from "./parser/parser.js";
+export type { Expr, ExprBase, Program, Statement, Token, TokenType } from "./parser/expression.js";
+export * from "./runtime/context.js";
+export { MolangMath } from "./runtime/math.js";
+export { MolangRuntime } from "./runtime/runtime.js";
+export type { MolangOptions } from "./runtime/runtime.js";
+export * from "./diagnostics/error.js";

package/script/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MolangRuntime = exports.MolangMath = exports.MolangParser = exports.evaluate = void 0;
+var molang_js_1 = require("./molang.js");
+Object.defineProperty(exports, "evaluate", { enumerable: true, get: function () { return molang_js_1.evaluate; } });
+var parser_js_1 = require("./parser/parser.js");
+Object.defineProperty(exports, "MolangParser", { enumerable: true, get: function () { return parser_js_1.MolangParser; } });
+__exportStar(require("./runtime/context.js"), exports);
+var math_js_1 = require("./runtime/math.js");
+Object.defineProperty(exports, "MolangMath", { enumerable: true, get: function () { return math_js_1.MolangMath; } });
+var runtime_js_1 = require("./runtime/runtime.js");
+Object.defineProperty(exports, "MolangRuntime", { enumerable: true, get: function () { return runtime_js_1.MolangRuntime; } });
+__exportStar(require("./diagnostics/error.js"), exports);

package/script/molang.d.ts

@@ -0,0 +1,2 @@
+import { MolangContext } from "./runtime/context.js";
+export declare function evaluate(input: string, context?: MolangContext): unknown;

package/script/molang.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluate = void 0;
+const parser_js_1 = require("./parser/parser.js");
+const runtime_js_1 = require("./runtime/runtime.js");
+const context_js_1 = require("./runtime/context.js");
+const LRUCache_js_1 = __importDefault(require("./LRUCache.js"));
+const MAX_CACHE_SIZE = 2048;
+const cache = new LRUCache_js_1.default(MAX_CACHE_SIZE);
+function evaluate(input, context = {}) {
+    if (context === context_js_1.DEFAULT_CONTEXT) {
+        context = (0, context_js_1.mergeContext)(context_js_1.DEFAULT_CONTEXT, {});
+    }
+    else if (!Object.prototype.isPrototypeOf.call(context_js_1.DEFAULT_CONTEXT, context)) {
+        Object.setPrototypeOf(context, context_js_1.DEFAULT_CONTEXT);
+    }
+    let program = cache.get(input);
+    if (!program) {
+        const parser = new parser_js_1.MolangParser(input);
+        program = parser.parseProgram();
+        cache.set(input, program);
+    }
+    const runtime = new runtime_js_1.MolangRuntime(context, input, { strict: false });
+    return runtime.evaluateProgram(program);
+}
+exports.evaluate = evaluate;

package/script/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/script/parser/expression.d.ts

@@ -0,0 +1,87 @@
+export declare const TOKEN_REGEX: RegExp;
+export type ExprBase = {
+    start: number;
+    end: number;
+};
+export type Expr = ({
+    type: "Literal";
+    value: unknown;
+} & ExprBase) | ({
+    type: "Identifier";
+    name: string;
+    path: string[];
+} & ExprBase) | ({
+    type: "BinaryExpression";
+    operator: string;
+    left: Expr;
+    right: Expr;
+} & ExprBase) | ({
+    type: "CallExpression";
+    callee: Expr;
+    arguments: Expr[];
+} & ExprBase) | ({
+    type: "UnaryExpression";
+    operator: string;
+    expression: Expr;
+} & ExprBase) | ({
+    type: "ArrayLiteral";
+    elements: Expr[];
+} & ExprBase) | ({
+    type: "IndexExpression";
+    array: Expr;
+    index: Expr;
+} & ExprBase) | ({
+    type: "ArrowExpression";
+    left: Expr;
+    right: Expr;
+} & ExprBase) | ({
+    type: "ConditionalExpression";
+    condition: Expr;
+    then: Expr;
+    else?: Expr;
+} & ExprBase);
+export type Statement = ({
+    type: "ExprStatement";
+    expr: Expr;
+} & ExprBase) | ({
+    type: "AssignStatement";
+    target: Expr;
+    value: Expr;
+} & ExprBase) | ({
+    type: "ReturnStatement";
+    value?: Expr;
+} & ExprBase) | ({
+    type: "BreakStatement";
+} & ExprBase) | ({
+    type: "ContinueStatement";
+} & ExprBase) | ({
+    type: "LoopStatement";
+    count: Expr;
+    body: Statement;
+} & ExprBase) | ({
+    type: "ForEachStatement";
+    iterator: Expr;
+    iterable: Expr;
+    body: Statement;
+} & ExprBase) | ({
+    type: "ConditionalStatement";
+    condition: Expr;
+    then: Statement;
+    else?: Statement;
+} & ExprBase) | ({
+    type: "BlockStatement";
+    body: Statement[];
+} & ExprBase);
+export type Program = {
+    type: "Program";
+    body: Statement[];
+    start: number;
+    end: number;
+};
+export type TokenType = "number" | "string" | "identifier" | "assignment" | "operator" | "parenthesis" | "brace" | "comma" | "bracket" | "semicolon" | "eof";
+export type Token = {
+    type: TokenType;
+    value: string;
+    start: number;
+    end: number;
+};

package/script/parser/expression.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOKEN_REGEX = void 0;
+exports.TOKEN_REGEX = new RegExp([
+    // number
+    "^(?<number>-?\\d+(?:\\.\\d+)?)",
+    // string (double OR single quotes)
+    "(?<string>\"[^\"]*\"|'[^']*')",
+    // identifier + dotted path
+    "(?<identifier>[a-zA-Z_][a-zA-Z0-9_]*(?:\\.[a-zA-Z_][a-zA-Z0-9_]*)*)",
+    "(?<assignment>=(?!=))",
+    "(?<operator>\\?\\?|->|>>>|>>|<<|\\|\\||&&|==|!=|<=|>=|\\^|\\||&|\\?|:|[+\\-*/<>!])",
+    // grouping
+    "(?<parenthesis>[()])",
+    "(?<bracket>[\\[\\]])",
+    "(?<brace>[{}])",
+    // punctuation
+    "(?<comma>,)",
+    "(?<semicolon>;)",
+    // whitespace
+    "(?<whitespace>\\s+)"
+].join("|^"));

package/script/parser/parser.d.ts

@@ -0,0 +1,20 @@
+import { Program } from "./expression.js";
+export declare class MolangParser {
+    private input;
+    private tokens;
+    private position;
+    constructor(input: string);
+    private tokenize;
+    private peek;
+    private consume;
+    parseProgram(): Program;
+    private parseStatement;
+    private parseExpression;
+    private parseBinaryExpression;
+    private tryFold;
+    private getOperatorPrecedence;
+    private parseConditionalExpression;
+    private parsePrimaryExpression;
+    private parseUnary;
+    private parseAtom;
+}