ticbuild 1.0.0

package/dist/backend/luaPreprocessor.js

@@ -0,0 +1,862 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessLuaCode = preprocessLuaCode;
+const luaparse = __importStar(require("luaparse"));
+const fileSystem_1 = require("../utils/fileSystem");
+const lua_fundamentals_1 = require("../utils/lua/lua_fundamentals");
+const lua_utils_1 = require("../utils/lua/lua_utils");
+const cartLoader_1 = require("../utils/tic80/cartLoader");
+const codecRegistry_1 = require("../utils/encoding/codecRegistry");
+const luaBinaryEncoding_1 = require("./luaBinaryEncoding");
+const importUtils_1 = require("./importUtils");
+const manifestTypes_1 = require("./manifestTypes");
+async function preprocessLuaCode(project, source, filePath) {
+    const state = {
+        defines: new Map(),
+        dependencies: new Set(),
+        pragmaOnceKeys: new Set(),
+        includeStack: [],
+        macros: new Map(),
+    };
+    const includeKey = makeIncludeKey(filePath, {});
+    const rawCode = await processSource(project, source, filePath, includeKey, state, {});
+    const expandedCode = expandMacros(project, rawCode, state.macros, filePath);
+    const finalCode = await expandPreprocessorCalls(project, expandedCode, filePath, state);
+    return {
+        code: finalCode,
+        dependencies: Array.from(state.dependencies.values()),
+    };
+}
+async function processSource(project, source, filePath, includeKey, state, inputOverrides, trackDependency = true) {
+    if (state.pragmaOnceKeys.has(includeKey)) {
+        return "";
+    }
+    if (state.includeStack.includes(includeKey)) {
+        const cycle = [...state.includeStack, includeKey].join(" -> ");
+        throw new Error(`Lua preprocessor include cycle detected: ${cycle}`);
+    }
+    state.includeStack.push(includeKey);
+    if (trackDependency) {
+        state.dependencies.add(filePath);
+    }
+    const hasOverrides = Object.keys(inputOverrides).length > 0;
+    const localDefines = hasOverrides ? new Map(state.defines) : state.defines;
+    if (hasOverrides) {
+        for (const [key, value] of Object.entries(inputOverrides)) {
+            localDefines.set(key, value);
+        }
+    }
+    const conditionalStack = [];
+    const outputLines = [];
+    // helper to check if current line is in active conditional block
+    const isActive = () => {
+        if (conditionalStack.length === 0) {
+            return true;
+        }
+        return conditionalStack[conditionalStack.length - 1].active;
+    };
+    const lines = source.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNumber = i + 1;
+        const directiveMatch = line.match(/^\s*--#\s*(\w+)\s*(.*)$/);
+        if (!directiveMatch) {
+            if (isActive()) {
+                outputLines.push(line);
+            }
+            continue;
+        }
+        const directive = directiveMatch[1];
+        const rest = directiveMatch[2] || "";
+        switch (directive) {
+            case "macro": {
+                const macroHeader = parseMacroHeader(rest, filePath, lineNumber);
+                if (macroHeader.inlineBody !== undefined) {
+                    if (isActive()) {
+                        state.macros.set(macroHeader.name, {
+                            name: macroHeader.name,
+                            params: macroHeader.params,
+                            body: macroHeader.inlineBody,
+                            sourceFile: filePath,
+                            lineNumber,
+                        });
+                    }
+                    break;
+                }
+                const bodyResult = readMacroBody(lines, i + 1, filePath, lineNumber);
+                i = bodyResult.endIndex;
+                if (isActive()) {
+                    state.macros.set(macroHeader.name, {
+                        name: macroHeader.name,
+                        params: macroHeader.params,
+                        body: bodyResult.body,
+                        sourceFile: filePath,
+                        lineNumber,
+                    });
+                }
+                break;
+            }
+            case "endmacro": {
+                throw new Error(formatError(filePath, lineNumber, `--#endmacro without matching --#macro`));
+            }
+            case "define": {
+                if (!isActive()) {
+                    break;
+                }
+                const defineMatch = rest.match(/^([A-Za-z_][A-Za-z0-9_]*)(?:\s+(.*))?$/);
+                if (!defineMatch) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid --#define syntax: ${line}`));
+                }
+                const name = defineMatch[1];
+                const expr = defineMatch[2];
+                if (!expr || expr.trim() === "") {
+                    localDefines.set(name, true);
+                }
+                else {
+                    const value = evaluateExpression(parseExpression(expr, filePath, lineNumber), localDefines, filePath, lineNumber);
+                    localDefines.set(name, value);
+                }
+                break;
+            }
+            case "undef": {
+                if (!isActive()) {
+                    break;
+                }
+                const undefMatch = rest.match(/^([A-Za-z_][A-Za-z0-9_]*)$/);
+                if (!undefMatch) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid --#undef syntax: ${line}`));
+                }
+                localDefines.delete(undefMatch[1]);
+                break;
+            }
+            case "if": {
+                const parentActive = isActive();
+                let conditionMet = false;
+                if (parentActive) {
+                    if (!rest || rest.trim() === "") {
+                        throw new Error(formatError(filePath, lineNumber, `Missing expression in --#if`));
+                    }
+                    const exprValue = evaluateExpression(parseExpression(rest, filePath, lineNumber), localDefines, filePath, lineNumber);
+                    conditionMet = isTruthy(exprValue);
+                }
+                conditionalStack.push({
+                    parentActive,
+                    conditionMet,
+                    active: parentActive && conditionMet,
+                    hasElse: false,
+                });
+                break;
+            }
+            case "else": {
+                if (conditionalStack.length === 0) {
+                    throw new Error(formatError(filePath, lineNumber, `--#else without matching --#if`));
+                }
+                const top = conditionalStack[conditionalStack.length - 1];
+                if (top.hasElse) {
+                    throw new Error(formatError(filePath, lineNumber, `Duplicate --#else for same --#if`));
+                }
+                top.hasElse = true;
+                top.active = top.parentActive && !top.conditionMet;
+                break;
+            }
+            case "endif": {
+                if (conditionalStack.length === 0) {
+                    throw new Error(formatError(filePath, lineNumber, `--#endif without matching --#if`));
+                }
+                conditionalStack.pop();
+                break;
+            }
+            case "pragma": {
+                if (!isActive()) {
+                    break;
+                }
+                const pragmaMatch = rest.trim().match(/^(\w+)$/);
+                if (!pragmaMatch) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid --#pragma syntax: ${line}`));
+                }
+                if (pragmaMatch[1] === "once") {
+                    state.pragmaOnceKeys.add(includeKey);
+                }
+                else {
+                    throw new Error(formatError(filePath, lineNumber, `Unknown pragma: ${pragmaMatch[1]}`));
+                }
+                break;
+            }
+            case "include": {
+                if (!isActive()) {
+                    break;
+                }
+                const includeMatch = rest.trim().match(/^"([^"]+)"(.*)$/);
+                if (!includeMatch) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid --#include syntax: ${line}`));
+                }
+                const includeTarget = includeMatch[1];
+                const remainder = includeMatch[2] || "";
+                const overrides = parseWithOverrides(remainder, localDefines, filePath, lineNumber);
+                const includedText = await resolveInclude(project, includeTarget, filePath, overrides, state, lineNumber);
+                if (includedText) {
+                    outputLines.push(includedText);
+                }
+                break;
+            }
+            default:
+                throw new Error(formatError(filePath, lineNumber, `Unknown directive: --#${directive}`));
+        }
+    }
+    if (conditionalStack.length > 0) {
+        throw new Error(formatError(filePath, lines.length, `Unclosed --#if block`));
+    }
+    state.includeStack.pop();
+    return outputLines.join("\n");
+}
+async function resolveInclude(project, includeTarget, fromFile, overrides, state, lineNumber) {
+    if (includeTarget.startsWith("import:")) {
+        return await resolveImportInclude(project, includeTarget, overrides, state, lineNumber);
+    }
+    const substituted = project.substituteVariables(includeTarget);
+    let resolvedPath;
+    try {
+        resolvedPath = project.resolveIncludePath(substituted);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(formatError(fromFile, lineNumber, message));
+    }
+    const includeKey = makeIncludeKey(resolvedPath, overrides);
+    if (state.pragmaOnceKeys.has(includeKey)) {
+        return "";
+    }
+    const source = await (0, fileSystem_1.readTextFileAsync)(resolvedPath);
+    const included = await processSource(project, source, resolvedPath, includeKey, state, overrides);
+    return ensureTrailingNewline(included);
+}
+async function resolveImportInclude(project, includeTarget, overrides, state, lineNumber) {
+    const ref = (0, importUtils_1.parseImportReference)(includeTarget);
+    const importName = ref.importName;
+    const chunkSpec = ref.chunkSpec;
+    const importDef = project.manifest.imports.find((imp) => imp.name === importName);
+    if (!importDef) {
+        throw new Error(formatError("<include>", lineNumber, `Import not found: ${importName}`));
+    }
+    if (importDef.kind === manifestTypes_1.kImportKind.key.LuaCode) {
+        const resolvedPath = project.resolveImportPath(importDef);
+        const includeKey = makeIncludeKey(resolvedPath, overrides);
+        if (state.pragmaOnceKeys.has(includeKey)) {
+            return "";
+        }
+        const source = await (0, fileSystem_1.readTextFileAsync)(resolvedPath);
+        const included = await processSource(project, source, resolvedPath, includeKey, state, overrides);
+        return ensureTrailingNewline(included);
+    }
+    if (importDef.kind === manifestTypes_1.kImportKind.key.Tic80Cartridge) {
+        const resolvedPath = project.resolveImportPath(importDef);
+        const data = await (0, fileSystem_1.readBinaryFileAsync)(resolvedPath);
+        const cart = (0, cartLoader_1.parseTic80Cart)(data);
+        state.dependencies.add(resolvedPath);
+        const availableChunks = importDef.chunks && importDef.chunks.length > 0 ? importDef.chunks : cart.chunks.map((chunk) => chunk.chunkType);
+        const hasCode = availableChunks.includes("CODE");
+        if (!hasCode) {
+            throw new Error(formatError(resolvedPath, lineNumber, `No CODE chunk found in cart: ${importName}`));
+        }
+        let selectedChunk = "CODE";
+        if (chunkSpec) {
+            if (chunkSpec !== "CODE") {
+                throw new Error(formatError(resolvedPath, lineNumber, `Only CODE chunk is supported for include`));
+            }
+            selectedChunk = chunkSpec;
+            if (!availableChunks.includes(selectedChunk)) {
+                throw new Error(formatError(resolvedPath, lineNumber, `Requested chunk ${selectedChunk} not available in import`));
+            }
+        }
+        else if (availableChunks.length > 1) {
+            throw new Error(formatError(resolvedPath, lineNumber, `Import ${importName} contains multiple chunks. Specify :CODE explicitly in include.`));
+        }
+        const codeChunk = cart.chunks.find((chunk) => chunk.chunkType === selectedChunk);
+        if (!codeChunk) {
+            throw new Error(formatError(resolvedPath, lineNumber, `Requested chunk ${selectedChunk} not found in cart`));
+        }
+        const decoder = new TextDecoder("utf-8");
+        const source = decoder.decode(codeChunk.data);
+        const includeKey = makeIncludeKey(`${includeTarget}:${selectedChunk}`, overrides);
+        const included = await processSource(project, source, `${includeTarget}:${selectedChunk}`, includeKey, state, overrides, false);
+        return ensureTrailingNewline(included);
+    }
+    throw new Error(formatError("<include>", lineNumber, `Unsupported import kind: ${importDef.kind}`));
+}
+function parseWithOverrides(remainder, defines, filePath, lineNumber) {
+    const match = remainder.match(/\bwith\s*(\{[\s\S]*\})\s*(?:--.*)?$/);
+    if (!match) {
+        return {};
+    }
+    const tableText = match[1];
+    const expr = parseExpression(tableText, filePath, lineNumber);
+    if (expr.type !== "TableConstructorExpression") {
+        throw new Error(formatError(filePath, lineNumber, `Invalid with-clause expression`));
+    }
+    return evaluateTable(expr, defines, filePath, lineNumber);
+}
+function parseExpression(exprText, filePath, lineNumber) {
+    try {
+        const chunk = luaparse.parse(`return ${exprText}`);
+        if (chunk.body.length === 0 || chunk.body[0].type !== "ReturnStatement") {
+            throw new Error("Invalid expression");
+        }
+        const returnStmt = chunk.body[0];
+        if (returnStmt.arguments.length !== 1) {
+            throw new Error("Expected single expression");
+        }
+        return returnStmt.arguments[0];
+    }
+    catch (error) {
+        throw new Error(formatError(filePath, lineNumber, `Failed to parse expression: ${exprText}`));
+    }
+}
+// alternatively i could actually RUN the Lua but it's not trivial and would be slow.
+// turns out not to be so bad to just evaluate off the AST.
+function evaluateExpression(expr, defines, filePath, lineNumber) {
+    switch (expr.type) {
+        case "NumericLiteral":
+            return expr.value;
+        case "StringLiteral": {
+            const value = (0, lua_utils_1.stringValue)(expr);
+            if (value === null) {
+                throw new Error(formatError(filePath, lineNumber, `Invalid string literal`));
+            }
+            return value;
+        }
+        case "BooleanLiteral":
+            return expr.value;
+        case "Identifier": {
+            if (!defines.has(expr.name)) {
+                throw new Error(formatError(filePath, lineNumber, `Undefined preprocessor symbol: ${expr.name}`));
+            }
+            return defines.get(expr.name);
+        }
+        case "UnaryExpression": {
+            const arg = evaluateExpression(expr.argument, defines, filePath, lineNumber);
+            switch (expr.operator) {
+                case "not":
+                    return !isTruthy(arg);
+                case "-":
+                    return -asNumber(arg, filePath, lineNumber);
+                default:
+                    throw new Error(formatError(filePath, lineNumber, `Unsupported unary operator: ${expr.operator}`));
+            }
+        }
+        case "BinaryExpression": {
+            const left = evaluateExpression(expr.left, defines, filePath, lineNumber);
+            const right = evaluateExpression(expr.right, defines, filePath, lineNumber);
+            switch (expr.operator) {
+                case "+":
+                    return asNumber(left, filePath, lineNumber) + asNumber(right, filePath, lineNumber);
+                case "-":
+                    return asNumber(left, filePath, lineNumber) - asNumber(right, filePath, lineNumber);
+                case "*":
+                    return asNumber(left, filePath, lineNumber) * asNumber(right, filePath, lineNumber);
+                case "/":
+                    return asNumber(left, filePath, lineNumber) / asNumber(right, filePath, lineNumber);
+                case "%":
+                    return asNumber(left, filePath, lineNumber) % asNumber(right, filePath, lineNumber);
+                case "..":
+                    return String(left) + String(right);
+                case "==":
+                    return left === right;
+                case "~=":
+                    return left !== right;
+                case "<":
+                    return compareValues(left, right, filePath, lineNumber, (a, b) => a < b);
+                case "<=":
+                    return compareValues(left, right, filePath, lineNumber, (a, b) => a <= b);
+                case ">":
+                    return compareValues(left, right, filePath, lineNumber, (a, b) => a > b);
+                case ">=":
+                    return compareValues(left, right, filePath, lineNumber, (a, b) => a >= b);
+                default:
+                    throw new Error(formatError(filePath, lineNumber, `Unsupported binary operator: ${expr.operator}`));
+            }
+        }
+        case "LogicalExpression": {
+            const left = evaluateExpression(expr.left, defines, filePath, lineNumber);
+            if (expr.operator === "and") {
+                return isTruthy(left) ? evaluateExpression(expr.right, defines, filePath, lineNumber) : left;
+            }
+            if (expr.operator === "or") {
+                return isTruthy(left) ? left : evaluateExpression(expr.right, defines, filePath, lineNumber);
+            }
+            throw new Error(formatError(filePath, lineNumber, `Unsupported logical operator: ${expr.operator}`));
+        }
+        case "CallExpression": {
+            if (expr.base.type !== "Identifier" || expr.base.name !== "defined") {
+                throw new Error(formatError(filePath, lineNumber, `Unsupported function call in preprocessor expression`));
+            }
+            if (expr.arguments.length !== 1) {
+                throw new Error(formatError(filePath, lineNumber, `defined() expects exactly one argument`));
+            }
+            const arg = expr.arguments[0];
+            if (arg.type === "Identifier") {
+                return defines.has(arg.name);
+            }
+            if (arg.type === "StringLiteral") {
+                const value = (0, lua_utils_1.stringValue)(arg);
+                if (value === null) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid string literal in defined()`));
+                }
+                return defines.has(value);
+            }
+            throw new Error(formatError(filePath, lineNumber, `defined() argument must be an identifier or string literal`));
+        }
+        default:
+            throw new Error(formatError(filePath, lineNumber, `Unsupported expression type: ${expr.type}`));
+    }
+}
+// evaluates a table constructor expression into a key-value map
+// used for with-clause parsing in include directives
+function evaluateTable(expr, defines, filePath, lineNumber) {
+    const result = {};
+    for (const field of expr.fields) {
+        switch (field.type) {
+            case "TableKeyString": {
+                const key = field.key.name;
+                const value = evaluateExpression(field.value, defines, filePath, lineNumber);
+                result[key] = value;
+                break;
+            }
+            case "TableKey": {
+                if (field.key.type !== "StringLiteral") {
+                    throw new Error(formatError(filePath, lineNumber, `Only string keys are supported in with-clause`));
+                }
+                const key = (0, lua_utils_1.stringValue)(field.key);
+                if (key === null) {
+                    throw new Error(formatError(filePath, lineNumber, `Invalid string key in with-clause`));
+                }
+                const value = evaluateExpression(field.value, defines, filePath, lineNumber);
+                result[key] = value;
+                break;
+            }
+            default:
+                throw new Error(formatError(filePath, lineNumber, `Unsupported with-clause field type: ${field.type}`));
+        }
+    }
+    return result;
+}
+function compareValues(left, right, filePath, lineNumber, comparator) {
+    if (typeof left === "number" && typeof right === "number") {
+        return comparator(left, right);
+    }
+    if (typeof left === "string" && typeof right === "string") {
+        return comparator(left, right);
+    }
+    throw new Error(formatError(filePath, lineNumber, `Comparison requires both values to be numbers or strings`));
+}
+// ensures the value is a number; throws otherwise
+// used in expression evaluation
+function asNumber(value, filePath, lineNumber) {
+    if (typeof value !== "number") {
+        throw new Error(formatError(filePath, lineNumber, `Expected number but got ${typeof value}`));
+    }
+    return value;
+}
+function isTruthy(value) {
+    return value !== false;
+}
+function ensureTrailingNewline(text) {
+    if (!text.endsWith("\n")) {
+        return text + "\n";
+    }
+    return text;
+}
+// unique key for an include based on file path and overrides
+// used for pragma once and cycle detection
+function makeIncludeKey(filePath, overrides) {
+    const keys = Object.keys(overrides).sort();
+    if (keys.length === 0) {
+        return filePath;
+    }
+    const serialized = keys.map((key) => `${key}=${String(overrides[key])}`).join(";");
+    return `${filePath}::${serialized}`;
+}
+function formatError(filePath, lineNumber, message) {
+    return `[LuaPreprocessor] ${filePath}:${lineNumber} ${message}`;
+}
+function parseMacroHeader(rest, filePath, lineNumber) {
+    const headerMatch = rest.trim().match(/^([A-Za-z_][A-Za-z0-9_]*)(\s*\(([^)]*)\))?\s*(?:=>\s*(.*))?$/);
+    if (!headerMatch) {
+        throw new Error(formatError(filePath, lineNumber, `Invalid --#macro syntax: ${rest}`));
+    }
+    const name = headerMatch[1];
+    const paramList = headerMatch[3];
+    const inlineBody = headerMatch[4];
+    const params = paramList
+        ? paramList
+            .split(",")
+            .map((p) => p.trim())
+            .filter((p) => p.length > 0)
+        : [];
+    return {
+        name,
+        params,
+        inlineBody: inlineBody !== undefined ? inlineBody.trim() : undefined,
+    };
+}
+function readMacroBody(lines, startIndex, filePath, lineNumber) {
+    const bodyLines = [];
+    for (let i = startIndex; i < lines.length; i++) {
+        const line = lines[i];
+        const match = line.match(/^\s*--#\s*(\w+)\s*(.*)$/);
+        if (match) {
+            if (match[1] === "endmacro") {
+                return { body: bodyLines.join("\n"), endIndex: i };
+            }
+            if (match[1] === "macro") {
+                throw new Error(formatError(filePath, lineNumber, `Nested --#macro is not supported`));
+            }
+        }
+        bodyLines.push(line);
+    }
+    throw new Error(formatError(filePath, lineNumber, `Unclosed --#macro block`));
+}
+function expandMacros(project, code, macros, filePath) {
+    if (macros.size === 0) {
+        return code;
+    }
+    let current = code;
+    const maxPasses = 25;
+    for (let pass = 0; pass < maxPasses; pass++) {
+        const result = applyMacroPass(project, current, macros, filePath);
+        if (!result.changed) {
+            return current;
+        }
+        current = result.code;
+    }
+    throw new Error(formatError(filePath, 1, `Macro expansion exceeded ${maxPasses} passes (possible recursion)`));
+}
+function applyMacroPass(project, code, macros, filePath) {
+    const chunk = luaparse.parse(code, { ranges: true, locations: true });
+    const replacements = [];
+    walkLuaAst(chunk, (node, parent) => {
+        if (node.type !== "CallExpression") {
+            return;
+        }
+        const callNode = node;
+        if (callNode.base.type !== "Identifier") {
+            return;
+        }
+        const macroDef = macros.get(callNode.base.name);
+        if (!macroDef) {
+            return;
+        }
+        const range = getRange(callNode, filePath);
+        const lineNumber = getLineNumber(callNode, 1);
+        const args = callNode.arguments || [];
+        if (args.length !== macroDef.params.length) {
+            throw new Error(formatError(filePath, lineNumber, `Macro ${macroDef.name} expects ${macroDef.params.length} args but got ${args.length}`));
+        }
+        const argTexts = args.map((arg) => sliceRange(code, getRange(arg, filePath)));
+        const expanded = expandMacroBody(project, macroDef, argTexts, filePath, lineNumber);
+        replacements.push({ start: range[0], end: range[1], text: expanded });
+    });
+    if (replacements.length === 0) {
+        return { code, changed: false };
+    }
+    const sorted = replacements.sort((a, b) => b.start - a.start);
+    let out = code;
+    for (const rep of sorted) {
+        out = out.slice(0, rep.start) + rep.text + out.slice(rep.end);
+    }
+    return { code: out, changed: true };
+}
+function expandMacroBody(project, macro, argTexts, filePath, lineNumber) {
+    if (macro.params.length === 0) {
+        return wrapMacroBody(macro.body);
+    }
+    const parsed = parseExpressionWithRanges(macro.body, macro.sourceFile, macro.lineNumber);
+    const offset = "return ".length;
+    const replacements = [];
+    walkLuaAst(parsed, (node, parent) => {
+        if (node.type !== "Identifier") {
+            return;
+        }
+        if (isIdentifierKeyPosition(node, parent)) {
+            return;
+        }
+        const index = macro.params.indexOf(node.name);
+        if (index < 0) {
+            return;
+        }
+        const range = getRange(node, macro.sourceFile);
+        replacements.push({
+            start: range[0] - offset,
+            end: range[1] - offset,
+            text: `(${argTexts[index]})`,
+        });
+    });
+    if (replacements.length === 0) {
+        return wrapMacroBody(macro.body);
+    }
+    const sorted = replacements.sort((a, b) => b.start - a.start);
+    let out = macro.body;
+    for (const rep of sorted) {
+        out = out.slice(0, rep.start) + rep.text + out.slice(rep.end);
+    }
+    return wrapMacroBody(out);
+}
+function wrapMacroBody(body) {
+    const trimmed = body.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    return `(${trimmed})`;
+}
+async function expandPreprocessorCalls(project, code, filePath, state) {
+    const chunk = luaparse.parse(code, { ranges: true, locations: true });
+    const replacements = [];
+    const tasks = [];
+    const addReplacement = (node, text) => {
+        const range = getRange(node, filePath);
+        replacements.push({ start: range[0], end: range[1], text });
+    };
+    const getStringLiteralArg = (callNode, index, fnName) => {
+        const lineNumber = getLineNumber(callNode, 1);
+        const arg = callNode.arguments[index];
+        if (!arg || arg.type !== "StringLiteral") {
+            throw new Error(formatError(filePath, lineNumber, `${fnName} argument ${index + 1} must be a string literal`));
+        }
+        const rawValue = (0, lua_utils_1.stringValue)(arg);
+        if (rawValue === null) {
+            throw new Error(formatError(filePath, lineNumber, `Invalid string literal in ${fnName}`));
+        }
+        return { value: rawValue, lineNumber };
+    };
+    const resolveImportDefinition = (importName, lineNumber) => {
+        const importDef = project.manifest.imports.find((imp) => imp.name === importName);
+        if (!importDef) {
+            throw new Error(formatError(filePath, lineNumber, `Import not found: ${importName}`));
+        }
+        return importDef;
+    };
+    walkLuaAst(chunk, (node) => {
+        if (node.type !== "CallExpression") {
+            return;
+        }
+        const callNode = node;
+        if (callNode.base.type !== "Identifier") {
+            return;
+        }
+        const fnName = callNode.base.name;
+        if (fnName === "__EXPAND") {
+            tasks.push((async () => {
+                const lineNumber = getLineNumber(callNode, 1);
+                if (callNode.arguments.length !== 1) {
+                    throw new Error(formatError(filePath, lineNumber, `__EXPAND expects exactly one argument`));
+                }
+                const arg = getStringLiteralArg(callNode, 0, "__EXPAND");
+                const substituted = project.substituteVariables(arg.value);
+                const literal = (0, lua_fundamentals_1.toLuaStringLiteral)(substituted);
+                addReplacement(callNode, literal);
+            })());
+            return;
+        }
+        if (fnName === "__IMPORTTEXT") {
+            tasks.push((async () => {
+                const lineNumber = getLineNumber(callNode, 1);
+                if (callNode.arguments.length !== 1) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTTEXT expects exactly one argument`));
+                }
+                const arg = getStringLiteralArg(callNode, 0, "__IMPORTTEXT");
+                const substituted = project.substituteVariables(arg.value);
+                if (!substituted.startsWith("import:")) {
+                    addReplacement(callNode, (0, lua_fundamentals_1.toLuaStringLiteral)(substituted));
+                    return;
+                }
+                const ref = (0, importUtils_1.parseImportReference)(substituted);
+                if (ref.chunkSpec) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTTEXT does not support chunk specifiers`));
+                }
+                const importDef = resolveImportDefinition(ref.importName, lineNumber);
+                if (importDef.kind !== manifestTypes_1.kImportKind.key.text) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTTEXT requires a text import`));
+                }
+                const result = await (0, importUtils_1.loadTextImportData)(project, importDef);
+                for (const dep of result.dependencies) {
+                    state.dependencies.add(dep);
+                }
+                addReplacement(callNode, (0, lua_fundamentals_1.toLuaStringLiteral)(result.data));
+            })());
+            return;
+        }
+        if (fnName === "__IMPORTBIN") {
+            tasks.push((async () => {
+                const lineNumber = getLineNumber(callNode, 1);
+                if (callNode.arguments.length !== 2) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTBIN expects exactly two arguments`));
+                }
+                const encodingArg = getStringLiteralArg(callNode, 0, "__IMPORTBIN");
+                const importArg = getStringLiteralArg(callNode, 1, "__IMPORTBIN");
+                const encoding = (0, luaBinaryEncoding_1.normalizeBinaryOutputEncoding)(project.substituteVariables(encodingArg.value));
+                const importSpec = project.substituteVariables(importArg.value);
+                if (!importSpec.startsWith("import:")) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTBIN requires an import reference`));
+                }
+                const ref = (0, importUtils_1.parseImportReference)(importSpec);
+                if (ref.chunkSpec) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTBIN does not support chunk specifiers`));
+                }
+                const importDef = resolveImportDefinition(ref.importName, lineNumber);
+                if (importDef.kind !== manifestTypes_1.kImportKind.key.binary) {
+                    throw new Error(formatError(filePath, lineNumber, `__IMPORTBIN requires a binary import`));
+                }
+                const result = await (0, importUtils_1.loadBinaryImportData)(project, importDef);
+                for (const dep of result.dependencies) {
+                    state.dependencies.add(dep);
+                }
+                const literal = (0, luaBinaryEncoding_1.encodeBinaryAsLuaLiteral)(result.data, encoding);
+                addReplacement(callNode, literal);
+            })());
+            return;
+        }
+        if (fnName === "__ENCODE") {
+            tasks.push((async () => {
+                const lineNumber = getLineNumber(callNode, 1);
+                if (callNode.arguments.length !== 3) {
+                    throw new Error(formatError(filePath, lineNumber, `__ENCODE expects exactly three arguments`));
+                }
+                const sourceEncodingArg = getStringLiteralArg(callNode, 0, "__ENCODE");
+                const outputEncodingArg = getStringLiteralArg(callNode, 1, "__ENCODE");
+                const valueArg = getStringLiteralArg(callNode, 2, "__ENCODE");
+                const sourceEncodingRaw = project.substituteVariables(sourceEncodingArg.value).trim().toLowerCase();
+                const sourceEncoding = (0, codecRegistry_1.resolveSourceEncoding)(sourceEncodingRaw).key;
+                if (!(0, codecRegistry_1.isStringSourceEncoding)(sourceEncoding)) {
+                    throw new Error(formatError(filePath, lineNumber, `__ENCODE only supports string-based source encodings`));
+                }
+                const outputEncoding = (0, luaBinaryEncoding_1.normalizeBinaryOutputEncoding)(project.substituteVariables(outputEncodingArg.value));
+                const sourceValue = project.substituteVariables(valueArg.value);
+                if (sourceValue.startsWith("import:")) {
+                    console.warn(formatError(filePath, lineNumber, `__ENCODE used with import reference; use __IMPORTBIN`));
+                }
+                const data = (0, codecRegistry_1.decodeSourceDataFromString)(sourceEncoding, sourceValue);
+                const literal = (0, luaBinaryEncoding_1.encodeBinaryAsLuaLiteral)(data, outputEncoding);
+                addReplacement(callNode, literal);
+            })());
+        }
+    });
+    if (tasks.length === 0) {
+        return code;
+    }
+    await Promise.all(tasks);
+    if (replacements.length === 0) {
+        return code;
+    }
+    const sorted = replacements.sort((a, b) => b.start - a.start);
+    let out = code;
+    for (const rep of sorted) {
+        out = out.slice(0, rep.start) + rep.text + out.slice(rep.end);
+    }
+    return out;
+}
+function parseExpressionWithRanges(body, filePath, lineNumber) {
+    try {
+        const chunk = luaparse.parse(`return ${body}`, { ranges: true, locations: true });
+        if (chunk.body.length === 0 || chunk.body[0].type !== "ReturnStatement") {
+            throw new Error("Invalid expression");
+        }
+        const returnStmt = chunk.body[0];
+        if (returnStmt.arguments.length !== 1) {
+            throw new Error("Expected single expression");
+        }
+        return returnStmt.arguments[0];
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(formatError(filePath, lineNumber, `Failed to parse macro body: ${message}`));
+    }
+}
+function getRange(node, filePath) {
+    const withRange = node;
+    if (!withRange.range) {
+        throw new Error(formatError(filePath, 1, `Missing range for Lua node`));
+    }
+    return withRange.range;
+}
+function getLineNumber(node, fallback) {
+    const withLoc = node;
+    return withLoc.loc?.start.line ?? fallback;
+}
+function sliceRange(source, range) {
+    return source.slice(range[0], range[1]);
+}
+function walkLuaAst(node, visit, parent = null) {
+    if (!isLuaNode(node)) {
+        return;
+    }
+    visit(node, parent);
+    const record = node;
+    for (const value of Object.values(record)) {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                walkLuaAst(item, visit, node);
+            }
+        }
+        else if (isLuaNode(value)) {
+            walkLuaAst(value, visit, node);
+        }
+    }
+}
+function isLuaNode(value) {
+    if (typeof value !== "object" || value === null) {
+        return false;
+    }
+    const record = value;
+    return typeof record.type === "string";
+}
+function isIdentifierKeyPosition(node, parent) {
+    if (!parent) {
+        return false;
+    }
+    if (parent.type === "TableKeyString") {
+        const tableKey = parent;
+        return tableKey.key === node;
+    }
+    if (parent.type === "TableKey") {
+        const tableKey = parent;
+        return tableKey.key === node;
+    }
+    if (parent.type === "MemberExpression") {
+        const member = parent;
+        return member.identifier === node;
+    }
+    return false;
+}
+//# sourceMappingURL=luaPreprocessor.js.map