nextlua 3.0.0 → 3.1.0

package/package.json

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

package/src/main.js

@@ -409,10 +409,11 @@ function needsSpace(prev, current) {
     }
 
     if (current === "(") {
-        // Control-flow keywords read better with a space before the paren
-        // (`if (`, `while (`, `elseif (`), but calls like `function(` and
-        // `foo(` stay tight.
-        return keywordsSpacedBeforeParen.has(prev);
+        // 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)) {
@@ -429,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;
     }
 
@@ -454,6 +457,18 @@ function isGenericOpen(tokens, index) {
         !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;
@@ -465,7 +480,14 @@ function joinTokens(tokens) {
         const inGeneric = genericDepth > 0;
         const opensGeneric = !inGeneric && token === "<" && isGenericOpen(tokens, idx);
 
-        if (prev !== null && !inGeneric && !opensGeneric && needsSpace(prev, token)) {
+        // 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;
@@ -571,6 +593,17 @@ function layout(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();