@danielx/civet 0.5.89 → 0.5.90

package/dist/browser.js

@@ -436,16 +436,18 @@ var Civet = (() => {
         }
         let [splices, thisAssignments] = gatherBindingCode(id);
         splices = splices.map((s) => [", ", s]);
-        thisAssignments = thisAssignments.map((a) => [";", a]);
+        thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
         const binding = [c, id, suffix, ...ws];
-        const initializer = [ca, e, ...splices, ...thisAssignments];
+        const initializer = [ca, e];
         const children = [binding, initializer];
         return {
           type: "Declaration",
           names: id.names,
           children,
           binding,
-          initializer
+          initializer,
+          splices,
+          thisAssignments
         };
       }
       function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
@@ -458,18 +460,87 @@ var Civet = (() => {
         };
         let [splices, thisAssignments] = gatherBindingCode(id);
         splices = splices.map((s) => [", ", s]);
-        thisAssignments = thisAssignments.map((a) => [";", a]);
+        thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
         const binding = [l, id, suffix, ...ws];
-        const initializer = [la, e, ...splices, ...thisAssignments];
+        const initializer = [la, e];
         const children = [binding, initializer];
         return {
           type: "Declaration",
           names: id.names,
           children,
           binding,
-          initializer
+          initializer,
+          splices,
+          thisAssignments
         };
       }
+      function processUnaryExpression(pre, exp, post) {
+        if (post?.token === "?") {
+          post = {
+            $loc: post.$loc,
+            token: " != null"
+          };
+          switch (exp.type) {
+            case "Identifier":
+            case "Literal":
+              return {
+                ...exp,
+                children: [...pre, ...exp.children, post]
+              };
+            default:
+              const expression = {
+                ...exp,
+                children: [...pre, "(", exp.children, ")", post]
+              };
+              return {
+                type: "ParenthesizedExpression",
+                children: ["(", expression, ")"],
+                expression
+              };
+          }
+        }
+        if (exp.type === "Literal") {
+          if (pre.length === 1 && pre[0].token === "-") {
+            const children = [pre[0], ...exp.children];
+            if (post)
+              exp.children.push(post);
+            return {
+              type: "Literal",
+              children,
+              raw: `-${exp.raw}`
+            };
+          }
+        }
+        const l = pre.length;
+        if (l) {
+          const last = pre[l - 1];
+          if (last.type === "Await" && last.op) {
+            if (exp.type !== "ParenthesizedExpression") {
+              exp = ["(", exp, ")"];
+            }
+            exp = {
+              type: "CallExpression",
+              children: [" Promise", last.op, exp]
+            };
+          }
+        }
+        if (exp.children) {
+          const children = [...pre, ...exp.children];
+          if (post)
+            children.push(post);
+          return Object.assign({}, exp, { children });
+        } else if (Array.isArray(exp)) {
+          const children = [...pre, ...exp];
+          if (post)
+            children.push(post);
+          return { children };
+        } else {
+          const children = [...pre, exp];
+          if (post)
+            children.push(post);
+          return { children };
+        }
+      }
       module.exports = {
         blockWithPrefix,
         clone,
@@ -493,6 +564,7 @@ var Civet = (() => {
         processCoffeeInterpolation,
         processConstAssignmentDeclaration,
         processLetAssignmentDeclaration,
+        processUnaryExpression,
         quoteString,
         removeParentPointers
       };
@@ -1116,6 +1188,7 @@ ${input.slice(result.pos)}
         Xor,
         Xnor,
         UnaryOp,
+        AwaitOp,
         ModuleItem,
         StatementListItem,
         PostfixedStatement,
@@ -2659,7 +2732,7 @@ ${input.slice(result.pos)}
         var pre = $1;
         var exp = $2;
         var post = $3;
-        return module.processUnaryExpression(pre, exp, post);
+        return processUnaryExpression(pre, exp, post);
       });
       var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
         var ws = $3;
@@ -9070,8 +9143,9 @@ ${input.slice(result.pos)}
       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 = $S($C(Await, Delete, Void, Typeof), __);
