ticbuild 1.0.0

package/dist/utils/lua/lua_processor.js

@@ -0,0 +1,1153 @@
+"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.LuaPrinter = void 0;
+exports.unparseLua = unparseLua;
+exports.parseLua = parseLua;
+exports.processLua = processLua;
+const luaparse = __importStar(require("luaparse"));
+const lua_renamer_1 = require("./lua_renamer");
+const lua_alias_literals_1 = require("./lua_alias_literals");
+const lua_alias_expressions_1 = require("./lua_alias_expressions");
+const lua_pack_locals_1 = require("./lua_pack_locals");
+const lua_simplify_1 = require("./lua_simplify");
+const lua_remove_unused_locals_1 = require("./lua_remove_unused_locals");
+const lua_remove_unused_functions_1 = require("./lua_remove_unused_functions");
+const lua_rename_table_fields_1 = require("./lua_rename_table_fields");
+const lua_rename_allowed_table_keys_1 = require("./lua_rename_allowed_table_keys");
+const lua_fundamentals_1 = require("./lua_fundamentals");
+// Precedence tables, low → high
+const LOGICAL_PRECEDENCE = {
+    or: 1,
+    and: 2,
+};
+const BINARY_PRECEDENCE = {
+    "<": 3,
+    ">": 3,
+    "<=": 3,
+    ">=": 3,
+    "~=": 3,
+    "==": 3,
+    "|": 4,
+    "~": 5,
+    "&": 6,
+    "<<": 7,
+    ">>": 7,
+    "..": 8, // right associative
+    "+": 9,
+    "-": 9,
+    "*": 10,
+    "/": 10,
+    "//": 10,
+    "%": 10,
+};
+const UNARY_PRECEDENCE = 11; // not, #, -, ~
+const POW_PRECEDENCE = 12; // ^
+function getPrecedence(node) {
+    switch (node.type) {
+        case "LogicalExpression":
+            return LOGICAL_PRECEDENCE[node.operator];
+        case "BinaryExpression": {
+            const op = node.operator;
+            if (op === "^")
+                return POW_PRECEDENCE;
+            return BINARY_PRECEDENCE[op];
+        }
+        case "UnaryExpression":
+            return UNARY_PRECEDENCE;
+        default:
+            // Primary expressions (literals, identifiers, calls, table ctors, etc.)
+            return 100;
+    }
+}
+class LuaPrinter {
+    constructor(options, blockComments) {
+        this.buf = [];
+        this.indentLevel = 0;
+        this.indentUnit = " "; // only used if !minified
+        this.currentLine = "";
+        this.inlineMode = false; // When true, render everything on single lines without packing
+        this.options = options;
+        this.blockComments = blockComments || new Map();
+    }
+    print(chunk) {
+        const mode = this.options.lineBehavior || "pretty";
+        // For tight mode, use the token-stream approach
+        if (mode === "tight") {
+            return this.printTightMode(chunk);
+        }
+        // For pretty and single-line-blocks, use structured approach
+        this.buf = [];
+        this.currentLine = "";
+        this.indentLevel = 0;
+        this.printBlock(chunk.body);
+        if (this.currentLine.length > 0)
+            this.flushLine();
+        return this.buf.join("");
+    }
+    // ===== TIGHT MODE: Token-stream based packing =====
+    // Renders everything to space-separated tokens, then packs into lines
+    printTightMode(chunk) {
+        const tokens = this.collectTokens(chunk.body);
+        return this.packTokensIntoLines(tokens);
+    }
+    // Collect all tokens from a block of statements
+    collectTokens(body) {
+        const comments = [...(this.blockComments.get(body) || [])];
+        const items = [];
+        let ci = 0;
+        for (const stmt of body) {
+            while (ci < comments.length && this.startPos(comments[ci]) <= this.startPos(stmt)) {
+                items.push(comments[ci]);
+                ci++;
+            }
+            items.push(stmt);
+        }
+        while (ci < comments.length) {
+            items.push(comments[ci]);
+            ci++;
+        }
+        const tokens = [];
+        for (const node of items) {
+            if (node.type === "Comment") {
+                // Comments get special handling - they force a line break
+                tokens.push("\n" + this.renderComment(node));
+            }
+            else {
+                const stmtTokens = this.statementToTokens(node);
+                tokens.push(...stmtTokens);
+            }
+        }
+        return tokens;
+    }
+    // Convert a statement to tokens (space-separated pieces)
+    // For maximum packing flexibility, we separate keywords from their arguments
+    statementToTokens(stmt) {
+        const tokens = [];
+        switch (stmt.type) {
+            case "AssignmentStatement": {
+                const st = stmt;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                const vals = st.init.map((v) => this.expr(v)).join(",");
+                tokens.push(vars + "=" + vals);
+                break;
+            }
+            case "LocalStatement": {
+                const st = stmt;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                let s = "local " + vars;
+                if (st.init && st.init.length > 0) {
+                    s += "=" + st.init.map((v) => this.expr(v)).join(",");
+                }
+                tokens.push(s);
+                break;
+            }
+            case "CallStatement": {
+                const st = stmt;
+                tokens.push(this.expr(st.expression));
+                break;
+            }
+            case "ReturnStatement": {
+                const st = stmt;
+                if (st.arguments.length > 0) {
+                    // Keep return with all its comma-separated arguments as one token
+                    // to preserve required commas between multiple return values
+                    tokens.push("return " + st.arguments.map((a) => this.expr(a)).join(","));
+                }
+                else {
+                    tokens.push("return");
+                }
+                break;
+            }
+            case "BreakStatement":
+                tokens.push("break");
+                break;
+            case "FunctionDeclaration": {
+                const fn = stmt;
+                let s = fn.isLocal ? "local function " : "function ";
+                if (fn.identifier) {
+                    s += this.expr(fn.identifier);
+                }
+                s += "(" + fn.parameters.map((p) => this.expr(p)).join(",") + ")";
+                tokens.push(s);
+                tokens.push(...this.collectTokens(fn.body));
+                tokens.push("end");
+                break;
+            }
+            case "IfStatement": {
+                const ifs = stmt;
+                for (const clause of ifs.clauses) {
+                    if (clause.type === "IfClause") {
+                        tokens.push("if " + this.expr(clause.condition) + " then");
+                    }
+                    else if (clause.type === "ElseifClause") {
+                        tokens.push("elseif " + this.expr(clause.condition) + " then");
+                    }
+                    else {
+                        tokens.push("else");
+                    }
+                    tokens.push(...this.collectTokens(clause.body));
+                }
+                tokens.push("end");
+                break;
+            }
+            case "WhileStatement": {
+                const st = stmt;
+                tokens.push("while " + this.expr(st.condition) + " do");
+                tokens.push(...this.collectTokens(st.body));
+                tokens.push("end");
+                break;
+            }
+            case "RepeatStatement": {
+                const st = stmt;
+                tokens.push("repeat");
+                tokens.push(...this.collectTokens(st.body));
+                tokens.push("until " + this.expr(st.condition));
+                break;
+            }
+            case "ForNumericStatement": {
+                const st = stmt;
+                let s = "for " + this.expr(st.variable) + "=" + this.expr(st.start) + "," + this.expr(st.end);
+                if (st.step) {
+                    s += "," + this.expr(st.step);
+                }
+                s += " do";
+                tokens.push(s);
+                tokens.push(...this.collectTokens(st.body));
+                tokens.push("end");
+                break;
+            }
+            case "ForGenericStatement": {
+                const st = stmt;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                const iters = st.iterators.map((it) => this.expr(it)).join(",");
+                tokens.push("for " + vars + " in " + iters + " do");
+                tokens.push(...this.collectTokens(st.body));
+                tokens.push("end");
+                break;
+            }
+            case "DoStatement": {
+                const st = stmt;
+                tokens.push("do");
+                tokens.push(...this.collectTokens(st.body));
+                tokens.push("end");
+                break;
+            }
+            default:
+                break;
+        }
+        return tokens;
+    }
+    // Pack tokens into lines respecting maxLineLength
+    packTokensIntoLines(tokens) {
+        const maxLen = this.options.maxLineLength || 120;
+        const lines = [];
+        let currentLine = "";
+        for (const token of tokens) {
+            // Special case: comment tokens start with \n and force a new line
+            if (token.startsWith("\n")) {
+                if (currentLine.length > 0) {
+                    lines.push(currentLine);
+                    currentLine = "";
+                }
+                lines.push(token.slice(1)); // Remove the leading \n marker
+                continue;
+            }
+            if (currentLine.length === 0) {
+                currentLine = token;
+            }
+            else {
+                const candidate = currentLine + " " + token;
+                // Use <= to allow filling lines up to exactly maxLen
+                // EXCEPT: if the token is 'end', use < to prefer wrapping
+                // This avoids packing 'end' to fill exactly maxLen
+                const isEndToken = token === "end";
+                const fits = isEndToken ? candidate.length < maxLen : candidate.length <= maxLen;
+                if (fits) {
+                    currentLine = candidate;
+                }
+                else {
+                    lines.push(currentLine);
+                    currentLine = token;
+                }
+            }
+        }
+        if (currentLine.length > 0) {
+            lines.push(currentLine);
+        }
+        return lines.join("\n") + (lines.length > 0 ? "\n" : "");
+    }
+    // Render a comment for tight mode
+    renderComment(comment) {
+        if (comment.raw) {
+            return comment.raw.trim();
+        }
+        return "--" + comment.value;
+    }
+    // --- low-level emit helpers ---
+    emit(s) {
+        this.currentLine += s;
+    }
+    newline() {
+        this.flushLine();
+    }
+    flushLine() {
+        this.buf.push(this.currentLine + "\n");
+        this.currentLine = "";
+    }
+    emitKeyword(s) {
+        this.emit(s);
+    }
+    startPos(node) {
+        if (node && Array.isArray(node.range) && node.range.length > 0) {
+            return node.range[0];
+        }
+        return 0;
+    }
+    printIndent() {
+        const indentLevel = Math.min(this.indentLevel, this.options.maxIndentLevel);
+        this.buf.push(this.indentUnit.repeat(indentLevel));
+        //   if (!this.options.stripWhitespace) {
+        //      this.buf.push(this.indentUnit.repeat(this.indentLevel));
+        //   }
+    }
+    printBlock(body) {
+        const comments = [...(this.blockComments.get(body) || [])];
+        const items = [];
+        let ci = 0;
+        for (const stmt of body) {
+            while (ci < comments.length && this.startPos(comments[ci]) <= this.startPos(stmt)) {
+                items.push(comments[ci]);
+                ci++;
+            }
+            items.push(stmt);
+        }
+        while (ci < comments.length) {
+            items.push(comments[ci]);
+            ci++;
+        }
+        const mode = this.options.lineBehavior || "pretty";
+        const maxLen = this.options.maxLineLength || 120;
+        // In inline mode, render all statements space-separated on one line (no newlines)
+        if (this.inlineMode) {
+            for (let i = 0; i < items.length; i++) {
+                const node = items[i];
+                if (i > 0)
+                    this.emit(" ");
+                this.printStatementInline(node);
+            }
+            return;
+        }
+        // In pretty mode, print each statement on its own line
+        if (mode === "pretty") {
+            for (const node of items) {
+                this.printIndent();
+                this.printStatement(node);
+            }
+            return;
+        }
+        // single-line-blocks mode: blocks are either entirely single-line or multi-line
+        // (tight mode is handled separately via printTightMode)
+        const flushLineIfAny = () => {
+            if (this.currentLine.length > 0)
+                this.flushLine();
+        };
+        for (const node of items) {
+            // Comments always get their own line
+            if (node.type === "Comment") {
+                flushLineIfAny();
+                this.printIndent();
+                this.printStatement(node);
+                continue;
+            }
+            const stmt = node;
+            const inline = this.renderInlineStatement(stmt, maxLen);
+            const indent = this.indentUnit.repeat(Math.min(this.indentLevel, this.options.maxIndentLevel));
+            // Check if inline version fits on its own line (with indent)
+            const inlineWithIndent = inline !== null ? indent + inline : null;
+            const inlineFits = inlineWithIndent !== null && inlineWithIndent.length < maxLen;
+            if (inlineFits) {
+                // Try to pack onto current line
+                const sep = this.currentLine.length === 0 ? "" : " ";
+                const prefix = this.currentLine.length === 0 ? indent : this.currentLine;
+                const candidate = prefix + sep + inline;
+                if (candidate.length < maxLen || this.currentLine.length === 0) {
+                    if (this.currentLine.length === 0) {
+                        this.currentLine = indent + inline;
+                    }
+                    else {
+                        this.currentLine = this.currentLine + " " + inline;
+                    }
+                    continue;
+                }
+                // Doesn't fit on current line, but inline exists - start new line with inline
+                flushLineIfAny();
+                this.currentLine = indent + inline;
+                continue;
+            }
+            // Fallback to normal multi-line printing for this statement
+            flushLineIfAny();
+            this.printIndent();
+            this.printStatement(node);
+        }
+        // Ensure any buffered inline statements inside this block are flushed before exiting it.
+        flushLineIfAny();
+    }
+    // Print a statement without any newline at the end (for inline mode)
+    printStatementInline(node) {
+        switch (node.type) {
+            case "AssignmentStatement": {
+                const st = node;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                const vals = st.init.map((v) => this.expr(v)).join(",");
+                this.emit(vars + "=" + vals);
+                break;
+            }
+            case "LocalStatement": {
+                const st = node;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                let s = "local " + vars;
+                if (st.init && st.init.length > 0) {
+                    s += "=" + st.init.map((v) => this.expr(v)).join(",");
+                }
+                this.emit(s);
+                break;
+            }
+            case "CallStatement": {
+                const st = node;
+                this.emit(this.expr(st.expression));
+                break;
+            }
+            case "FunctionDeclaration": {
+                const fn = node;
+                let s = fn.isLocal ? "local function " : "function ";
+                if (fn.identifier) {
+                    s += this.expr(fn.identifier);
+                }
+                s += "(" + fn.parameters.map((p) => this.expr(p)).join(",") + ") ";
+                this.emit(s);
+                this.printBlock(fn.body);
+                this.emit(" end");
+                break;
+            }
+            case "IfStatement": {
+                const ifs = node;
+                for (let i = 0; i < ifs.clauses.length; i++) {
+                    const clause = ifs.clauses[i];
+                    if (clause.type === "IfClause") {
+                        this.emit("if " + this.expr(clause.condition) + " then ");
+                    }
+                    else if (clause.type === "ElseifClause") {
+                        this.emit(" elseif " + this.expr(clause.condition) + " then ");
+                    }
+                    else {
+                        this.emit(" else ");
+                    }
+                    this.printBlock(clause.body);
+                }
+                this.emit(" end");
+                break;
+            }
+            case "WhileStatement": {
+                const st = node;
+                this.emit("while " + this.expr(st.condition) + " do ");
+                this.printBlock(st.body);
+                this.emit(" end");
+                break;
+            }
+            case "RepeatStatement": {
+                const st = node;
+                this.emit("repeat ");
+                this.printBlock(st.body);
+                this.emit(" until " + this.expr(st.condition));
+                break;
+            }
+            case "ForNumericStatement": {
+                const st = node;
+                let s = "for " + this.expr(st.variable) + "=" + this.expr(st.start) + "," + this.expr(st.end);
+                if (st.step) {
+                    s += "," + this.expr(st.step);
+                }
+                s += " do ";
+                this.emit(s);
+                this.printBlock(st.body);
+                this.emit(" end");
+                break;
+            }
+            case "ForGenericStatement": {
+                const st = node;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                const iters = st.iterators.map((it) => this.expr(it)).join(",");
+                this.emit("for " + vars + " in " + iters + " do ");
+                this.printBlock(st.body);
+                this.emit(" end");
+                break;
+            }
+            case "ReturnStatement": {
+                const st = node;
+                if (st.arguments.length > 0) {
+                    this.emit("return " + st.arguments.map((a) => this.expr(a)).join(","));
+                }
+                else {
+                    this.emit("return");
+                }
+                break;
+            }
+            case "BreakStatement":
+                this.emit("break");
+                break;
+            case "DoStatement": {
+                const st = node;
+                this.emit("do ");
+                this.printBlock(st.body);
+                this.emit(" end");
+                break;
+            }
+            case "Comment":
+                // Skip comments in inline mode
+                break;
+            default:
+                break;
+        }
+    }
+    // --- statement printer ---
+    printStatement(node) {
+        switch (node.type) {
+            case "AssignmentStatement": {
+                const st = node;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                const vals = st.init.map((v) => this.expr(v)).join(",");
+                this.emit(vars);
+                this.emit("=");
+                this.emit(vals);
+                this.newline();
+                break;
+            }
+            case "LocalStatement": {
+                const st = node;
+                const vars = st.variables.map((v) => this.expr(v)).join(",");
+                this.emitKeyword("local");
+                this.emit(" ");
+                this.emit(vars);
+                if (st.init && st.init.length > 0) {
+                    const vals = st.init.map((v) => this.expr(v)).join(",");
+                    this.emit("=");
+                    this.emit(vals);
+                }
+                this.newline();
+                break;
+            }
+            case "CallStatement": {
+                const st = node;
+                this.emit(this.expr(st.expression));
+                this.newline();
+                break;
+            }
+            case "FunctionDeclaration": {
+                const fn = node;
+                if (fn.isLocal) {
+                    this.emitKeyword("local");
+                    this.emit(" ");
+                }
+                this.emitKeyword("function");
+                this.emit(" ");
+                if (fn.identifier) {
+                    this.emit(this.expr(fn.identifier));
+                }
+                this.emit("(");
+                this.emit(fn.parameters.map((p) => this.expr(p)).join(","));
+                this.emit(")");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(fn.body);
+                this.indentLevel--;
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "IfStatement": {
+                const ifs = node;
+                ifs.clauses.forEach((clause, idx) => {
+                    // The enclosing block printer (`printBlock`) emits indentation only once for the
+                    // top-level statement. Subsequent clauses need to re-emit indentation explicitly,
+                    // otherwise `elseif`/`else` start at column 0.
+                    if (idx > 0) {
+                        this.printIndent();
+                    }
+                    if (clause.type === "IfClause") {
+                        this.emitKeyword("if");
+                        this.emit(" ");
+                        this.emit(this.expr(clause.condition));
+                        this.emitKeyword(" then");
+                    }
+                    else if (clause.type === "ElseifClause") {
+                        this.emitKeyword("elseif");
+                        this.emit(" ");
+                        this.emit(this.expr(clause.condition));
+                        this.emitKeyword(" then");
+                    }
+                    else {
+                        this.emitKeyword("else");
+                    }
+                    this.newline();
+                    this.indentLevel++;
+                    this.printBlock(clause.body);
+                    this.indentLevel--;
+                });
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "WhileStatement": {
+                const st = node;
+                this.emitKeyword("while");
+                this.emit(" ");
+                this.emit(this.expr(st.condition));
+                this.emitKeyword(" do");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(st.body);
+                this.indentLevel--;
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "RepeatStatement": {
+                const st = node;
+                this.emitKeyword("repeat");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(st.body);
+                this.indentLevel--;
+                this.emitKeyword("until");
+                this.emit(" ");
+                this.emit(this.expr(st.condition));
+                this.newline();
+                break;
+            }
+            case "ForNumericStatement": {
+                const st = node;
+                this.emitKeyword("for");
+                this.emit(" ");
+                this.emit(this.expr(st.variable));
+                this.emit("=");
+                this.emit(this.expr(st.start));
+                this.emit(",");
+                this.emit(this.expr(st.end));
+                if (st.step) {
+                    this.emit(",");
+                    this.emit(this.expr(st.step));
+                }
+                this.emitKeyword(" do");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(st.body);
+                this.indentLevel--;
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "ForGenericStatement": {
+                const st = node;
+                this.emitKeyword("for");
+                this.emit(" ");
+                this.emit(st.variables.map((v) => this.expr(v)).join(","));
+                this.emitKeyword(" in ");
+                this.emit(st.iterators.map((it) => this.expr(it)).join(","));
+                this.emitKeyword(" do");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(st.body);
+                this.indentLevel--;
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "ReturnStatement": {
+                const st = node;
+                this.emitKeyword("return");
+                if (st.arguments.length > 0) {
+                    this.emit(" ");
+                    this.emit(st.arguments.map((a) => this.expr(a)).join(","));
+                }
+                this.newline();
+                break;
+            }
+            case "BreakStatement": {
+                this.emitKeyword("break");
+                this.newline();
+                break;
+            }
+            case "DoStatement": {
+                const st = node;
+                this.emitKeyword("do");
+                this.newline();
+                this.indentLevel++;
+                this.printBlock(st.body);
+                this.indentLevel--;
+                this.printIndent();
+                this.emitKeyword("end");
+                this.newline();
+                break;
+            }
+            case "Comment":
+                this.printComment(node);
+                break;
+            default:
+                // console.warn("Unimplemented statement type:", node.type);
+                break;
+        }
+    }
+    // Try to render a statement as a single-line string.
+    // For single-line-blocks mode: only return non-null if the entire statement (including nested blocks) fits on one line.
+    // Returns null if the statement cannot be rendered inline under the given constraints.
+    renderInlineStatement(stmt, maxLen) {
+        // Use a temporary printer in inline mode to render everything on one line
+        const temp = new LuaPrinter(this.options, this.blockComments);
+        temp.inlineMode = true;
+        temp.buf = [];
+        temp.currentLine = "";
+        temp.printStatementInline(stmt);
+        const out = temp.currentLine.trim();
+        // If it exceeds maxLen, cannot inline
+        if (out.length > maxLen) {
+            return null;
+        }
+        return out;
+    }
+    // Check if statement contains nested blocks
+    isBlockStatement(stmt) {
+        switch (stmt.type) {
+            case "IfStatement":
+            case "WhileStatement":
+            case "RepeatStatement":
+            case "ForNumericStatement":
+            case "ForGenericStatement":
+            case "FunctionDeclaration":
+            case "DoStatement":
+                return true;
+            default:
+                return false;
+        }
+    }
+    // --- expression printer ---
+    expr(node, parentPrec = 0) {
+        if (!node)
+            return "";
+        switch (node.type) {
+            case "Identifier":
+                return node.name;
+            case "StringLiteral":
+                return this.stringLiteral(node);
+            case "NumericLiteral":
+                return this.numericLiteral(node);
+            case "BooleanLiteral":
+                return node.value ? "true" : "false";
+            case "NilLiteral":
+                return "nil";
+            case "VarargLiteral":
+                return "...";
+            case "TableConstructorExpression":
+                return this.tableConstructor(node);
+            case "UnaryExpression":
+                return this.unaryExpr(node, parentPrec);
+            case "BinaryExpression":
+                return this.binaryExpr(node, parentPrec);
+            case "LogicalExpression":
+                return this.logicalExpr(node, parentPrec);
+            case "MemberExpression":
+                return this.memberExpr(node);
+            case "IndexExpression":
+                return this.indexExpr(node);
+            case "CallExpression":
+                return this.callExpr(node);
+            case "TableCallExpression":
+                return this.tableCallExpr(node);
+            case "StringCallExpression":
+                return this.stringCallExpr(node);
+            case "FunctionDeclaration":
+                return this.functionExpr(node);
+            default:
+                return `<${node.type}>`;
+        }
+    }
+    stringLiteral(node) {
+        if (node.raw)
+            return node.raw;
+        return (0, lua_fundamentals_1.toLuaStringLiteral)(node.value);
+    }
+    numericLiteral(node, options) {
+        const value = node.value;
+        const decimalStr = Number.isFinite(value) ? value.toString(10) : String(value);
+        if (/^-?0\.\d/.test(decimalStr)) {
+            const compact = decimalStr.replace(/^(-?)0\./, "$1.");
+            if (options?.forceLeadingZero && /^-?\./.test(compact)) {
+                return compact.replace(/^(-?)\./, "$10.");
+            }
+            return compact;
+        }
+        if (options?.forceLeadingZero && /^-?\./.test(decimalStr)) {
+            return decimalStr.replace(/^(-?)\./, "$10.");
+        }
+        return decimalStr;
+    }
+    tableConstructor(node) {
+        if (node.fields.length === 0)
+            return "{}";
+        const parts = [];
+        for (const f of node.fields) {
+            if (f.type === "TableKey") {
+                parts.push(`[${this.expr(f.key)}]=${this.expr(f.value)}`);
+            }
+            else if (f.type === "TableKeyString") {
+                // luaparse gives key as an Identifier or StringLiteral
+                parts.push(`${this.expr(f.key)}=${this.expr(f.value)}`);
+            }
+            else {
+                // TableValue
+                parts.push(this.expr(f.value));
+            }
+        }
+        return `{${parts.join(",")}}`;
+    }
+    unaryExpr(node, parentPrec) {
+        const prec = getPrecedence(node);
+        const arg = this.expr(node.argument, prec);
+        const op = node.operator;
+        let s;
+        if (op === "not") {
+            s = `not ${arg}`;
+        }
+        else {
+            s = op + arg;
+        }
+        if (prec < parentPrec)
+            s = `(${s})`;
+        return s;
+    }
+    binaryExpr(node, parentPrec) {
+        const prec = getPrecedence(node);
+        const left = node.operator === ".." ? this.concatLeftExpr(node.left, prec) : this.expr(node.left, prec);
+        const rightRaw = node.operator === ".." ? this.concatRightExpr(node.right, prec) : this.expr(node.right, prec);
+        const right = node.operator === ".." ? this.ensureConcatSafeRight(rightRaw) : rightRaw;
+        let s = `${left}${node.operator}${right}`;
+        if (prec < parentPrec)
+            s = `(${s})`;
+        return s;
+    }
+    concatLeftExpr(node, parentPrec) {
+        if (node.type === "NumericLiteral") {
+            return `(${this.numericLiteral(node)})`;
+        }
+        if (node.type === "UnaryExpression") {
+            const unary = node;
+            if (unary.operator === "-" && unary.argument.type === "NumericLiteral") {
+                const arg = this.numericLiteral(unary.argument);
+                return `(-${arg})`;
+            }
+        }
+        return this.expr(node, parentPrec);
+    }
+    concatRightExpr(node, parentPrec) {
+        if (node.type === "NumericLiteral") {
+            return this.numericLiteral(node, { forceLeadingZero: true });
+        }
+        if (node.type === "UnaryExpression") {
+            const unary = node;
+            if (unary.operator === "-" && unary.argument.type === "NumericLiteral") {
+                const arg = this.numericLiteral(unary.argument, { forceLeadingZero: true });
+                let s = `-${arg}`;
+                if (getPrecedence(unary) < parentPrec)
+                    s = `(${s})`;
+                return s;
+            }
+        }
+        return this.expr(node, parentPrec);
+    }
+    ensureConcatSafeRight(text) {
+        if (text.startsWith("-.")) {
+            return "-0" + text.slice(1);
+        }
+        if (text.startsWith(".")) {
+            return "0" + text;
+        }
+        return text;
+    }
+    logicalExpr(node, parentPrec) {
+        const prec = getPrecedence(node);
+        const left = this.expr(node.left, prec);
+        const right = this.expr(node.right, prec);
+        let s = `${left} ${node.operator} ${right}`;
+        if (prec < parentPrec)
+            s = `(${s})`;
+        return s;
+    }
+    memberExpr(node) {
+        // luaparse usually gives . or : in node.indexer
+        const base = this.expr(node.base, 100); // force parens if non-primary
+        const id = this.expr(node.identifier);
+        const indexer = node.indexer || ".";
+        return `${base}${indexer}${id}`;
+    }
+    indexExpr(node) {
+        const base = this.expr(node.base, 100);
+        return `${base}[${this.expr(node.index)}]`;
+    }
+    callExpr(node) {
+        const base = this.expr(node.base, 100);
+        const args = node.arguments.map((a) => this.expr(a)).join(",");
+        return `${base}(${args})`;
+    }
+    tableCallExpr(node) {
+        // sugar: f{...}  → f({ ... })
+        const base = this.expr(node.base, 100);
+        const arg = this.expr(node.arguments);
+        return `${base}(${arg})`;
+    }
+    stringCallExpr(node) {
+        // sugar: f"str" → f("str")
+        const base = this.expr(node.base, 100);
+        const arg = this.stringLiteral(node.argument);
+        return `${base}(${arg})`;
+    }
+    functionExpr(node) {
+        // function used as expression: "function(a,b) ... end"
+        const params = node.parameters.map((p) => this.expr(p)).join(",");
+        const bodyPrinter = new LuaPrinter(this.options, this.blockComments);
+        // reuse statement printer but avoid duplicating indent handling:
+        const innerChunk = {
+            type: "Chunk",
+            body: node.body,
+            comments: [],
+            //globals: [],
+        };
+        const bodyCode = bodyPrinter.print(innerChunk).trimEnd();
+        return `function(${params})\n${bodyCode}\nend`;
+    }
+    printComment(node) {
+        if (node.raw) {
+            this.emit(node.raw);
+        }
+        else {
+            this.emit("--" + node.value);
+        }
+        this.newline();
+    }
+}
+exports.LuaPrinter = LuaPrinter;
+function nodeRange(node) {
+    if (node && Array.isArray(node.range) && node.range.length > 1) {
+        return node.range;
+    }
+    return [0, Number.MAX_SAFE_INTEGER];
+}
+function rangeContains(outer, inner) {
+    return inner[0] >= outer[0] && inner[1] <= outer[1];
+}
+// Collect all statement blocks (function bodies, if/else bodies, loops, etc.)
+function collectBlocksFromStatement(node, blocks) {
+    switch (node.type) {
+        case "FunctionDeclaration": {
+            const fn = node;
+            blocks.push({ body: fn.body, range: nodeRange(fn) });
+            fn.body.forEach((st) => collectBlocksFromStatement(st, blocks));
+            break;
+        }
+        case "IfStatement": {
+            const ifs = node;
+            ifs.clauses.forEach((clause) => {
+                blocks.push({ body: clause.body, range: nodeRange(clause) });
+                clause.body.forEach((st) => collectBlocksFromStatement(st, blocks));
+            });
+            break;
+        }
+        case "WhileStatement":
+        case "RepeatStatement":
+        case "ForNumericStatement":
+        case "ForGenericStatement":
+        case "DoStatement": {
+            const body = node.body;
+            blocks.push({ body, range: nodeRange(node) });
+            body.forEach((st) => collectBlocksFromStatement(st, blocks));
+            break;
+        }
+        default:
+            break;
+    }
+}
+function collectAllStatementBlocks(chunk) {
+    const blocks = [
+        { body: chunk.body, range: nodeRange(chunk) },
+    ];
+    for (const st of chunk.body) {
+        collectBlocksFromStatement(st, blocks);
+    }
+    return blocks;
+}
+// Build a map from statement blocks to comments contained within them
+// why is this needed?
+// luaparse gives comments attached to the root chunk only, not to inner blocks
+// so we have to manually assign them to the correct blocks
+function buildCommentMap(ast) {
+    const blocks = collectAllStatementBlocks(ast);
+    const map = new Map();
+    blocks.forEach((b) => map.set(b.body, []));
+    const comments = ast.comments || [];
+    for (const c of comments) {
+        const cr = nodeRange(c);
+        let target = blocks[0];
+        for (const blk of blocks) {
+            if (rangeContains(blk.range, cr)) {
+                const widthCurrent = target ? target.range[1] - target.range[0] : Number.MAX_SAFE_INTEGER;
+                const widthCandidate = blk.range[1] - blk.range[0];
+                if (widthCandidate <= widthCurrent) {
+                    target = blk;
+                }
+            }
+        }
+        const list = map.get(target.body) || [];
+        list.push(c);
+        map.set(target.body, list);
+    }
+    for (const [body, list] of map.entries()) {
+        list.sort((a, b) => nodeRange(a)[0] - nodeRange(b)[0]);
+    }
+    return map;
+}
+// Generate Lua code from an AST
+function unparseLua(ast, ruleOptions) {
+    const generator = new LuaPrinter(ruleOptions, buildCommentMap(ast));
+    return generator.print(ast);
+}
+function parseLua(code) {
+    //console.log(code);
+    try {
+        const ast = luaparse.parse(code, {
+            luaVersion: "5.3", // TIC-80 is 5.3-ish
+            comments: true,
+            locations: true,
+            ranges: true,
+        });
+        return ast;
+    }
+    catch (error) {
+        console.error("Error parsing Lua code:", error);
+        console.log("Lua code:\n", code);
+    }
+    return null;
+}
+function processLua(code, ruleOptions) {
+    // Apply optimization rules
+    //const options = {...DEFAULT_OPTIMIZATION_RULES, ...ruleOptions};
+    // Strip debug blocks and lines before parsing (line-based string matching)
+    let processedCode = code;
+    // if (ruleOptions.stripDebugBlocks) {
+    //    // Strip debug blocks
+    //    processedCode = replaceLuaBlock(processedCode, "-- BEGIN_DEBUG_ONLY", "-- END_DEBUG_ONLY", "");
+    //    // Strip individual lines marked with -- DEBUG_ONLY
+    //    const eol = processedCode.includes("\r\n") ? "\r\n" : "\n";
+    //    const lines = processedCode.split(eol);
+    //    const filteredLines = lines.filter(line => !line.includes("-- DEBUG_ONLY"));
+    //    processedCode = filteredLines.join(eol);
+    // }
+    // Honor explicit directives to keep certain regions verbatim
+    // doing this at text level for simplification and because the printer can reformat everything.
+    const disableMinify = (0, lua_fundamentals_1.extractLuaBlocks)(processedCode, "-- MINIFICATION OFF", "-- MINIFICATION ON", (i) => `__SOMATIC_DISABLED_MINIFICATION_BLOCK_${i}__()`, { strict: false });
+    processedCode = disableMinify.code;
+    let ast = parseLua(processedCode);
+    if (!ast) {
+        console.error("Failed to parse Lua code; returning original code.");
+        return code;
+    }
+    //console.log("Parsed Lua AST:", ast);
+    if (ruleOptions.stripComments) {
+        ast.comments = [];
+    }
+    if (ruleOptions.simplifyExpressions) {
+        ast = (0, lua_simplify_1.simplifyExpressionsInAST)(ast);
+    }
+    if (ruleOptions.removeUnusedLocals) {
+        ast = (0, lua_remove_unused_locals_1.removeUnusedLocalsInAST)(ast);
+    }
+    if (ruleOptions.removeUnusedFunctions) {
+        ast = (0, lua_remove_unused_functions_1.removeUnusedFunctionsInAST)(ast, {
+            functionNamesToKeep: ruleOptions.functionNamesToKeep,
+        });
+    }
+    if (ruleOptions.aliasLiterals) {
+        ast = (0, lua_alias_literals_1.aliasLiteralsInAST)(ast);
+    }
+    if (ruleOptions.aliasRepeatedExpressions) {
+        ast = (0, lua_alias_expressions_1.aliasRepeatedExpressionsInAST)(ast);
+    }
+    if (ruleOptions.packLocalDeclarations) {
+        ast = (0, lua_pack_locals_1.packLocalDeclarationsInAST)(ast);
+    }
+    if (ruleOptions.renameLocalVariables) {
+        ast = (0, lua_renamer_1.renameLocalVariablesInAST)(ast);
+    }
+    if (ruleOptions.tableEntryKeysToRename && ruleOptions.tableEntryKeysToRename.length > 0) {
+        ast = (0, lua_rename_allowed_table_keys_1.renameAllowedTableKeysInAST)(ast, ruleOptions.tableEntryKeysToRename);
+    }
+    if (ruleOptions.renameTableFields) {
+        ast = (0, lua_rename_table_fields_1.renameTableFieldsInAST)(ast);
+    }
+    const minified = unparseLua(ast, ruleOptions);
+    return reinsertDisableMinificationBlocks(minified, disableMinify.blocks);
+}
+// Escape special characters in a string for use in a RegExp
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function reinsertDisableMinificationBlocks(src, blocks) {
+    if (blocks.length === 0)
+        return src;
+    let out = src;
+    for (const b of blocks) {
+        // normalize line endings and trim trailing newlines from the block content
+        const normalized = b.content.replace(/\r?\n/g, "\n").replace(/\n+$/g, "");
+        const replacement = `\n${normalized}\n`;
+        // remove surrounding whitespace introduced by tight packing.
+        const re = new RegExp(`[\\t ]*${escapeRegExp(b.placeholder)}[\\t ]*`, "g");
+        out = out.replace(re, replacement);
+    }
+    return out;
+}
+//# sourceMappingURL=lua_processor.js.map