nextlua 2.0.0 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nextlua",
-  "version": "2.0.0",
+  "version": "3.1.0",
   "description": "A luau beautifier and minifier.",
   "main": "index.js",
   "bin": {

package/src/main.js

@@ -141,6 +141,115 @@ function readLongBracket(input, index) {
     };
 }
 
+function decodeStringToken(token) {
+    const quote = token[0];
+    if (quote !== '"' && quote !== "'" && quote !== "`") {
+        return token;
+    }
+
+    function keepEscape(code) {
+        // Only de-uglify printable ASCII; leave control bytes and chars that
+        // would need re-escaping (quote/backslash) as their original escapes.
+        if (code < 0x20 || code > 0x7e) {
+            return false;
+        }
+        const ch = String.fromCharCode(code);
+        return ch !== '"' && ch !== "'" && ch !== "`" && ch !== "\\";
+    }
+
+    // Pass 1: split into units — final text, or a preserved decimal escape
+    // (kept as { dec } so padding can be decided once we know what follows).
+    const units = [];
+    function pushText(text) {
+        const last = units[units.length - 1];
+        if (last && last.text !== undefined) {
+            last.text += text;
+        } else {
+            units.push({ text });
+        }
+    }
+
+    let i = 0;
+    while (i < token.length) {
+        const ch = token[i];
+        if (ch !== "\\") {
+            pushText(ch);
+            i++;
+            continue;
+        }
+
+        const next = token[i + 1];
+        const hexMatch = next === "x" && /^[0-9A-Fa-f]{2}/.test(token.slice(i + 2, i + 4))
+            ? token.slice(i + 2, i + 4)
+            : null;
+        if (hexMatch) {
+            const code = parseInt(hexMatch, 16);
+            if (keepEscape(code)) {
+                pushText(String.fromCharCode(code));
+            } else {
+                // Hex escapes are fixed-width (\xHH), so never ambiguous.
+                pushText("\\x" + hexMatch);
+            }
+            i += 4;
+            continue;
+        }
+
+        const decMatch = /^[0-9]{1,3}/.exec(token.slice(i + 1, i + 4));
+        if (decMatch) {
+            const digits = decMatch[0];
+            const code = parseInt(digits, 10);
+            i += 1 + digits.length;
+            if (code <= 0xff && keepEscape(code)) {
+                pushText(String.fromCharCode(code));
+            } else {
+                units.push({ dec: Math.min(code, 0xff) });
+            }
+            continue;
+        }
+
+        // Preserve any other escape sequence verbatim (\n, \t, \\, \" ...).
+        pushText(ch + (next === undefined ? "" : next));
+        i += next === undefined ? 1 : 2;
+    }
+
+    // Pass 2: serialize. A preserved decimal escape only needs zero-padding to
+    // 3 digits when the next output char is a digit (which would otherwise
+    // merge into a single, possibly >255, escape).
+    let result = "";
+    for (let u = 0; u < units.length; u++) {
+        const unit = units[u];
+        if (unit.text !== undefined) {
+            result += unit.text;
+            continue;
+        }
+
+        const nextUnit = units[u + 1];
+        const nextChar = nextUnit && nextUnit.text !== undefined ? nextUnit.text[0] : "";
+        result += "\\" + (/[0-9]/.test(nextChar)
+            ? String(unit.dec).padStart(3, "0")
+            : String(unit.dec));
+    }
+
+    return result;
+}
+
+function normalizeNumberToken(token) {
+    // Underscore digit separators are stripped (a no-op when none are present).
+    const stripped = token.replace(/_/g, "");
+
+    const hexMatch = /^0[xX]([0-9A-Fa-f]+)$/.exec(stripped);
+    if (hexMatch) {
+        return BigInt("0x" + hexMatch[1]).toString(10);
+    }
+
+    const binMatch = /^0[bB]([01]+)$/.exec(stripped);
+    if (binMatch) {
+        return BigInt("0b" + binMatch[1]).toString(10);
+    }
+
+    return stripped;
+}
+
 function tokenize(input) {
     const tokens = [];
     let i = 0;
@@ -174,17 +283,26 @@ function tokenize(input) {
         if (ch === '"' || ch === "'" || ch === "`") {
             let value = ch;
             i++;
+            let escaped = false;
 
             while (i < input.length) {
-                value += input[i];
-                if (input[i] === ch && input[i - 1] !== "\\") {
-                    i++;
+                const c = input[i];
+                value += c;
+                i++;
+                if (escaped) {
+                    escaped = false;
+                    continue;
+                }
+                if (c === "\\") {
+                    escaped = true;
+                    continue;
+                }
+                if (c === ch) {
                     break;
                 }
-                i++;
             }
 
-            tokens.push(value);
+            tokens.push(decodeStringToken(value));
             continue;
         }
 
@@ -217,7 +335,7 @@ function tokenize(input) {
             while (end < input.length && /[A-Fa-f0-9_xX.]/.test(input[end])) {
                 end++;
             }
-            tokens.push(input.slice(i, end));
+            tokens.push(normalizeNumberToken(input.slice(i, end)));
             i = end;
             continue;
         }
@@ -241,6 +359,26 @@ function isLiteral(token) {
     return /^["'`]/.test(token) || /^\d/.test(token) || token === "..." || token === "true" || token === "false" || token === "nil";
 }
 
+const keywordsSpacedBeforeParen = new Set([
+    "if",
+    "elseif",
+    "while",
+    "until",
+    "return",
+    "and",
+    "or",
+    "not",
+    "in"
+]);
+
+function isValueEnd(token) {
+    return (isIdentifier(token) && !reservedKeywords.has(token)) ||
+        isLiteral(token) ||
+        token === ")" ||
+        token === "]" ||
+        token === "}";
+}
+
 function canEndStatement(token) {
     return (isIdentifier(token) && !reservedKeywords.has(token)) || isLiteral(token) || token === ")" || token === "]" || token === "}" || token === "end" || token === "break" || token === "continue";
 }
@@ -271,6 +409,16 @@ function needsSpace(prev, current) {
     }
 
     if (current === "(") {
+        // Control-flow keywords and binary operators read better with a space
+        // before the paren (`if (`, `while (`, `a * (`, `x = (`), but calls
+        // like `function(` and `foo(` stay tight. A unary sign before `(` is
+        // handled by joinTokens, which suppresses the space (`-(x)`).
+        return keywordsSpacedBeforeParen.has(prev) || binaryOperators.has(prev);
+    }
+
+    if (current === "[" && isValueEnd(prev)) {
+        // Indexing: `A[x]`, `t.k[x]`, `f()[x]` — no space. Table-constructor
+        // keys (`{ [k] = v }`) keep prev as `{`/`,`, so they are unaffected.
         return false;
     }
 
@@ -282,7 +430,9 @@ function needsSpace(prev, current) {
         return false;
     }
 
-    if (prev === "#" || current === "#") {
+    if (prev === "#") {
+        // The length operator binds tightly to its operand: `#h`, never `# h`.
+        // The space *before* `#` still follows the normal rules (`= #h`).
         return false;
     }
 
@@ -293,22 +443,75 @@ function needsSpace(prev, current) {
     return true;
 }
 
-function renderLine(tokens) {
+function isGenericOpen(tokens, index) {
+    // tokens[index] is "<". Treat it as a generic-parameter list only in a
+    // declaration context: `function<T>`, `function foo<T>`, `type X<T>`.
+    const prev = tokens[index - 1];
+    if (prev === "function" || prev === "type") {
+        return true;
+    }
+
+    const prev2 = tokens[index - 2];
+    return (prev2 === "function" || prev2 === "type") &&
+        isIdentifier(prev) &&
+        !reservedKeywords.has(prev);
+}
+
+function isUnarySign(tokens, index) {
+    // tokens[index] is "-" or "+". It is unary (binding tightly to its operand
+    // with no following space: `-1`, `-x`, `-(y)`, `-#t`) when it does not
+    // follow a complete value. Otherwise it is the binary operator (`a - 1`).
+    const token = tokens[index];
+    if (token !== "-" && token !== "+") {
+        return false;
+    }
+    const before = tokens[index - 1];
+    return before === undefined || !isValueEnd(before);
+}
+
+function joinTokens(tokens) {
     let text = "";
     let prev = null;
+    let genericDepth = 0;
+
+    for (let idx = 0; idx < tokens.length; idx++) {
+        const token = tokens[idx];
 
-    for (const token of tokens) {
-        if (needsSpace(prev, token)) {
+        const inGeneric = genericDepth > 0;
+        const opensGeneric = !inGeneric && token === "<" && isGenericOpen(tokens, idx);
+
+        // A unary +/- binds to its operand, so suppress the space after it.
+        // (Skip the suppression when the next token is itself a +/- so we never
+        // fuse two signs into a `--` comment or a `+-` run.)
+        const prevIsUnarySign = prev !== null &&
+            token !== "-" && token !== "+" &&
+            isUnarySign(tokens, idx - 1);
+
+        if (prev !== null && !inGeneric && !opensGeneric && !prevIsUnarySign && needsSpace(prev, token)) {
             text += " ";
         }
         text += token;
+
+        // Track generic-bracket nesting so the whole `<...>` stays tight.
+        if (opensGeneric || (inGeneric && token === "<")) {
+            genericDepth++;
+        } else if (inGeneric && token === ">") {
+            genericDepth--;
+        } else if (inGeneric && token === ">>") {
+            genericDepth = Math.max(0, genericDepth - 2);
+        }
+
         prev = token;
     }
 
-    return text.trim();
+    return text;
 }
 
-function beautify(input) {
+function renderLine(tokens) {
+    return joinTokens(tokens).trim();
+}
+
+function layout(input) {
     const tokens = tokenize(input);
     const lines = [];
     let current = [];
@@ -329,7 +532,7 @@ function beautify(input) {
 
         lines.push({
             depth: Math.max(0, depth),
-            text: renderLine(current)
+            tokens: current
         });
         current = [];
     }
@@ -381,7 +584,7 @@ function beautify(input) {
             flushCurrent();
             lines.push({
                 depth: Math.max(0, depth),
-                text: token
+                tokens: [token]
             });
             continue;
         }
@@ -390,6 +593,17 @@ function beautify(input) {
             flushCurrent();
         }
 
+        if (token === "else" && inlineIfStack.length && inlineIfStack[inlineIfStack.length - 1] === "else") {
+            // The `else` of an inline `if ... then ... else ...` expression.
+            // It can appear nested inside parens/brackets (e.g. `x = (if c then
+            // a else b)`), so it must be matched regardless of bracket depth —
+            // otherwise inlineIfStack never empties and statement-splitting
+            // stays disabled for the rest of the block.
+            inlineIfStack.pop();
+            current.push(token);
+            continue;
+        }
+
         if (blockMiddle.has(token) && atStatementLevel()) {
             if (token === "else" && inlineIfStack.length) {
                 inlineIfStack.pop();
@@ -494,6 +708,23 @@ function beautify(input) {
         }
 
         if (token === ";") {
+            const table = currentTable();
+            const inTable = table &&
+                braceDepth === table.brace &&
+                parenDepth === table.paren &&
+                bracketDepth === table.bracket &&
+                blockBases.length === table.blockDepth;
+
+            if (inTable) {
+                // Inside a table constructor a `;` is just a field separator;
+                // normalize it to `,`.
+                current[current.length - 1] = ",";
+                if (table.multiline) {
+                    flushCurrent();
+                }
+                continue;
+            }
+
             flushCurrent();
             continue;
         }
@@ -558,27 +789,78 @@ function beautify(input) {
 
     flushCurrent();
 
-    return lines
-        .map(line => `${indent.repeat(line.depth)}${line.text}`.trimEnd())
+    return lines;
+}
+
+function beautify(input) {
+    return layout(input)
+        .map(line => `${indent.repeat(line.depth)}${renderLine(line.tokens)}`.trimEnd())
         .join("\n");
 }
 
+function isIdentChar(ch) {
+    return /[A-Za-z0-9_]/.test(ch);
+}
+
+function minifyNeedsSpace(prev, current) {
+    if (prev === null) {
+        return false;
+    }
+
+    const lastA = prev[prev.length - 1];
+    const firstB = current[0];
+
+    // Two word/number tokens would fuse into one (`local`+`x`, `1`+`e`).
+    if (isIdentChar(lastA) && isIdentChar(firstB)) {
+        return true;
+    }
+
+    // A numeric literal followed by `.`/`..` is ambiguous (`1`+`..` -> `1..`).
+    if (/^[0-9]/.test(prev) && firstB === ".") {
+        return true;
+    }
+
+    // Avoid two operator chars fusing into a longer token (`-`+`-` -> `--`
+    // comment, `.`+`.` -> `..`, `<`+`=` -> `<=`, `:`+`:` -> `::`, ...).
+    const pair = lastA + firstB;
+    if (pair === "--" || multiCharTokens.some(token => token.startsWith(pair))) {
+        return true;
+    }
+
+    return false;
+}
+
 function minify(input) {
-    const tokens = tokenize(input);
-    const filtered = tokens.filter(t => !isComment(t));
+    const lines = layout(input).filter(
+        line => !(line.tokens.length === 1 && isComment(line.tokens[0]))
+    );
 
-    let text = "";
+    let result = "";
     let prev = null;
 
-    for (const token of filtered) {
-        if (needsSpace(prev, token)) {
-            text += " ";
+    for (const line of lines) {
+        const tokens = line.tokens;
+        for (let k = 0; k < tokens.length; k++) {
+            const token = tokens[k];
+
+            if (prev !== null) {
+                const callable = prev === ")" || prev === "]" ||
+                    (isIdentifier(prev) && !reservedKeywords.has(prev));
+                if (k === 0 && token === "(" && callable) {
+                    // A new statement starting with `(` after a prefix-expression
+                    // would be parsed as a call continuation; separate with `;`.
+                    result += ";";
+                } else if (minifyNeedsSpace(prev, token)) {
+                    result += " ";
+                }
+            }
+
+            result += token;
+            prev = token;
         }
-        text += token;
-        prev = token;
     }
 
-    return text;
+    return result;
 }
 
 module.exports = { beautify, minify };