-      var UnaryOp$2 = Not;
+      var UnaryOp$1 = AwaitOp;
+      var UnaryOp$2 = $S($C(Delete, Void, Typeof), $E(_));
+      var UnaryOp$3 = Not;
       function UnaryOp(state) {
         let eventData;
         if (state.events) {
@@ -9083,17 +9157,52 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state));
+          const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state));
           if (state.events)
             state.events.exit?.("UnaryOp", state, result, eventData);
           return result;
         } else {
-          const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state);
+          const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state);
           if (state.events)
             state.events.exit?.("UnaryOp", state, result, eventData);
           return result;
         }
       }
+      var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $C(_, $Y(OpenParen))), function($skip, $loc, $0, $1, $2, $3) {
+        var a = $1;
+        var op = $2;
+        var ws = $3;
+        if (op) {
+          return {
+            ...a,
+            op,
+            children: [a, ...ws || []]
+          };
+        }
+        return [a, ...ws || []];
+      });
+      function AwaitOp(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("AwaitOp", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("AwaitOp", state, AwaitOp$0(state));
+          if (state.events)
+            state.events.exit?.("AwaitOp", state, result, eventData);
+          return result;
+        } else {
+          const result = AwaitOp$0(state);
+          if (state.events)
+            state.events.exit?.("AwaitOp", state, result, eventData);
+          return result;
+        }
+      }
       var ModuleItem$0 = ImportDeclaration;
       var ModuleItem$1 = ExportDeclaration;
       var ModuleItem$2 = StatementListItem;
@@ -11180,12 +11289,15 @@ ${input.slice(result.pos)}
           type: "Ref",
           base: "ref"
         };
-        const { binding, initializer } = dec;
+        const { binding, initializer, splices, thisAssignments } = dec;
         const initCondition = {
           type: "AssignmentExpression",
           children: [ref, " ", initializer],
           hoistDec: [["", ["let ", ref], ";"]],
-          blockPrefix: [["", [binding, "= ", ref], ";"]]
+          blockPrefix: [
+            ["", [binding, "= ", ref, ...splices], ";"],
+            ...thisAssignments
+          ]
         };
         return initCondition;
       });
@@ -12580,7 +12692,20 @@ ${input.slice(result.pos)}
       }
       var Declaration$0 = HoistableDeclaration;
       var Declaration$1 = ClassDeclaration;
-      var Declaration$2 = LexicalDeclaration;
+      var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+        var d = $0;
+        if (d.thisAssignments?.length)
+          return {
+            ...d,
+            children: [...d.children, ...d.splices, ";", ...d.thisAssignments]
+          };
+        if (d.splices?.length)
+          return {
+            ...d,
+            children: [...d.children, ...d.splices]
+          };
+        return d;
+      });
       var Declaration$3 = TypeDeclaration;
       var Declaration$4 = EnumDeclaration;
       var Declaration$5 = OperatorDeclaration;
@@ -12630,12 +12755,21 @@ ${input.slice(result.pos)}
         }
       }
       var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
+        var d = $1;
         var binding = $2;
         var tail = $3;
+        const { splices, thisAssignments } = binding;
         return {
           type: "Declaration",
           children: $0,
-          names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names))
+          names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names)),
+          binding: {
+            ...binding.binding,
+            children: [d, ...binding.binding.children]
+          },
+          initializer: binding.initializer,
+          splices,
+          thisAssignments
         };
       });
       var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -12722,25 +12856,51 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        children.push($3);
+      var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), $E(_), Initializer), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var binding = $1;
+        var suffix = $2;
+        var ws = $3;
+        var initializer = $4;
+        const bindingChildren = [...binding.children];
+        if (suffix)
+          bindingChildren.push(suffix);
+        if (ws)
+          bindingChildren.push(...ws);
+        binding = {
+          ...binding,
+          children: bindingChildren
+        };
+        const [splices, thisAssignments] = gatherBindingCode(binding.children);
         return {
-          children,
-          names: $1.names
+          children: [binding, initializer],
+          names: binding.names,
+          binding,
+          initializer,
+          splices: splices.map((s) => [",", s]),
+          thisAssignments: thisAssignments.map((s) => ["", s, ";"])
         };
       });
