@danielx/civet 0.6.15 → 0.6.17

package/dist/main.mjs

@@ -742,12 +742,15 @@ var require_lib = __commonJS({
       }
     }
     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)
@@ -820,14 +823,11 @@ var require_lib = __commonJS({
     }
     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.");
         }
@@ -943,6 +943,9 @@ var require_lib = __commonJS({
     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;
@@ -1367,6 +1370,8 @@ var require_lib = __commonJS({
       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];
@@ -1386,8 +1391,8 @@ var require_lib = __commonJS({
           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);
@@ -2109,7 +2114,7 @@ var require_lib = __commonJS({
         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));
@@ -2161,7 +2166,7 @@ var require_lib = __commonJS({
       }
       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) {
@@ -2224,7 +2229,7 @@ var require_lib = __commonJS({
       let declared;
       values.forEach((value) => {
         value.children = [ref];
-        const ancestor = findAncestor(
+        const { ancestor } = findAncestor(
           value,
           ({ type }) => type === "Declaration",
           isFunction
@@ -2994,6 +2999,7 @@ ${input.slice(result.pos)}
       NonPipelineArgumentPart,
       BinaryOpExpression,
       BinaryOpRHS,
+      WRHS,
       SingleLineBinaryOpRHS,
       RHS,
       ParenthesizedAssignment,
@@ -3103,6 +3109,8 @@ ${input.slice(result.pos)}
       ExplicitBlock,
       ImplicitNestedBlock,
       Block,
+      BareNestedBlock,
+      BareBlock,
       ThenClause,
       BracedOrEmptyBlock,
       NoPostfixBracedOrEmptyBlock,
@@ -3227,7 +3235,9 @@ ${input.slice(result.pos)}
       PatternExpressionList,
       ConditionFragment,
       CaseExpressionList,
+      CaseExpression,
       ImpliedColon,
+      IgnoreColon,
       TryStatement,
       TryExpression,
       CatchClause,
@@ -3570,6 +3580,7 @@ ${input.slice(result.pos)}
       EOS,
       EOL,
       DebugHere,
+      InsertColon,
       InsertSemicolon,
       InsertOpenParen,
       InsertCloseParen,
@@ -4801,9 +4812,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];
@@ -4830,6 +4842,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;
@@ -5536,8 +5577,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;
@@ -8463,6 +8504,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];
     });
@@ -10213,13 +10318,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) {
@@ -12847,7 +12956,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 {
@@ -12857,13 +12966,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,
@@ -12872,7 +12981,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",
@@ -12968,7 +13077,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)
@@ -13004,10 +13113,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) {
@@ -13030,6 +13169,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;
@@ -14729,14 +14894,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;
@@ -22106,7 +22272,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;
@@ -22567,6 +22734,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: ";" };
     });

package/package.json

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