@danielx/civet 0.6.15 → 0.6.17

package/dist/browser.js

@@ -745,12 +745,15 @@ var Civet = (() => {
         }
       }
       function findAncestor(node, predicate, stopPredicate) {
-        node = node.parent;
-        while (node && !stopPredicate?.(node)) {
-          if (predicate(node))
-            return node;
-          node = node.parent;
+        let { parent } = node;
+        while (parent && !stopPredicate?.(parent, node)) {
+          if (predicate(parent, node)) {
+            return { ancestor: parent, child: node };
+          }
+          node = parent;
+          parent = node.parent;
         }
+        return { ancestor: void 0, child: node };
       }
       function gatherNodes(node, predicate) {
         if (node == null)
@@ -823,14 +826,11 @@ var Civet = (() => {
       }
       function hoistRefDecs(statements) {
         gatherRecursiveAll(statements, (s) => s.hoistDec).forEach((node) => {
-          let { hoistDec, parent } = node;
+          let { hoistDec } = node;
           node.hoistDec = null;
-          while (parent?.type !== "BlockStatement" || parent.bare && !parent.root) {
-            node = parent;
-            parent = node.parent;
-          }
-          if (parent) {
-            insertHoistDec(parent, node, hoistDec);
+          const { ancestor, child } = findAncestor(node, (ancestor2) => ancestor2.type === "BlockStatement" && (!ancestor2.bare || ancestor2.root));
+          if (ancestor) {
+            insertHoistDec(ancestor, child, hoistDec);
           } else {
             throw new Error("Couldn't find block to hoist declaration into.");
           }
@@ -946,6 +946,9 @@ var Civet = (() => {
       function isVoidType(t) {
         return t?.type === "LiteralType" && t.t.type === "VoidType";
       }
+      function isPromiseVoidType(t) {
+        return t?.type === "IdentifierType" && t.raw === "Promise" && t.args?.types?.length === 1 && isVoidType(t.args.types[0]);
+      }
       function isWhitespaceOrEmpty(node) {
         if (!node)
           return true;
@@ -1370,6 +1373,8 @@ var Civet = (() => {
         if (f.abstract || f.block || f.signature?.optional)
           return;
         const { name, parent } = f;
+        if (parent?.type === "ExportDeclaration")
+          return;
         const expressions = parent?.expressions ?? parent?.elements;
         const currentIndex = expressions?.findIndex(([, def]) => def === f);
         const following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
@@ -1389,8 +1394,8 @@ var Civet = (() => {
             implicitFunctionBlock(f);
           processParams(f);
           if (!processReturnValue(f) && config.implicitReturns) {
-            const { block, returnType } = f;
-            const isVoid = isVoidType(returnType?.t);
+            const { async, block, returnType } = f;
+            const isVoid = isVoidType(returnType?.t) || async && isPromiseVoidType(returnType?.t);
             const isBlock = block?.type === "BlockStatement";
             if (!isVoid && isBlock) {
               insertReturn(block);
@@ -2112,7 +2117,7 @@ var Civet = (() => {
           if (!hasDec(x))
             return a.indexOf(x) === i;
         }).forEach(pushVar);
-        const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
+        const fnNodes = gatherNodes(statements, isFunction);
         const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
         const blockNodes = new Set(gatherNodes(statements, (s) => s.type === "BlockStatement"));
         fnNodes.forEach(({ block }) => blockNodes.delete(block));
@@ -2164,7 +2169,7 @@ var Civet = (() => {
         }
         let currentScope = /* @__PURE__ */ new Set();
         scopes.push(currentScope);
-        const fnNodes = gatherNodes(statements, (s) => s.type === "FunctionExpression");
+        const fnNodes = gatherNodes(statements, isFunction);
         const forNodes = gatherNodes(statements, (s) => s.type === "ForStatement");
         let targetStatements = [];
         for (const statement of statements) {
@@ -2227,7 +2232,7 @@ var Civet = (() => {
         let declared;
         values.forEach((value) => {
           value.children = [ref];
-          const ancestor = findAncestor(
+          const { ancestor } = findAncestor(
             value,
             ({ type }) => type === "Declaration",
             isFunction
@@ -2997,6 +3002,7 @@ ${input.slice(result.pos)}
         NonPipelineArgumentPart,
         BinaryOpExpression,
         BinaryOpRHS,
+        WRHS,
         SingleLineBinaryOpRHS,
         RHS,
         ParenthesizedAssignment,
@@ -3106,6 +3112,8 @@ ${input.slice(result.pos)}
         ExplicitBlock,
         ImplicitNestedBlock,
         Block,
+        BareNestedBlock,
+        BareBlock,
         ThenClause,
         BracedOrEmptyBlock,
         NoPostfixBracedOrEmptyBlock,
@@ -3230,7 +3238,9 @@ ${input.slice(result.pos)}
         PatternExpressionList,
         ConditionFragment,
         CaseExpressionList,
+        CaseExpression,
         ImpliedColon,
+        IgnoreColon,
         TryStatement,
         TryExpression,
         CatchClause,
@@ -3573,6 +3583,7 @@ ${input.slice(result.pos)}
         EOS,
         EOL,
         DebugHere,
+        InsertColon,
         InsertSemicolon,
         InsertOpenParen,
         InsertCloseParen,
@@ -4804,9 +4815,10 @@ ${input.slice(result.pos)}
         var rhs = $2;
         return [[], op, [], 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$1 = $TS($S(NewlineBinaryOpAllowed, NotDedentedBinaryOp, WRHS), function($skip, $loc, $0, $1, $2, $3) {
+        var op = $2;
+        var rhs = $3;
+        return [...op, ...rhs];
       });
       var BinaryOpRHS$2 = $T($S($N(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
         return value[1];
@@ -4833,6 +4845,35 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var WRHS$0 = $TS($S(PushIndent, $E($S(Nested, RHS)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+        var wrhs = $2;
+        if (!wrhs)
+          return $skip;
+        return wrhs;
+      });
+      var WRHS$1 = $S($C(_, $S(EOS, __)), RHS);
+      function WRHS(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("WRHS", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("WRHS", state, WRHS$0(state) || WRHS$1(state));
+          if (state.events)
+            state.events.exit?.("WRHS", state, result, eventData);
+          return result;
+        } else {
+          const result = WRHS$0(state) || WRHS$1(state);
+          if (state.events)
+            state.events.exit?.("WRHS", state, result, eventData);
+          return result;
+        }
+      }
       var SingleLineBinaryOpRHS$0 = $TS($S($E(_), BinaryOp, $C(_, $S(EOS, __)), RHS), function($skip, $loc, $0, $1, $2, $3, $4) {
         var ws1 = $1;
         var op = $2;
@@ -5539,8 +5580,8 @@ ${input.slice(result.pos)}
       var PrimaryExpression$2 = TemplateLiteral;
       var PrimaryExpression$3 = Literal;
       var PrimaryExpression$4 = ArrayLiteral;
-      var PrimaryExpression$5 = IdentifierReference;
-      var PrimaryExpression$6 = FunctionExpression;
+      var PrimaryExpression$5 = FunctionExpression;
+      var PrimaryExpression$6 = IdentifierReference;
       var PrimaryExpression$7 = ClassExpression;
       var PrimaryExpression$8 = RegularExpressionLiteral;
       var PrimaryExpression$9 = ParenthesizedExpression;
@@ -8466,6 +8507,70 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var BareNestedBlock$0 = $TS($S($Y(EOS), AllowAll, $E(NestedBlockStatements), RestoreAll), function($skip, $loc, $0, $1, $2, $3, $4) {
+        if (!$3)
+          return $skip;
+        return $3;
+      });
+      function BareNestedBlock(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("BareNestedBlock", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("BareNestedBlock", state, BareNestedBlock$0(state));
+          if (state.events)
+            state.events.exit?.("BareNestedBlock", state, result, eventData);
+          return result;
+        } else {
+          const result = BareNestedBlock$0(state);
+          if (state.events)
+            state.events.exit?.("BareNestedBlock", state, result, eventData);
+          return result;
+        }
+      }
+      var BareBlock$0 = BareNestedBlock;
+      var BareBlock$1 = ExplicitBlock;
+      var BareBlock$2 = ThenClause;
+      var BareBlock$3 = $TS($S($E(_), $N(EOS), Statement), function($skip, $loc, $0, $1, $2, $3) {
+        var ws = $1;
+        var s = $3;
+        const expressions = [[ws, s]];
+        return {
+          type: "BlockStatement",
+          expressions,
+          children: [expressions],
+          bare: true
+        };
+      });
+      var BareBlock$4 = EmptyBareBlock;
+      function BareBlock(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("BareBlock", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("BareBlock", state, BareBlock$0(state) || BareBlock$1(state) || BareBlock$2(state) || BareBlock$3(state) || BareBlock$4(state));
+          if (state.events)
+            state.events.exit?.("BareBlock", state, result, eventData);
+          return result;
+        } else {
+          const result = BareBlock$0(state) || BareBlock$1(state) || BareBlock$2(state) || BareBlock$3(state) || BareBlock$4(state);
+          if (state.events)
+            state.events.exit?.("BareBlock", state, result, eventData);
+          return result;
+        }
+      }
       var ThenClause$0 = $T($S(Then, SingleLineStatements), function(value) {
         return value[1];
       });
@@ -10216,13 +10321,17 @@ ${input.slice(result.pos)}
         return {
           type: "ComputedPropertyName",
           children: $0,
-          expression
+          expression,
+          implicit: true
         };
       });
       var ComputedPropertyName$2 = $TS($S(InsertOpenBracket, $EXPECT($L20, fail, 'ComputedPropertyName "-"'), NumericLiteral, InsertCloseBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
+        const expression = [$2, $3];
         return {
           type: "ComputedPropertyName",
-          children: $0
+          expression,
+          children: [$1, expression, $4],
+          implicit: true
         };
       });
       function ComputedPropertyName(state) {
@@ -12850,7 +12959,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CaseClause$0 = $TS($S(PatternExpressionList, $C(ThenClause, NestedBlockStatements, EmptyBareBlock)), function($skip, $loc, $0, $1, $2) {
+      var CaseClause$0 = $TS($S(PatternExpressionList, $C(ThenClause, BareBlock)), function($skip, $loc, $0, $1, $2) {
         var patterns = $1;
         var block = $2;
         return {
@@ -12860,13 +12969,13 @@ ${input.slice(result.pos)}
           patterns
         };
       });
-      var CaseClause$1 = $T($S(Case, CaseExpressionList, $C(NestedBlockStatements, EmptyBareBlock)), function(value) {
+      var CaseClause$1 = $T($S(Case, CaseExpressionList, IgnoreColon, $C(ThenClause, BareBlock)), function(value) {
         return { "type": "CaseClause", "children": value };
       });
-      var CaseClause$2 = $TS($S(When, CaseExpressionList, InsertOpenBrace, $C(ThenClause, NestedBlockStatements, EmptyBareBlock), InsertBreak, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8) {
+      var CaseClause$2 = $TS($S(When, CaseExpressionList, IgnoreColon, InsertOpenBrace, $C(ThenClause, BareBlock), InsertBreak, InsertNewline, InsertIndent, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7, $8, $9) {
         var cases = $2;
-        var block = $4;
-        var b = $5;
+        var block = $5;
+        var b = $6;
         return {
           type: "WhenClause",
           cases,
@@ -12875,7 +12984,7 @@ ${input.slice(result.pos)}
           children: $0
         };
       });
-      var CaseClause$3 = $TS($S(Default, ImpliedColon, $C(NestedBlockStatements, EmptyBareBlock)), function($skip, $loc, $0, $1, $2, $3) {
+      var CaseClause$3 = $TS($S(Default, ImpliedColon, $C(ThenClause, BareBlock)), function($skip, $loc, $0, $1, $2, $3) {
         var block = $3;
         return {
           type: "DefaultClause",
@@ -12971,7 +13080,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CaseExpressionList$0 = $TS($S(ForbidMultiLineImplicitObjectLiteral, $E($S($Q(_), ExpressionWithObjectApplicationForbidden, ImpliedColon)), $Q($S(__, Comma, ExpressionWithObjectApplicationForbidden, ImpliedColon)), RestoreMultiLineImplicitObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var CaseExpressionList$0 = $TS($S(ForbidMultiLineImplicitObjectLiteral, $E($S($E(_), CaseExpression, InsertColon)), $Q($S(__, Comma, CaseExpression, InsertColon)), RestoreMultiLineImplicitObjectLiteral), function($skip, $loc, $0, $1, $2, $3, $4) {
         var first = $2;
         var rest = $3;
         if (!first)
@@ -13007,10 +13116,40 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var ImpliedColon$0 = $S($E(_), Colon);
-      var ImpliedColon$1 = $TV($EXPECT($L0, fail, 'ImpliedColon ""'), function($skip, $loc, $0, $1) {
-        return { $loc, token: ":" };
+      var CaseExpression$0 = $TS($S(PropertyName, $Y($S($E(_), Colon))), function($skip, $loc, $0, $1, $2) {
+        var value = $1;
+        if (value.type === "ComputedPropertyName") {
+          if (value.implicit)
+            return value.expression;
+          return { ...value, type: "ArrayExpression" };
+        }
+        return value;
       });
+      var CaseExpression$1 = ExpressionWithObjectApplicationForbidden;
+      function CaseExpression(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("CaseExpression", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("CaseExpression", state, CaseExpression$0(state) || CaseExpression$1(state));
+          if (state.events)
+            state.events.exit?.("CaseExpression", state, result, eventData);
+          return result;
+        } else {
+          const result = CaseExpression$0(state) || CaseExpression$1(state);
+          if (state.events)
+            state.events.exit?.("CaseExpression", state, result, eventData);
+          return result;
+        }
+      }
+      var ImpliedColon$0 = $S($E(_), Colon);
+      var ImpliedColon$1 = InsertColon;
       function ImpliedColon(state) {
         let eventData;
         if (state.events) {
@@ -13033,6 +13172,32 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var IgnoreColon$0 = $TV($E($S($E(_), Colon)), function($skip, $loc, $0, $1) {
+        if ($1)
+          return $1[0];
+      });
+      function IgnoreColon(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("IgnoreColon", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("IgnoreColon", state, IgnoreColon$0(state));
+          if (state.events)
+            state.events.exit?.("IgnoreColon", state, result, eventData);
+          return result;
+        } else {
+          const result = IgnoreColon$0(state);
+          if (state.events)
+            state.events.exit?.("IgnoreColon", state, result, eventData);
+          return result;
+        }
+      }
       var TryStatement$0 = $TS($S(Try, $N($EXPECT($L12, fail, 'TryStatement ":"')), NoPostfixBracedOrEmptyBlock, $E(CatchClause), $E(FinallyClause)), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         var t = $1;
         var b = $3;
@@ -14732,14 +14897,15 @@ ${input.slice(result.pos)}
         }
       }
       var ExportDeclaration$0 = $TS($S($E(Decorators), Export, __, Default, __, $C(HoistableDeclaration, ClassDeclaration, ExtendedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
-        return { type: "ExportDeclaration", children: $0 };
+        var declaration = $6;
+        return { type: "ExportDeclaration", declaration, children: $0 };
       });
       var ExportDeclaration$1 = $TS($S(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
         return { type: "ExportDeclaration", ts: $3.ts, children: $0 };
       });
       var ExportDeclaration$2 = $TS($S($E(Decorators), Export, __, $C(Declaration, VariableStatement, TypeAndNamedExports, ExportVarDec)), function($skip, $loc, $0, $1, $2, $3, $4) {
-        var decl = $4;
-        return { type: "ExportDeclaration", ts: decl.ts, children: $0 };
+        var declaration = $4;
+        return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
       });
       function ExportDeclaration(state) {
         let eventData;
@@ -22109,7 +22275,8 @@ ${input.slice(result.pos)}
         }
       }
       var TypeArguments$0 = $TS($S($EXPECT($L155, fail, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L34, fail, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
-        return { ts: true, children: $0 };
+        var args = $2;
+        return { ts: true, types: args.map(([, t]) => t), children: $0 };
       });
       function TypeArguments(state) {
         let eventData;
@@ -22570,6 +22737,31 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var InsertColon$0 = $TV($EXPECT($L0, fail, 'InsertColon ""'), function($skip, $loc, $0, $1) {
+        return { $loc, token: ":" };
+      });
+      function InsertColon(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("InsertColon", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("InsertColon", state, InsertColon$0(state));
+          if (state.events)
+            state.events.exit?.("InsertColon", state, result, eventData);
+          return result;
+        } else {
+          const result = InsertColon$0(state);
+          if (state.events)
+            state.events.exit?.("InsertColon", state, result, eventData);
+          return result;
+        }
+      }
       var InsertSemicolon$0 = $TV($EXPECT($L0, fail, 'InsertSemicolon ""'), function($skip, $loc, $0, $1) {
         return { $loc, token: ";" };
       });