-      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
-        const children = [...$1.children];
-        if ($2)
-          children.push($2);
-        if ($3)
-          children.push($3);
+      var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(_), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var binding = $1;
+        var suffix = $2;
+        var ws = $3;
+        var initializer = $4;
+        const bindingChildren = [...binding.children];
+        if (suffix)
+          bindingChildren.push(suffix);
+        if (ws)
+          bindingChildren.push(...ws);
+        binding = {
+          ...binding,
+          children: bindingChildren
+        };
         return {
-          children,
-          names: $1.names
+          children: [binding, initializer],
+          names: binding.names,
+          binding,
+          initializer,
+          splices: [],
+          thisAssignments: []
         };
       });
       function LexicalBinding(state) {
@@ -17299,7 +17459,7 @@ ${input.slice(result.pos)}
         var pre = $1;
         var exp = $2;
         var post = $3;
-        return module.processUnaryExpression(pre, exp, post);
+        return processUnaryExpression(pre, exp, post);
       });
       function InlineJSXUnaryExpression(state) {
         let eventData;
@@ -21189,60 +21349,6 @@ ${input.slice(result.pos)}
           }
           return node;
         };
-        module.processUnaryExpression = (pre, exp, post) => {
-          if (post?.token === "?") {
-            post = {
-              $loc: post.$loc,
-              token: " != null"
-            };
-            switch (exp.type) {
-              case "Identifier":
-              case "Literal":
-                return {
-                  ...exp,
-                  children: [...pre, ...exp.children, post]
-                };
-              default:
-                const expression = {
-                  ...exp,
-                  children: [...pre, "(", exp.children, ")", post]
-                };
-                return {
-                  type: "ParenthesizedExpression",
-                  children: ["(", expression, ")"],
-                  expression
-                };
-            }
-          }
-          if (exp.type === "Literal") {
-            if (pre.length === 1 && pre[0].token === "-") {
-              const children = [pre[0], ...exp.children];
-              if (post)
-                exp.children.push(post);
-              return {
-                type: "Literal",
-                children,
-                raw: `-${exp.raw}`
-              };
-            }
-          }
-          if (exp.children) {
-            const children = [...pre, ...exp.children];
-            if (post)
-              children.push(post);
-            return Object.assign({}, exp, { children });
-          } else if (Array.isArray(exp)) {
-            const children = [...pre, ...exp];
-            if (post)
-              children.push(post);
-            return { children };
-          } else {
-            const children = [...pre, exp];
-            if (post)
-              children.push(post);
-            return { children };
-          }
-        };
         module.needsRef = function(expression, base = "ref") {
           switch (expression.type) {
             case "Ref":
@@ -23186,6 +23292,7 @@ ${input.slice(result.pos)}
         processCoffeeInterpolation,
         processConstAssignmentDeclaration,
         processLetAssignmentDeclaration,
+        processUnaryExpression,
         quoteString,
         removeParentPointers
       } = require_lib();

package/dist/main.js

@@ -435,16 +435,18 @@ var require_lib = __commonJS({
       }
       let [splices, thisAssignments] = gatherBindingCode(id);
       splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
+      thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
       const binding = [c, id, suffix, ...ws];
-      const initializer = [ca, e, ...splices, ...thisAssignments];
+      const initializer = [ca, e];
       const children = [binding, initializer];
       return {
         type: "Declaration",
         names: id.names,
         children,
         binding,
-        initializer
+        initializer,
+        splices,
+        thisAssignments
       };
     }
     function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
@@ -457,18 +459,87 @@ var require_lib = __commonJS({
       };
       let [splices, thisAssignments] = gatherBindingCode(id);
       splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
+      thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
       const binding = [l, id, suffix, ...ws];
-      const initializer = [la, e, ...splices, ...thisAssignments];
+      const initializer = [la, e];
       const children = [binding, initializer];
       return {
         type: "Declaration",
         names: id.names,
         children,
         binding,
-        initializer
+        initializer,
+        splices,
+        thisAssignments
       };
     }
+    function processUnaryExpression(pre, exp, post) {
+      if (post?.token === "?") {
+        post = {
+          $loc: post.$loc,
+          token: " != null"
+        };
+        switch (exp.type) {
+          case "Identifier":
+          case "Literal":
+            return {
+              ...exp,
+              children: [...pre, ...exp.children, post]
+            };
+          default:
+            const expression = {
+              ...exp,
+              children: [...pre, "(", exp.children, ")", post]
+            };
+            return {
+              type: "ParenthesizedExpression",
+              children: ["(", expression, ")"],
+              expression
+            };
+        }
+      }
+      if (exp.type === "Literal") {
+        if (pre.length === 1 && pre[0].token === "-") {
+          const children = [pre[0], ...exp.children];
+          if (post)
+            exp.children.push(post);
+          return {
+            type: "Literal",
+            children,
+            raw: `-${exp.raw}`
+          };
+        }
+      }
+      const l = pre.length;
+      if (l) {
+        const last = pre[l - 1];
+        if (last.type === "Await" && last.op) {
+          if (exp.type !== "ParenthesizedExpression") {
+            exp = ["(", exp, ")"];
+          }
+          exp = {
+            type: "CallExpression",
+            children: [" Promise", last.op, exp]
+          };
+        }
+      }
+      if (exp.children) {
+        const children = [...pre, ...exp.children];
+        if (post)
+          children.push(post);
+        return Object.assign({}, exp, { children });
+      } else if (Array.isArray(exp)) {
+        const children = [...pre, ...exp];
+        if (post)
+          children.push(post);
+        return { children };
+      } else {
+        const children = [...pre, exp];
+        if (post)
+          children.push(post);
+        return { children };
+      }
+    }
     module2.exports = {
       blockWithPrefix,
       clone,
@@ -492,6 +563,7 @@ var require_lib = __commonJS({
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processUnaryExpression,
       quoteString,
       removeParentPointers
     };
@@ -1115,6 +1187,7 @@ ${input.slice(result.pos)}
       Xor,
       Xnor,
       UnaryOp,
+      AwaitOp,
       ModuleItem,
       StatementListItem,
       PostfixedStatement,
@@ -2658,7 +2731,7 @@ ${input.slice(result.pos)}
       var pre = $1;
       var exp = $2;
       var post = $3;
-      return module2.processUnaryExpression(pre, exp, post);
+      return processUnaryExpression(pre, exp, post);
     });
     var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var ws = $3;
@@ -9069,8 +9142,9 @@ ${input.slice(result.pos)}
     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 = $S($C(Await, Delete, Void, Typeof), __);
-    var UnaryOp$2 = Not;
+    var UnaryOp$1 = AwaitOp;
+    var UnaryOp$2 = $S($C(Delete, Void, Typeof), $E(_));
+    var UnaryOp$3 = Not;
     function UnaryOp(state) {
       let eventData;
       if (state.events) {
@@ -9082,17 +9156,52 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state));
+        const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state));
         if (state.events)
           state.events.exit?.("UnaryOp", state, result, eventData);
         return result;
       } else {
-        const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state);
+        const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state);
         if (state.events)
           state.events.exit?.("UnaryOp", state, result, eventData);
         return result;
       }
     }
