@danielx/civet 0.6.13 → 0.6.14

package/dist/browser.js

@@ -209,7 +209,7 @@ var Civet = (() => {
           ref.children = [makeLeftHandSideExpression(arg)];
           return {
             type: "UnwrappedExpression",
-            children: [skipIfOnlyWS(fn.leadingComment), ...body, skipIfOnlyWS(fn.trailingComment)]
+            children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
           };
         }
         expr = fn.expr;
@@ -631,12 +631,20 @@ var Civet = (() => {
           children
         };
       }
+      function isExistence(exp) {
+        if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+          exp = exp.expression;
+        }
+        if (exp.type === "Existence") {
+          return exp;
+        }
+      }
       function expandChainedComparisons([first, binops]) {
         const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
         const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
         let results = [];
         let i = 0;
-        let l = binops.length;
+        const l = binops.length;
         let start = 0;
         let chains = [];
         while (i < l) {
@@ -652,12 +660,15 @@ var Civet = (() => {
         processChains();
         return results;
         function processChains() {
+          first = expandExistence(first);
           if (chains.length > 1) {
             chains.forEach((index, k) => {
               if (k > 0) {
                 results.push(" ", "&&", " ");
               }
-              const [pre, op, post, exp] = binops[index];
+              const binop = binops[index];
+              let [pre, op, post, exp] = binop;
+              exp = binop[3] = expandExistence(exp);
               let endIndex;
               if (k < chains.length - 1) {
                 endIndex = chains[k + 1];
@@ -674,6 +685,14 @@ var Civet = (() => {
           }
           chains.length = 0;
         }
+        function expandExistence(exp) {
+          const existence = isExistence(exp);
+          if (existence) {
+            results.push(existence, " ", "&&", " ");
+            return existence.expression;
+          }
+          return exp;
+        }
       }
       function processParams(f) {
         const { type, parameters, block } = f;
@@ -1126,6 +1145,7 @@ var Civet = (() => {
       function makeLeftHandSideExpression(expression) {
         switch (expression.type) {
           case "Ref":
+          case "AmpersandRef":
           case "Identifier":
           case "Literal":
           case "CallExpression":
@@ -1140,7 +1160,8 @@ var Civet = (() => {
             return {
               type: "ParenthesizedExpression",
               children: ["(", expression, ")"],
-              expression
+              expression,
+              implicit: true
             };
         }
       }
@@ -2248,27 +2269,20 @@ var Civet = (() => {
         if (post?.token === "?") {
           post = {
             $loc: post.$loc,
-            token: " != null"
+            token: "!="
           };
-          switch (exp.type) {
-            case "Identifier":
-            case "Literal":
-            case "AmpersandRef":
-              return {
-                ...exp,
-                children: [...pre, ...exp.children, post]
-              };
-            default:
-              const expression = {
-                ...exp,
-                children: [...pre, "(", exp.children, ")", post]
-              };
-              return {
-                type: "ParenthesizedExpression",
-                children: ["(", expression, ")"],
-                expression
-              };
+          if (pre.length) {
+            exp = {
+              type: "UnaryExpression",
+              children: [...pre, exp, void 0]
+            };
           }
+          const existence = {
+            type: "Existence",
+            expression: exp,
+            children: [exp, " ", post, " ", "null"]
+          };
+          return makeLeftHandSideExpression(existence);
         }
         if (exp.type === "Literal") {
           if (pre.length === 1 && pre[0].token === "-") {
@@ -3141,6 +3155,7 @@ ${input.slice(result.pos)}
         OperatorAssignmentOp,
         AssignmentOpSymbol,
         CoffeeWordAssignmentOp,
+        NotDedentedBinaryOp,
         BinaryOp,
         BinaryOpSymbol,
         Xor,
@@ -3499,6 +3514,7 @@ ${input.slice(result.pos)}
         TypeIndex,
         TypeSuffix,
         ReturnTypeSuffix,
+        ReturnType,
         TypePredicate,
         Type,
         TypeBinary,
@@ -3803,7 +3819,7 @@ ${input.slice(result.pos)}
       var $R6 = $R(new RegExp("[!+-]", "suy"));
       var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
       var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
-      var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
+      var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
       var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
       var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
       var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
@@ -4684,9 +4700,9 @@ ${input.slice(result.pos)}
         var rhs = $2;
         return [[], op, [], rhs];
       });
-      var BinaryOpRHS$1 = $T($S(NewlineBinaryOpAllowed, $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS)), function(value) {
-        var rhs = value[1];
-        return rhs;
+      var BinaryOpRHS$1 = $TS($S(NewlineBinaryOpAllowed, $S(NotDedentedBinaryOp, $C(_, $S(EOS, __)), RHS)), function($skip, $loc, $0, $1, $2) {
+        var rhs = $2;
+        return [...rhs[0], ...rhs.slice(1)];
       });
       var BinaryOpRHS$2 = $T($S($N(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
         return value[1];
@@ -4825,10 +4841,7 @@ ${input.slice(result.pos)}
         }
       }
       var UnaryPostfix$0 = QuestionMark;
-      var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
-        return { "ts": true, "children": value };
-      });
-      var UnaryPostfix$2 = $T($P($S(__, Satisfies, Type)), function(value) {
+      var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
         return { "ts": true, "children": value };
       });
       function UnaryPostfix(state) {
@@ -4842,12 +4855,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state));
+          const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
           if (state.events)
             state.events.exit?.("UnaryPostfix", state, result, eventData);
           return result;
         } else {
-          const result = UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state);
+          const result = UnaryPostfix$0(state) || UnaryPostfix$1(state);
           if (state.events)
             state.events.exit?.("UnaryPostfix", state, result, eventData);
           return result;
@@ -5458,6 +5471,15 @@ ${input.slice(result.pos)}
         switch (exp.type) {
           case "IterationExpression":
             return exp;
+          case "ParenthesizedExpression":
+            if (exp.implicit) {
+              return {
+                ...exp,
+                children: [open, exp.expression, ws, close],
+                implicit: false
+              };
+            }
+            break;
         }
         return {
           type: "ParenthesizedExpression",
@@ -7898,17 +7920,29 @@ ${input.slice(result.pos)}
           return $skip;
         let body, ref;
         if (!rhs) {
-          ref = {
+          body = ref = {
             type: "Ref",
             base: "$",
             id: "$"
           };
-          body = [prefix, ref];
         } else {
-          ({ ref } = rhs);
-          body = [prefix, rhs];
+          let exp = rhs;
+          while (!exp.ref && exp.expression) {
+            exp = exp.expression;
+          }
+          ({ ref } = exp);
+          if (!ref) {
+            throw new Error("Could not find ref in ampersand shorthand block");
+          }
+          body = rhs;
+        }
+        if (prefix) {
+          body = {
+            type: "UnaryExpression",
+            children: [prefix, body, void 0]
+          };
         }
-        const children = [ref, " => ", ...body];
+        const children = [ref, " => ", body];
         if (hasAwait(body)) {
           children.unshift("async ");
         }
@@ -8068,7 +8102,7 @@ ${input.slice(result.pos)}
         var callExpRest = $1;
         var unaryPostfix = $2;
         var binopRHS = $3;
-        if (!callExpRest && !binopRHS)
+        if (!callExpRest && !binopRHS && !unaryPostfix)
           return $skip;
         const ref = {
           type: "Ref",
@@ -10572,6 +10606,42 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var NotDedentedBinaryOp$0 = $TS($S($E(IndentedFurther), $E(_), BinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+        const ws = [];
+        if ($1)
+          ws.push(...$1);
+        if ($2)
+          ws.push(...$2);
+        return [ws, $3];
+      });
+      var NotDedentedBinaryOp$1 = $TS($S(Samedent, $E(_), $N(Identifier), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
+        const ws = [...$1];
+        if ($2)
+          ws.push(...$2);
+        return [ws, $4];
+      });
+      function NotDedentedBinaryOp(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("NotDedentedBinaryOp", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("NotDedentedBinaryOp", state, NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state));
+          if (state.events)
+            state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+          return result;
+        } else {
+          const result = NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state);
+          if (state.events)
+            state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+          return result;
+        }
+      }
       var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
         if (typeof $1 === "string")
           return { $loc, token: $1 };
@@ -10901,7 +10971,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+      var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         return { $loc, token: $0 };
       });
       var UnaryOp$1 = AwaitOp;
@@ -11390,6 +11460,8 @@ ${input.slice(result.pos)}
         var kind = $1;
         var condition = $2;
         kind = { ...kind, token: "if" };
+        kind.token += getTrimmingSpace(condition);
+        condition = insertTrimmingSpace(condition, "");
         return {
           type: "IfStatement",
           children: [kind, ["(!", condition, ")"]],
@@ -21159,27 +21231,54 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L202, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
-        var asserts = $3;
-        var t = $4;
+      var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, ReturnType), function($skip, $loc, $0, $1, $2, $3) {
+        var t = $3;
+        return { ...t, children: [$1, $2, ...t.children] };
+      });
+      function ReturnTypeSuffix(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("ReturnTypeSuffix", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+          if (state.events)
+            state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          return result;
+        } else {
+          const result = ReturnTypeSuffix$0(state);
+          if (state.events)
+            state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          return result;
+        }
+      }
+      var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L202, fail, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+        var asserts = $1;
+        var t = $2;
         if (asserts) {
           t = {
             type: "AssertsType",
             t,
-            children: [asserts[0], asserts[1], t]
+            children: [asserts[0], asserts[1], t],
+            ts: true
           };
         }
         return {
           type: "ReturnTypeAnnotation",
-          children: [$1, $2, t],
+          children: [t],
           t,
           ts: true
         };
       });
-      function ReturnTypeSuffix(state) {
+      function ReturnType(state) {
         let eventData;
         if (state.events) {
-          const result = state.events.enter?.("ReturnTypeSuffix", state);
+          const result = state.events.enter?.("ReturnType", state);
           if (result) {
             if (result.cache)
               return result.cache;
@@ -21187,14 +21286,14 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+          const result = $TOKEN("ReturnType", state, ReturnType$0(state));
           if (state.events)
-            state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+            state.events.exit?.("ReturnType", state, result, eventData);
           return result;
         } else {
-          const result = ReturnTypeSuffix$0(state);
+          const result = ReturnType$0(state);
           if (state.events)
-            state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+            state.events.exit?.("ReturnType", state, result, eventData);
           return result;
         }
       }
@@ -21851,7 +21950,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var FunctionType$0 = $TS($S($E($S(New, $E(_))), Parameters, __, TypeArrowFunction, $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+      var FunctionType$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var type = $5;
         if (type) {
           return $0;

package/dist/main.js

@@ -208,7 +208,7 @@ var require_lib = __commonJS({
         ref.children = [makeLeftHandSideExpression(arg)];
         return {
           type: "UnwrappedExpression",
-          children: [skipIfOnlyWS(fn.leadingComment), ...body, skipIfOnlyWS(fn.trailingComment)]
+          children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
         };
       }
       expr = fn.expr;
@@ -630,12 +630,20 @@ var require_lib = __commonJS({
         children
       };
     }
+    function isExistence(exp) {
+      if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+        exp = exp.expression;
+      }
+      if (exp.type === "Existence") {
+        return exp;
+      }
+    }
     function expandChainedComparisons([first, binops]) {
       const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
       const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
       let results = [];
       let i = 0;
-      let l = binops.length;
+      const l = binops.length;
       let start = 0;
       let chains = [];
       while (i < l) {
@@ -651,12 +659,15 @@ var require_lib = __commonJS({
       processChains();
       return results;
       function processChains() {
+        first = expandExistence(first);
         if (chains.length > 1) {
           chains.forEach((index, k) => {
             if (k > 0) {
               results.push(" ", "&&", " ");
             }
-            const [pre, op, post, exp] = binops[index];
+            const binop = binops[index];
+            let [pre, op, post, exp] = binop;
+            exp = binop[3] = expandExistence(exp);
             let endIndex;
             if (k < chains.length - 1) {
               endIndex = chains[k + 1];
@@ -673,6 +684,14 @@ var require_lib = __commonJS({
         }
         chains.length = 0;
       }
+      function expandExistence(exp) {
+        const existence = isExistence(exp);
+        if (existence) {
+          results.push(existence, " ", "&&", " ");
+          return existence.expression;
+        }
+        return exp;
+      }
     }
     function processParams(f) {
       const { type, parameters, block } = f;
@@ -1125,6 +1144,7 @@ var require_lib = __commonJS({
     function makeLeftHandSideExpression(expression) {
       switch (expression.type) {
         case "Ref":
+        case "AmpersandRef":
         case "Identifier":
         case "Literal":
         case "CallExpression":
@@ -1139,7 +1159,8 @@ var require_lib = __commonJS({
           return {
             type: "ParenthesizedExpression",
             children: ["(", expression, ")"],
-            expression
+            expression,
+            implicit: true
           };
       }
     }
@@ -2247,27 +2268,20 @@ var require_lib = __commonJS({
       if (post?.token === "?") {
         post = {
           $loc: post.$loc,
-          token: " != null"
+          token: "!="
         };
-        switch (exp.type) {
-          case "Identifier":
-          case "Literal":
-          case "AmpersandRef":
-            return {
-              ...exp,
-              children: [...pre, ...exp.children, post]
-            };
-          default:
-            const expression = {
-              ...exp,
-              children: [...pre, "(", exp.children, ")", post]
-            };
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression
-            };
+        if (pre.length) {
+          exp = {
+            type: "UnaryExpression",
+            children: [...pre, exp, void 0]
+          };
         }
+        const existence = {
+          type: "Existence",
+          expression: exp,
+          children: [exp, " ", post, " ", "null"]
+        };
+        return makeLeftHandSideExpression(existence);
       }
       if (exp.type === "Literal") {
         if (pre.length === 1 && pre[0].token === "-") {
@@ -3140,6 +3154,7 @@ ${input.slice(result.pos)}
       OperatorAssignmentOp,
       AssignmentOpSymbol,
       CoffeeWordAssignmentOp,
+      NotDedentedBinaryOp,
       BinaryOp,
       BinaryOpSymbol,
       Xor,
@@ -3498,6 +3513,7 @@ ${input.slice(result.pos)}
       TypeIndex,
       TypeSuffix,
       ReturnTypeSuffix,
+      ReturnType,
       TypePredicate,
       Type,
       TypeBinary,
@@ -3802,7 +3818,7 @@ ${input.slice(result.pos)}
     var $R6 = $R(new RegExp("[!+-]", "suy"));
     var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
     var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
-    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
+    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
     var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
     var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
     var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
@@ -4683,9 +4699,9 @@ ${input.slice(result.pos)}
       var rhs = $2;
       return [[], op, [], rhs];
     });
-    var BinaryOpRHS$1 = $T($S(NewlineBinaryOpAllowed, $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS)), function(value) {
-      var rhs = value[1];
-      return rhs;
+    var BinaryOpRHS$1 = $TS($S(NewlineBinaryOpAllowed, $S(NotDedentedBinaryOp, $C(_, $S(EOS, __)), RHS)), function($skip, $loc, $0, $1, $2) {
+      var rhs = $2;
+      return [...rhs[0], ...rhs.slice(1)];
     });
     var BinaryOpRHS$2 = $T($S($N(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
       return value[1];
@@ -4824,10 +4840,7 @@ ${input.slice(result.pos)}
       }
     }
     var UnaryPostfix$0 = QuestionMark;
-    var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
-      return { "ts": true, "children": value };
-    });
-    var UnaryPostfix$2 = $T($P($S(__, Satisfies, Type)), function(value) {
+    var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
       return { "ts": true, "children": value };
     });
     function UnaryPostfix(state) {
@@ -4841,12 +4854,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state));
+        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
       } else {
-        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state);
+        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state);
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
@@ -5457,6 +5470,15 @@ ${input.slice(result.pos)}
       switch (exp.type) {
         case "IterationExpression":
           return exp;
+        case "ParenthesizedExpression":
+          if (exp.implicit) {
+            return {
+              ...exp,
+              children: [open, exp.expression, ws, close],
+              implicit: false
+            };
+          }
+          break;
       }
       return {
         type: "ParenthesizedExpression",
@@ -7897,17 +7919,29 @@ ${input.slice(result.pos)}
         return $skip;
       let body, ref;
       if (!rhs) {
-        ref = {
+        body = ref = {
           type: "Ref",
           base: "$",
           id: "$"
         };
-        body = [prefix, ref];
       } else {
-        ({ ref } = rhs);
-        body = [prefix, rhs];
+        let exp = rhs;
+        while (!exp.ref && exp.expression) {
+          exp = exp.expression;
+        }
+        ({ ref } = exp);
+        if (!ref) {
+          throw new Error("Could not find ref in ampersand shorthand block");
+        }
+        body = rhs;
+      }
+      if (prefix) {
+        body = {
+          type: "UnaryExpression",
+          children: [prefix, body, void 0]
+        };
       }
-      const children = [ref, " => ", ...body];
+      const children = [ref, " => ", body];
       if (hasAwait(body)) {
         children.unshift("async ");
       }
@@ -8067,7 +8101,7 @@ ${input.slice(result.pos)}
       var callExpRest = $1;
       var unaryPostfix = $2;
       var binopRHS = $3;
-      if (!callExpRest && !binopRHS)
+      if (!callExpRest && !binopRHS && !unaryPostfix)
         return $skip;
       const ref = {
         type: "Ref",
@@ -10571,6 +10605,42 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NotDedentedBinaryOp$0 = $TS($S($E(IndentedFurther), $E(_), BinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+      const ws = [];
+      if ($1)
+        ws.push(...$1);
+      if ($2)
+        ws.push(...$2);
+      return [ws, $3];
+    });
+    var NotDedentedBinaryOp$1 = $TS($S(Samedent, $E(_), $N(Identifier), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
+      const ws = [...$1];
+      if ($2)
+        ws.push(...$2);
+      return [ws, $4];
+    });
+    function NotDedentedBinaryOp(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NotDedentedBinaryOp", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NotDedentedBinaryOp", state, NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state));
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      } else {
+        const result = NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state);
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      }
+    }
     var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
       if (typeof $1 === "string")
         return { $loc, token: $1 };
@@ -10900,7 +10970,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
     var UnaryOp$1 = AwaitOp;
@@ -11389,6 +11459,8 @@ ${input.slice(result.pos)}
       var kind = $1;
       var condition = $2;
       kind = { ...kind, token: "if" };
+      kind.token += getTrimmingSpace(condition);
+      condition = insertTrimmingSpace(condition, "");
       return {
         type: "IfStatement",
         children: [kind, ["(!", condition, ")"]],
@@ -21158,27 +21230,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L202, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var asserts = $3;
-      var t = $4;
+    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, ReturnType), function($skip, $loc, $0, $1, $2, $3) {
+      var t = $3;
+      return { ...t, children: [$1, $2, ...t.children] };
+    });
+    function ReturnTypeSuffix(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      } else {
+        const result = ReturnTypeSuffix$0(state);
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      }
+    }
+    var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L202, fail, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var asserts = $1;
+      var t = $2;
       if (asserts) {
         t = {
           type: "AssertsType",
           t,
-          children: [asserts[0], asserts[1], t]
+          children: [asserts[0], asserts[1], t],
+          ts: true
         };
       }
       return {
         type: "ReturnTypeAnnotation",
-        children: [$1, $2, t],
+        children: [t],
         t,
         ts: true
       };
     });
-    function ReturnTypeSuffix(state) {
+    function ReturnType(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        const result = state.events.enter?.("ReturnType", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -21186,14 +21285,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        const result = $TOKEN("ReturnType", state, ReturnType$0(state));
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       } else {
-        const result = ReturnTypeSuffix$0(state);
+        const result = ReturnType$0(state);
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       }
     }
@@ -21850,7 +21949,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FunctionType$0 = $TS($S($E($S(New, $E(_))), Parameters, __, TypeArrowFunction, $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var FunctionType$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var type = $5;
       if (type) {
         return $0;

package/dist/main.mjs

@@ -206,7 +206,7 @@ var require_lib = __commonJS({
         ref.children = [makeLeftHandSideExpression(arg)];
         return {
           type: "UnwrappedExpression",
-          children: [skipIfOnlyWS(fn.leadingComment), ...body, skipIfOnlyWS(fn.trailingComment)]
+          children: [skipIfOnlyWS(fn.leadingComment), body, skipIfOnlyWS(fn.trailingComment)]
         };
       }
       expr = fn.expr;
@@ -628,12 +628,20 @@ var require_lib = __commonJS({
         children
       };
     }
+    function isExistence(exp) {
+      if (exp.type === "ParenthesizedExpression" && exp.implicit) {
+        exp = exp.expression;
+      }
+      if (exp.type === "Existence") {
+        return exp;
+      }
+    }
     function expandChainedComparisons([first, binops]) {
       const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
       const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
       let results = [];
       let i = 0;
-      let l = binops.length;
+      const l = binops.length;
       let start = 0;
       let chains = [];
       while (i < l) {
@@ -649,12 +657,15 @@ var require_lib = __commonJS({
       processChains();
       return results;
       function processChains() {
+        first = expandExistence(first);
         if (chains.length > 1) {
           chains.forEach((index, k) => {
             if (k > 0) {
               results.push(" ", "&&", " ");
             }
-            const [pre, op, post, exp] = binops[index];
+            const binop = binops[index];
+            let [pre, op, post, exp] = binop;
+            exp = binop[3] = expandExistence(exp);
             let endIndex;
             if (k < chains.length - 1) {
               endIndex = chains[k + 1];
@@ -671,6 +682,14 @@ var require_lib = __commonJS({
         }
         chains.length = 0;
       }
+      function expandExistence(exp) {
+        const existence = isExistence(exp);
+        if (existence) {
+          results.push(existence, " ", "&&", " ");
+          return existence.expression;
+        }
+        return exp;
+      }
     }
     function processParams(f) {
       const { type, parameters, block } = f;
@@ -1123,6 +1142,7 @@ var require_lib = __commonJS({
     function makeLeftHandSideExpression(expression) {
       switch (expression.type) {
         case "Ref":
+        case "AmpersandRef":
         case "Identifier":
         case "Literal":
         case "CallExpression":
@@ -1137,7 +1157,8 @@ var require_lib = __commonJS({
           return {
             type: "ParenthesizedExpression",
             children: ["(", expression, ")"],
-            expression
+            expression,
+            implicit: true
           };
       }
     }
@@ -2245,27 +2266,20 @@ var require_lib = __commonJS({
       if (post?.token === "?") {
         post = {
           $loc: post.$loc,
-          token: " != null"
+          token: "!="
         };
-        switch (exp.type) {
-          case "Identifier":
-          case "Literal":
-          case "AmpersandRef":
-            return {
-              ...exp,
-              children: [...pre, ...exp.children, post]
-            };
-          default:
-            const expression = {
-              ...exp,
-              children: [...pre, "(", exp.children, ")", post]
-            };
-            return {
-              type: "ParenthesizedExpression",
-              children: ["(", expression, ")"],
-              expression
-            };
+        if (pre.length) {
+          exp = {
+            type: "UnaryExpression",
+            children: [...pre, exp, void 0]
+          };
         }
+        const existence = {
+          type: "Existence",
+          expression: exp,
+          children: [exp, " ", post, " ", "null"]
+        };
+        return makeLeftHandSideExpression(existence);
       }
       if (exp.type === "Literal") {
         if (pre.length === 1 && pre[0].token === "-") {
@@ -3138,6 +3152,7 @@ ${input.slice(result.pos)}
       OperatorAssignmentOp,
       AssignmentOpSymbol,
       CoffeeWordAssignmentOp,
+      NotDedentedBinaryOp,
       BinaryOp,
       BinaryOpSymbol,
       Xor,
@@ -3496,6 +3511,7 @@ ${input.slice(result.pos)}
       TypeIndex,
       TypeSuffix,
       ReturnTypeSuffix,
+      ReturnType,
       TypePredicate,
       Type,
       TypeBinary,
@@ -3800,7 +3816,7 @@ ${input.slice(result.pos)}
     var $R6 = $R(new RegExp("[!+-]", "suy"));
     var $R7 = $R(new RegExp("<(?!\\p{ID_Start}|[_$])", "suy"));
     var $R8 = $R(new RegExp("!\\^\\^?", "suy"));
-    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)", "suy"));
+    var $R9 = $R(new RegExp("(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])", "suy"));
     var $R10 = $R(new RegExp("(?=[\\s\\)])", "suy"));
     var $R11 = $R(new RegExp('[^;"\\s]+', "suy"));
     var $R12 = $R(new RegExp("(?:0|[1-9](?:_[0-9]|[0-9])*)n", "suy"));
@@ -4681,9 +4697,9 @@ ${input.slice(result.pos)}
       var rhs = $2;
       return [[], op, [], rhs];
     });
-    var BinaryOpRHS$1 = $T($S(NewlineBinaryOpAllowed, $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS)), function(value) {
-      var rhs = value[1];
-      return rhs;
+    var BinaryOpRHS$1 = $TS($S(NewlineBinaryOpAllowed, $S(NotDedentedBinaryOp, $C(_, $S(EOS, __)), RHS)), function($skip, $loc, $0, $1, $2) {
+      var rhs = $2;
+      return [...rhs[0], ...rhs.slice(1)];
     });
     var BinaryOpRHS$2 = $T($S($N(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
       return value[1];
@@ -4822,10 +4838,7 @@ ${input.slice(result.pos)}
       }
     }
     var UnaryPostfix$0 = QuestionMark;
-    var UnaryPostfix$1 = $T($P($S(__, As, Type)), function(value) {
-      return { "ts": true, "children": value };
-    });
-    var UnaryPostfix$2 = $T($P($S(__, Satisfies, Type)), function(value) {
+    var UnaryPostfix$1 = $T($P($S(__, $C(As, Satisfies), Type)), function(value) {
       return { "ts": true, "children": value };
     });
     function UnaryPostfix(state) {
@@ -4839,12 +4852,12 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state));
+        const result = $TOKEN("UnaryPostfix", state, UnaryPostfix$0(state) || UnaryPostfix$1(state));
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
       } else {
-        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state) || UnaryPostfix$2(state);
+        const result = UnaryPostfix$0(state) || UnaryPostfix$1(state);
         if (state.events)
           state.events.exit?.("UnaryPostfix", state, result, eventData);
         return result;
@@ -5455,6 +5468,15 @@ ${input.slice(result.pos)}
       switch (exp.type) {
         case "IterationExpression":
           return exp;
+        case "ParenthesizedExpression":
+          if (exp.implicit) {
+            return {
+              ...exp,
+              children: [open, exp.expression, ws, close],
+              implicit: false
+            };
+          }
+          break;
       }
       return {
         type: "ParenthesizedExpression",
@@ -7895,17 +7917,29 @@ ${input.slice(result.pos)}
         return $skip;
       let body, ref;
       if (!rhs) {
-        ref = {
+        body = ref = {
           type: "Ref",
           base: "$",
           id: "$"
         };
-        body = [prefix, ref];
       } else {
-        ({ ref } = rhs);
-        body = [prefix, rhs];
+        let exp = rhs;
+        while (!exp.ref && exp.expression) {
+          exp = exp.expression;
+        }
+        ({ ref } = exp);
+        if (!ref) {
+          throw new Error("Could not find ref in ampersand shorthand block");
+        }
+        body = rhs;
+      }
+      if (prefix) {
+        body = {
+          type: "UnaryExpression",
+          children: [prefix, body, void 0]
+        };
       }
-      const children = [ref, " => ", ...body];
+      const children = [ref, " => ", body];
       if (hasAwait(body)) {
         children.unshift("async ");
       }
@@ -8065,7 +8099,7 @@ ${input.slice(result.pos)}
       var callExpRest = $1;
       var unaryPostfix = $2;
       var binopRHS = $3;
-      if (!callExpRest && !binopRHS)
+      if (!callExpRest && !binopRHS && !unaryPostfix)
         return $skip;
       const ref = {
         type: "Ref",
@@ -10569,6 +10603,42 @@ ${input.slice(result.pos)}
         return result;
       }
     }
+    var NotDedentedBinaryOp$0 = $TS($S($E(IndentedFurther), $E(_), BinaryOp), function($skip, $loc, $0, $1, $2, $3) {
+      const ws = [];
+      if ($1)
+        ws.push(...$1);
+      if ($2)
+        ws.push(...$2);
+      return [ws, $3];
+    });
+    var NotDedentedBinaryOp$1 = $TS($S(Samedent, $E(_), $N(Identifier), BinaryOp), function($skip, $loc, $0, $1, $2, $3, $4) {
+      const ws = [...$1];
+      if ($2)
+        ws.push(...$2);
+      return [ws, $4];
+    });
+    function NotDedentedBinaryOp(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("NotDedentedBinaryOp", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("NotDedentedBinaryOp", state, NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state));
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      } else {
+        const result = NotDedentedBinaryOp$0(state) || NotDedentedBinaryOp$1(state);
+        if (state.events)
+          state.events.exit?.("NotDedentedBinaryOp", state, result, eventData);
+        return result;
+      }
+    }
     var BinaryOp$0 = $TS($S(BinaryOpSymbol), function($skip, $loc, $0, $1) {
       if (typeof $1 === "string")
         return { $loc, token: $1 };
@@ -10898,7 +10968,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*&)/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
+    var UnaryOp$0 = $TR($EXPECT($R9, fail, "UnaryOp /(?!\\+\\+|--)[!~+-](?!\\s|[!~+-]*[&.])/"), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
       return { $loc, token: $0 };
     });
     var UnaryOp$1 = AwaitOp;
@@ -11387,6 +11457,8 @@ ${input.slice(result.pos)}
       var kind = $1;
       var condition = $2;
       kind = { ...kind, token: "if" };
+      kind.token += getTrimmingSpace(condition);
+      condition = insertTrimmingSpace(condition, "");
       return {
         type: "IfStatement",
         children: [kind, ["(!", condition, ")"]],
@@ -21156,27 +21228,54 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, $E($S(__, $EXPECT($L202, fail, 'ReturnTypeSuffix "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2, $3, $4) {
-      var asserts = $3;
-      var t = $4;
+    var ReturnTypeSuffix$0 = $TS($S($E(_), Colon, ReturnType), function($skip, $loc, $0, $1, $2, $3) {
+      var t = $3;
+      return { ...t, children: [$1, $2, ...t.children] };
+    });
+    function ReturnTypeSuffix(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      } else {
+        const result = ReturnTypeSuffix$0(state);
+        if (state.events)
+          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+        return result;
+      }
+    }
+    var ReturnType$0 = $TS($S($E($S(__, $EXPECT($L202, fail, 'ReturnType "asserts"'), NonIdContinue)), TypePredicate), function($skip, $loc, $0, $1, $2) {
+      var asserts = $1;
+      var t = $2;
       if (asserts) {
         t = {
           type: "AssertsType",
           t,
-          children: [asserts[0], asserts[1], t]
+          children: [asserts[0], asserts[1], t],
+          ts: true
         };
       }
       return {
         type: "ReturnTypeAnnotation",
-        children: [$1, $2, t],
+        children: [t],
         t,
         ts: true
       };
     });
-    function ReturnTypeSuffix(state) {
+    function ReturnType(state) {
       let eventData;
       if (state.events) {
-        const result = state.events.enter?.("ReturnTypeSuffix", state);
+        const result = state.events.enter?.("ReturnType", state);
         if (result) {
           if (result.cache)
             return result.cache;
@@ -21184,14 +21283,14 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("ReturnTypeSuffix", state, ReturnTypeSuffix$0(state));
+        const result = $TOKEN("ReturnType", state, ReturnType$0(state));
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       } else {
-        const result = ReturnTypeSuffix$0(state);
+        const result = ReturnType$0(state);
         if (state.events)
-          state.events.exit?.("ReturnTypeSuffix", state, result, eventData);
+          state.events.exit?.("ReturnType", state, result, eventData);
         return result;
       }
     }
@@ -21848,7 +21947,7 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var FunctionType$0 = $TS($S($E($S(New, $E(_))), Parameters, __, TypeArrowFunction, $E(Type)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var FunctionType$0 = $TS($S($E($S($E($S(Abstract, $E(_))), New, $E(_))), Parameters, __, TypeArrowFunction, $E(ReturnType)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var type = $5;
       if (type) {
         return $0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danielx/civet",
-  "version": "0.6.13",
+  "version": "0.6.14",
   "description": "CoffeeScript style syntax for TypeScript",
   "main": "dist/main.js",
   "module": "dist/main.mjs",