+    var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $C(_, $Y(OpenParen))), function($skip, $loc, $0, $1, $2, $3) {
+      var a = $1;
+      var op = $2;
+      var ws = $3;
+      if (op) {
+        return {
+          ...a,
+          op,
+          children: [a, ...ws || []]
+        };
+      }
+      return [a, ...ws || []];
+    });
+    function AwaitOp(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AwaitOp", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AwaitOp", state, AwaitOp$0(state));
+        if (state.events)
+          state.events.exit?.("AwaitOp", state, result, eventData);
+        return result;
+      } else {
+        const result = AwaitOp$0(state);
+        if (state.events)
+          state.events.exit?.("AwaitOp", state, result, eventData);
+        return result;
+      }
+    }
     var ModuleItem$0 = ImportDeclaration;
     var ModuleItem$1 = ExportDeclaration;
     var ModuleItem$2 = StatementListItem;
@@ -11179,12 +11288,15 @@ ${input.slice(result.pos)}
         type: "Ref",
         base: "ref"
       };
-      const { binding, initializer } = dec;
+      const { binding, initializer, splices, thisAssignments } = dec;
       const initCondition = {
         type: "AssignmentExpression",
         children: [ref, " ", initializer],
         hoistDec: [["", ["let ", ref], ";"]],
-        blockPrefix: [["", [binding, "= ", ref], ";"]]
+        blockPrefix: [
+          ["", [binding, "= ", ref, ...splices], ";"],
+          ...thisAssignments
+        ]
       };
       return initCondition;
     });
@@ -12579,7 +12691,20 @@ ${input.slice(result.pos)}
     }
     var Declaration$0 = HoistableDeclaration;
     var Declaration$1 = ClassDeclaration;
-    var Declaration$2 = LexicalDeclaration;
+    var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+      var d = $0;
+      if (d.thisAssignments?.length)
+        return {
+          ...d,
+          children: [...d.children, ...d.splices, ";", ...d.thisAssignments]
+        };
+      if (d.splices?.length)
+        return {
+          ...d,
+          children: [...d.children, ...d.splices]
+        };
+      return d;
+    });
     var Declaration$3 = TypeDeclaration;
     var Declaration$4 = EnumDeclaration;
     var Declaration$5 = OperatorDeclaration;
@@ -12629,12 +12754,21 @@ ${input.slice(result.pos)}
       }
     }
     var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
+      var d = $1;
       var binding = $2;
       var tail = $3;
+      const { splices, thisAssignments } = binding;
       return {
         type: "Declaration",
         children: $0,
-        names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names))
+        names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names)),
+        binding: {
+          ...binding.binding,
+          children: [d, ...binding.binding.children]
+        },
+        initializer: binding.initializer,
+        splices,
+        thisAssignments
       };
     });
     var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -12721,25 +12855,51 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
-      const children = [...$1.children];
-      if ($2)
-        children.push($2);
-      children.push($3);
+    var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), $E(_), Initializer), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var binding = $1;
+      var suffix = $2;
+      var ws = $3;
+      var initializer = $4;
+      const bindingChildren = [...binding.children];
+      if (suffix)
+        bindingChildren.push(suffix);
+      if (ws)
+        bindingChildren.push(...ws);
+      binding = {
+        ...binding,
+        children: bindingChildren
+      };
+      const [splices, thisAssignments] = gatherBindingCode(binding.children);
       return {
-        children,
-        names: $1.names
+        children: [binding, initializer],
+        names: binding.names,
+        binding,
+        initializer,
+        splices: splices.map((s) => [",", s]),
+        thisAssignments: thisAssignments.map((s) => ["", s, ";"])
       };
     });
-    var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
-      const children = [...$1.children];
-      if ($2)
-        children.push($2);
-      if ($3)
-        children.push($3);
+    var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(_), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var binding = $1;
+      var suffix = $2;
+      var ws = $3;
+      var initializer = $4;
+      const bindingChildren = [...binding.children];
+      if (suffix)
+        bindingChildren.push(suffix);
+      if (ws)
+        bindingChildren.push(...ws);
+      binding = {
+        ...binding,
+        children: bindingChildren
+      };
       return {
-        children,
-        names: $1.names
+        children: [binding, initializer],
+        names: binding.names,
+        binding,
+        initializer,
+        splices: [],
+        thisAssignments: []
       };
     });
     function LexicalBinding(state) {
@@ -17298,7 +17458,7 @@ ${input.slice(result.pos)}
       var pre = $1;
       var exp = $2;
       var post = $3;
-      return module2.processUnaryExpression(pre, exp, post);
+      return processUnaryExpression(pre, exp, post);
     });
     function InlineJSXUnaryExpression(state) {
       let eventData;
@@ -21188,60 +21348,6 @@ ${input.slice(result.pos)}
         }
         return node;
       };
-      module2.processUnaryExpression = (pre, exp, post) => {
-        if (post?.token === "?") {
-          post = {
-            $loc: post.$loc,
-            token: " != null"
-          };
-          switch (exp.type) {
-            case "Identifier":
-            case "Literal":
-              return {
-                ...exp,
-                children: [...pre, ...exp.children, post]
-              };
-            default:
-              const expression = {
-                ...exp,
-                children: [...pre, "(", exp.children, ")", post]
-              };
-              return {
-                type: "ParenthesizedExpression",
-                children: ["(", expression, ")"],
-                expression
-              };
-          }
-        }
-        if (exp.type === "Literal") {
-          if (pre.length === 1 && pre[0].token === "-") {
-            const children = [pre[0], ...exp.children];
-            if (post)
-              exp.children.push(post);
-            return {
-              type: "Literal",
-              children,
-              raw: `-${exp.raw}`
-            };
-          }
-        }
-        if (exp.children) {
-          const children = [...pre, ...exp.children];
-          if (post)
-            children.push(post);
-          return Object.assign({}, exp, { children });
-        } else if (Array.isArray(exp)) {
-          const children = [...pre, ...exp];
-          if (post)
-            children.push(post);
-          return { children };
-        } else {
-          const children = [...pre, exp];
-          if (post)
-            children.push(post);
-          return { children };
-        }
-      };
       module2.needsRef = function(expression, base = "ref") {
         switch (expression.type) {
           case "Ref":
@@ -23185,6 +23291,7 @@ ${input.slice(result.pos)}
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processUnaryExpression,
       quoteString,
       removeParentPointers
     } = require_lib();

package/dist/main.mjs

@@ -433,16 +433,18 @@ var require_lib = __commonJS({
       }
       let [splices, thisAssignments] = gatherBindingCode(id);
       splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
+      thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
       const binding = [c, id, suffix, ...ws];
-      const initializer = [ca, e, ...splices, ...thisAssignments];
+      const initializer = [ca, e];
       const children = [binding, initializer];
       return {
         type: "Declaration",
         names: id.names,
         children,
         binding,
-        initializer
+        initializer,
+        splices,
+        thisAssignments
       };
     }
     function processLetAssignmentDeclaration(l, id, suffix, ws, la, e) {
@@ -455,18 +457,87 @@ var require_lib = __commonJS({
       };
       let [splices, thisAssignments] = gatherBindingCode(id);
       splices = splices.map((s) => [", ", s]);
-      thisAssignments = thisAssignments.map((a) => [";", a]);
+      thisAssignments = thisAssignments.map((a) => ["", a, ";"]);
       const binding = [l, id, suffix, ...ws];
-      const initializer = [la, e, ...splices, ...thisAssignments];
+      const initializer = [la, e];
       const children = [binding, initializer];
       return {
         type: "Declaration",
         names: id.names,
         children,
         binding,
-        initializer
+        initializer,
+        splices,
+        thisAssignments
       };
     }
+    function processUnaryExpression(pre, exp, post) {
+      if (post?.token === "?") {
+        post = {
+          $loc: post.$loc,
+          token: " != null"
+        };
+        switch (exp.type) {
+          case "Identifier":
+          case "Literal":
+            return {
+              ...exp,
+              children: [...pre, ...exp.children, post]
+            };
+          default:
+            const expression = {
+              ...exp,
+              children: [...pre, "(", exp.children, ")", post]
+            };
+            return {
+              type: "ParenthesizedExpression",
+              children: ["(", expression, ")"],
+              expression
+            };
+        }
+      }
+      if (exp.type === "Literal") {
+        if (pre.length === 1 && pre[0].token === "-") {
+          const children = [pre[0], ...exp.children];
+          if (post)
+            exp.children.push(post);
+          return {
+            type: "Literal",
+            children,
+            raw: `-${exp.raw}`
+          };
+        }
+      }
+      const l = pre.length;
+      if (l) {
+        const last = pre[l - 1];
+        if (last.type === "Await" && last.op) {
+          if (exp.type !== "ParenthesizedExpression") {
+            exp = ["(", exp, ")"];
+          }
+          exp = {
+            type: "CallExpression",
+            children: [" Promise", last.op, exp]
+          };
+        }
+      }
+      if (exp.children) {
+        const children = [...pre, ...exp.children];
+        if (post)
+          children.push(post);
+        return Object.assign({}, exp, { children });
+      } else if (Array.isArray(exp)) {
+        const children = [...pre, ...exp];
+        if (post)
+          children.push(post);
+        return { children };
+      } else {
+        const children = [...pre, exp];
+        if (post)
+          children.push(post);
+        return { children };
+      }
+    }
     module.exports = {
       blockWithPrefix,
       clone,
@@ -490,6 +561,7 @@ var require_lib = __commonJS({
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processUnaryExpression,
       quoteString,
       removeParentPointers
     };
@@ -1113,6 +1185,7 @@ ${input.slice(result.pos)}
       Xor,
       Xnor,
       UnaryOp,
+      AwaitOp,
       ModuleItem,
       StatementListItem,
       PostfixedStatement,
@@ -2656,7 +2729,7 @@ ${input.slice(result.pos)}
       var pre = $1;
       var exp = $2;
       var post = $3;
-      return module.processUnaryExpression(pre, exp, post);
+      return processUnaryExpression(pre, exp, post);
     });
     var UnaryExpression$1 = $TS($S(CoffeeDoEnabled, Do, __, $C($S(LeftHandSideExpression, $N($S(__, AssignmentOpSymbol))), ArrowFunction, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var ws = $3;
@@ -9067,8 +9140,9 @@ ${input.slice(result.pos)}
     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 = $S($C(Await, Delete, Void, Typeof), __);
-    var UnaryOp$2 = Not;
+    var UnaryOp$1 = AwaitOp;
+    var UnaryOp$2 = $S($C(Delete, Void, Typeof), $E(_));
+    var UnaryOp$3 = Not;
     function UnaryOp(state) {
       let eventData;
       if (state.events) {
@@ -9080,17 +9154,52 @@ ${input.slice(result.pos)}
         }
       }
       if (state.tokenize) {
-        const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state));
+        const result = $TOKEN("UnaryOp", state, UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state));
         if (state.events)
           state.events.exit?.("UnaryOp", state, result, eventData);
         return result;
       } else {
-        const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state);
+        const result = UnaryOp$0(state) || UnaryOp$1(state) || UnaryOp$2(state) || UnaryOp$3(state);
         if (state.events)
           state.events.exit?.("UnaryOp", state, result, eventData);
         return result;
       }
     }
+    var AwaitOp$0 = $TS($S(Await, $E($S(Dot, IdentifierName)), $C(_, $Y(OpenParen))), function($skip, $loc, $0, $1, $2, $3) {
+      var a = $1;
+      var op = $2;
+      var ws = $3;
+      if (op) {
+        return {
+          ...a,
+          op,
+          children: [a, ...ws || []]
+        };
+      }
+      return [a, ...ws || []];
+    });
+    function AwaitOp(state) {
+      let eventData;
+      if (state.events) {
+        const result = state.events.enter?.("AwaitOp", state);
+        if (result) {
+          if (result.cache)
+            return result.cache;
+          eventData = result.data;
+        }
+      }
+      if (state.tokenize) {
+        const result = $TOKEN("AwaitOp", state, AwaitOp$0(state));
+        if (state.events)
+          state.events.exit?.("AwaitOp", state, result, eventData);
+        return result;
+      } else {
+        const result = AwaitOp$0(state);
+        if (state.events)
+          state.events.exit?.("AwaitOp", state, result, eventData);
+        return result;
+      }
+    }
     var ModuleItem$0 = ImportDeclaration;
     var ModuleItem$1 = ExportDeclaration;
     var ModuleItem$2 = StatementListItem;
@@ -11177,12 +11286,15 @@ ${input.slice(result.pos)}
         type: "Ref",
         base: "ref"
       };
-      const { binding, initializer } = dec;
+      const { binding, initializer, splices, thisAssignments } = dec;
       const initCondition = {
         type: "AssignmentExpression",
         children: [ref, " ", initializer],
         hoistDec: [["", ["let ", ref], ";"]],
-        blockPrefix: [["", [binding, "= ", ref], ";"]]
+        blockPrefix: [
+          ["", [binding, "= ", ref, ...splices], ";"],
+          ...thisAssignments
+        ]
       };
       return initCondition;
     });
@@ -12577,7 +12689,20 @@ ${input.slice(result.pos)}
     }
     var Declaration$0 = HoistableDeclaration;
     var Declaration$1 = ClassDeclaration;
-    var Declaration$2 = LexicalDeclaration;
+    var Declaration$2 = $TV(LexicalDeclaration, function($skip, $loc, $0, $1) {
+      var d = $0;
+      if (d.thisAssignments?.length)
+        return {
+          ...d,
+          children: [...d.children, ...d.splices, ";", ...d.thisAssignments]
+        };
+      if (d.splices?.length)
+        return {
+          ...d,
+          children: [...d.children, ...d.splices]
+        };
+      return d;
+    });
     var Declaration$3 = TypeDeclaration;
     var Declaration$4 = EnumDeclaration;
     var Declaration$5 = OperatorDeclaration;
@@ -12627,12 +12752,21 @@ ${input.slice(result.pos)}
       }
     }
     var LexicalDeclaration$0 = $TS($S(LetOrConst, LexicalBinding, $Q($S(__, Comma, LexicalBinding))), function($skip, $loc, $0, $1, $2, $3) {
+      var d = $1;
       var binding = $2;
       var tail = $3;
+      const { splices, thisAssignments } = binding;
       return {
         type: "Declaration",
         children: $0,
-        names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names))
+        names: [...binding.names].concat(tail.flatMap(([, , b]) => b.names)),
+        binding: {
+          ...binding.binding,
+          children: [d, ...binding.binding.children]
+        },
+        initializer: binding.initializer,
+        splices,
+        thisAssignments
       };
     });
     var LexicalDeclaration$1 = $TS($S(InsertConst, $C(BindingPattern, BindingIdentifier), $E(TypeSuffix), __, ConstAssignment, ExtendedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
@@ -12719,25 +12853,51 @@ ${input.slice(result.pos)}
         return result;
       }
     }
-    var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), Initializer), function($skip, $loc, $0, $1, $2, $3) {
-      const children = [...$1.children];
-      if ($2)
-        children.push($2);
-      children.push($3);
+    var LexicalBinding$0 = $TS($S(BindingPattern, $E(TypeSuffix), $E(_), Initializer), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var binding = $1;
+      var suffix = $2;
+      var ws = $3;
+      var initializer = $4;
+      const bindingChildren = [...binding.children];
+      if (suffix)
+        bindingChildren.push(suffix);
+      if (ws)
+        bindingChildren.push(...ws);
+      binding = {
+        ...binding,
+        children: bindingChildren
+      };
+      const [splices, thisAssignments] = gatherBindingCode(binding.children);
       return {
-        children,
-        names: $1.names
+        children: [binding, initializer],
+        names: binding.names,
+        binding,
+        initializer,
+        splices: splices.map((s) => [",", s]),
+        thisAssignments: thisAssignments.map((s) => ["", s, ";"])
       };
     });
-    var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3) {
-      const children = [...$1.children];
-      if ($2)
-        children.push($2);
-      if ($3)
-        children.push($3);
+    var LexicalBinding$1 = $TS($S(BindingIdentifier, $E(TypeSuffix), $E(_), $E(Initializer)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var binding = $1;
+      var suffix = $2;
+      var ws = $3;
+      var initializer = $4;
+      const bindingChildren = [...binding.children];
+      if (suffix)
+        bindingChildren.push(suffix);
+      if (ws)
+        bindingChildren.push(...ws);
+      binding = {
+        ...binding,
+        children: bindingChildren
+      };
       return {
-        children,
-        names: $1.names
+        children: [binding, initializer],
+        names: binding.names,
+        binding,
+        initializer,
+        splices: [],
+        thisAssignments: []
       };
     });
     function LexicalBinding(state) {
@@ -17296,7 +17456,7 @@ ${input.slice(result.pos)}
       var pre = $1;
       var exp = $2;
       var post = $3;
-      return module.processUnaryExpression(pre, exp, post);
+      return processUnaryExpression(pre, exp, post);
     });
     function InlineJSXUnaryExpression(state) {
       let eventData;
@@ -21186,60 +21346,6 @@ ${input.slice(result.pos)}
         }
         return node;
       };
-      module.processUnaryExpression = (pre, exp, post) => {
-        if (post?.token === "?") {
-          post = {
-            $loc: post.$loc,
-            token: " != null"
-          };
-          switch (exp.type) {
-            case "Identifier":
-            case "Literal":
-              return {
-                ...exp,
-                children: [...pre, ...exp.children, post]
-              };
-            default:
-              const expression = {
-                ...exp,
-                children: [...pre, "(", exp.children, ")", post]
-              };
-              return {
-                type: "ParenthesizedExpression",
-                children: ["(", expression, ")"],
-                expression
-              };
-          }
-        }
-        if (exp.type === "Literal") {
-          if (pre.length === 1 && pre[0].token === "-") {
-            const children = [pre[0], ...exp.children];
-            if (post)
-              exp.children.push(post);
-            return {
-              type: "Literal",
-              children,
-              raw: `-${exp.raw}`
-            };
-          }
-        }
-        if (exp.children) {
-          const children = [...pre, ...exp.children];
-          if (post)
-            children.push(post);
-          return Object.assign({}, exp, { children });
-        } else if (Array.isArray(exp)) {
-          const children = [...pre, ...exp];
-          if (post)
-            children.push(post);
-          return { children };
-        } else {
-          const children = [...pre, exp];
-          if (post)
-            children.push(post);
-          return { children };
-        }
-      };
       module.needsRef = function(expression, base = "ref") {
         switch (expression.type) {
           case "Ref":
@@ -23183,6 +23289,7 @@ ${input.slice(result.pos)}
       processCoffeeInterpolation,
       processConstAssignmentDeclaration,
       processLetAssignmentDeclaration,
+      processUnaryExpression,
       quoteString,
       removeParentPointers
     } = require_lib();

package/package.json

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