@danielx/civet 0.6.50 → 0.6.52

package/dist/main.js

@@ -3875,6 +3875,10 @@ var require_parser = __commonJS({
       ShortArrowParameters,
       ArrowParameters,
       NonEmptyParameters,
+      ParameterList,
+      NestedParameterList,
+      NestedParameter,
+      Parameter,
       FunctionRestParameter,
       ParameterElement,
       ParameterElementDelimiter,
@@ -4201,6 +4205,7 @@ var require_parser = __commonJS({
       Case,
       Catch,
       Class,
+      CloseAngleBracket,
       CloseBrace,
       CloseBracket,
       CloseParen,
@@ -4672,7 +4677,7 @@ var require_parser = __commonJS({
     var $R1 = $R(new RegExp("(as|of|satisfies|then|when|implements|xor|xnor)(?!\\p{ID_Continue}|[\\u200C\\u200D$])", "suy"));
     var $R2 = $R(new RegExp("[0-9]", "suy"));
     var $R3 = $R(new RegExp("[ \\t]", "suy"));
-    var $R4 = $R(new RegExp("(?=['\"`])", "suy"));
+    var $R4 = $R(new RegExp("(?=['\"`<])", "suy"));
     var $R5 = $R(new RegExp("(?=[\\/?])", "suy"));
     var $R6 = $R(new RegExp("(?=[\\/\\[{?.!@'\u2019:])", "suy"));
     var $R7 = $R(new RegExp("[)}]", "suy"));
@@ -5320,8 +5325,11 @@ var require_parser = __commonJS({
     function TrailingDeclaration(ctx, state) {
       return $EVENT(ctx, state, "TrailingDeclaration", TrailingDeclaration$0);
     }
-    var FatArrowBody$0 = $T($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function(value) {
-      var exp = value[1];
+    var FatArrowBody$0 = $TS($S($N(EOS), NonPipelinePostfixedExpression, $N(TrailingDeclaration), $N(SemicolonDelimiter)), function($skip, $loc, $0, $1, $2, $3, $4) {
+      var exp = $2;
+      if (exp.type === "ObjectExpression") {
+        return makeLeftHandSideExpression(exp);
+      }
       return exp;
     });
     var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
@@ -5793,12 +5801,15 @@ var require_parser = __commonJS({
       return $EVENT_C(ctx, state, "CallExpression", CallExpression$$);
     }
     var CallExpressionRest$0 = MemberExpressionRest;
-    var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`])/"), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2) {
-      var literal = $2;
+    var CallExpressionRest$1 = $TS($S($EXPECT($R4, "CallExpressionRest /(?=['\"`<])/"), $E(TypeArguments), $C(TemplateLiteral, StringLiteral)), function($skip, $loc, $0, $1, $2, $3) {
+      var args = $2;
+      var literal = $3;
       if (literal.type === "StringLiteral") {
-        return "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
+        literal = "`" + literal.token.slice(1, -1).replace(/(`|\$\{)/g, "\\$1") + "`";
       }
-      return literal;
+      if (!args)
+        return literal;
+      return [args, literal];
     });
     var CallExpressionRest$2 = $TS($S($E(OptionalShorthand), ArgumentsWithTrailingMemberExpressions), function($skip, $loc, $0, $1, $2) {
       if (!$1)
@@ -6138,15 +6149,55 @@ var require_parser = __commonJS({
     function ArrowParameters(ctx, state) {
       return $EVENT_C(ctx, state, "ArrowParameters", ArrowParameters$$);
     }
-    var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, $E(ThisType), $Q(ParameterElement), $E(FunctionRestParameter), $Q(ParameterElement), $S(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+    var NonEmptyParameters$0 = $TS($S($E(TypeParameters), OpenParen, ParameterList, $S(__, CloseParen)), function($skip, $loc, $0, $1, $2, $3, $4) {
       var tp = $1;
       var open = $2;
-      var tt = $3;
-      var pes = $4;
-      var rest = $5;
-      var after = $6;
-      var close = $7;
-      const names = pes.flatMap((p) => p.names);
+      var params = $3;
+      var close = $4;
+      let tt, before = [], rest, after = [], errors = [];
+      function append(p) {
+        (rest ? after : before).push(p);
+      }
+      for (const param of params) {
+        switch (param.type) {
+          case "ThisType":
+            if (tt) {
+              append({
+                type: "Error",
+                message: "Only one typed this parameter is allowed"
+              });
+              append(param);
+            } else {
+              tt = insertTrimmingSpace(param, "");
+              if (before.length || rest) {
+                let delim = tt.children.at(-1);
+                if (Array.isArray(delim))
+                  delim = delim.at(-1);
+                if (delim?.token !== ",") {
+                  tt = {
+                    ...tt,
+                    children: [...tt.children, ", "]
+                  };
+                }
+              }
+            }
+            break;
+          case "FunctionRestParameter":
+            if (rest) {
+              append({
+                type: "Error",
+                message: "Only one rest parameter is allowed"
+              });
+              append(param);
+            } else {
+              rest = param;
+            }
+            break;
+          default:
+            append(param);
+        }
+      }
+      const names = before.flatMap((p) => p.names);
       if (rest) {
         const restIdentifier = rest.binding.ref || rest.binding;
         names.push(...rest.names || []);
@@ -6163,7 +6214,7 @@ var require_parser = __commonJS({
             tp,
             open,
             tt,
-            ...pes,
+            ...before,
             // Remove delimiter
             { ...rest, children: rest.children.slice(0, -1) },
             close
@@ -6175,19 +6226,61 @@ var require_parser = __commonJS({
       }
       return {
         type: "Parameters",
-        children: [tp, open, tt, ...pes, close],
-        names: pes.flatMap((p) => p.names),
+        children: [tp, open, tt, ...before, close],
+        names,
         tp
       };
     });
     function NonEmptyParameters(ctx, state) {
       return $EVENT(ctx, state, "NonEmptyParameters", NonEmptyParameters$0);
     }
-    var FunctionRestParameter$0 = $TS($S(__, BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var ParameterList$0 = $TS($S($Q(Parameter), NestedParameterList), function($skip, $loc, $0, $1, $2) {
+      return [...$1, ...$2];
+    });
+    var ParameterList$1 = $TV($Q($S(__, Parameter)), function($skip, $loc, $0, $1) {
+      return $1.map(([eos, p]) => ({
+        ...p,
+        children: [eos, ...p.children]
+      }));
+    });
+    var ParameterList$$ = [ParameterList$0, ParameterList$1];
+    function ParameterList(ctx, state) {
+      return $EVENT_C(ctx, state, "ParameterList", ParameterList$$);
+    }
+    var NestedParameterList$0 = $TS($S(PushIndent, $Q(NestedParameter), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
+      var params = $2;
+      if (!params.length)
+        return $skip;
+      return params;
+    });
+    function NestedParameterList(ctx, state) {
+      return $EVENT(ctx, state, "NestedParameterList", NestedParameterList$0);
+    }
+    var NestedParameter$0 = $TS($S(Nested, $P(Parameter)), function($skip, $loc, $0, $1, $2) {
+      var ws = $1;
+      var params = $2;
+      params = [...params];
+      params[0] = {
+        ...params[0],
+        children: [ws, ...params[0].children]
+      };
+      return params;
+    });
+    function NestedParameter(ctx, state) {
+      return $EVENT(ctx, state, "NestedParameter", NestedParameter$0);
+    }
+    var Parameter$0 = ThisType;
+    var Parameter$1 = ParameterElement;
+    var Parameter$2 = FunctionRestParameter;
+    var Parameter$$ = [Parameter$0, Parameter$1, Parameter$2];
+    function Parameter(ctx, state) {
+      return $EVENT_C(ctx, state, "Parameter", Parameter$$);
+    }
+    var FunctionRestParameter$0 = $TS($S($N(EOS), BindingRestElement, $E(TypeSuffix), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4) {
       var id = $2;
       return {
         type: "FunctionRestParameter",
-        children: $0,
+        children: $0.slice(1),
         names: id.names,
         binding: id.binding
       };
@@ -6195,12 +6288,14 @@ var require_parser = __commonJS({
     function FunctionRestParameter(ctx, state) {
       return $EVENT(ctx, state, "FunctionRestParameter", FunctionRestParameter$0);
     }
-    var ParameterElement$0 = $TS($S(__, $E(AccessModifier), $C(BindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+    var ParameterElement$0 = $TS($S($E(_), $E(AccessModifier), $E(_), $C(NWBindingIdentifier, BindingPattern), $E(TypeSuffix), $E(Initializer), ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+      var accessModifier = $2;
+      var binding = $4;
       return {
         type: "Parameter",
         children: $0,
-        names: $3.names,
-        accessModifier: $2
+        names: binding.names,
+        accessModifier
       };
     });
     function ParameterElement(ctx, state) {
@@ -6595,8 +6690,8 @@ var require_parser = __commonJS({
         async,
         generator,
         modifier: {
-          async: !async.length,
-          generator: !generator.length
+          async: !!async.length,
+          generator: !!generator.length
         },
         block: null,
         children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
@@ -6619,9 +6714,11 @@ var require_parser = __commonJS({
       }
       if (hasAwait(block) && !signature.async.length) {
         signature.async.push("async ");
+        signature.modifier.async = true;
       }
       if (hasYield(block) && !signature.generator.length) {
         signature.generator.push("*");
+        signature.modifier.generator = true;
       }
       return {
         ...signature,
@@ -6796,10 +6893,11 @@ var require_parser = __commonJS({
     function AmpersandBlockRHS(ctx, state) {
       return $EVENT(ctx, state, "AmpersandBlockRHS", AmpersandBlockRHS$0);
     }
-    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3) {
+    var AmpersandBlockRHSBody$0 = $TS($S($E($S($N(_), $P(CallExpressionRest))), $E(QuestionMark), $E($S(WAssignmentOp, $Q($S(NotDedented, UpdateExpression, WAssignmentOp)), NonPipelineExtendedExpression)), $E($S($N($EXPECT($R8, "AmpersandBlockRHSBody /[&]/")), $P(BinaryOpRHS)))), function($skip, $loc, $0, $1, $2, $3, $4) {
       var callExpRest = $1;
       var unaryPostfix = $2;
-      var binopRHS = $3;
+      var assign = $3;
+      var binopRHS = $4;
       if (!callExpRest && !binopRHS && !unaryPostfix)
         return $skip;
       const ref = makeRef("$");
@@ -6815,8 +6913,24 @@ var require_parser = __commonJS({
       if (unaryPostfix) {
         exp = processUnaryExpression([], exp, unaryPostfix);
       }
+      if (assign) {
+        const [op1, more, rhs] = assign;
+        const lhs = [
+          [void 0, exp, ...op1],
+          ...more.map((x) => [x[0], x[1], ...x[2]])
+        ];
+        exp = {
+          type: "AssignmentExpression",
+          children: [lhs, rhs],
+          names: null,
+          lhs,
+          assigned: exp,
+          exp: rhs,
+          ref
+        };
+      }
       if (binopRHS) {
-        return {
+        exp = {
           children: processBinaryOpExpression([exp, binopRHS[1]]),
           ref
         };
@@ -10701,6 +10815,12 @@ var require_parser = __commonJS({
     function Class(ctx, state) {
       return $EVENT(ctx, state, "Class", Class$0);
     }
+    var CloseAngleBracket$0 = $TV($EXPECT($L33, 'CloseAngleBracket ">"'), function($skip, $loc, $0, $1) {
+      return { $loc, token: $1 };
+    });
+    function CloseAngleBracket(ctx, state) {
+      return $EVENT(ctx, state, "CloseAngleBracket", CloseAngleBracket$0);
+    }
     var CloseBrace$0 = $TV($EXPECT($L25, 'CloseBrace "}"'), function($skip, $loc, $0, $1) {
       return { $loc, token: $1 };
     });
@@ -12499,9 +12619,14 @@ var require_parser = __commonJS({
     function TypeArrowFunction(ctx, state) {
       return $EVENT(ctx, state, "TypeArrowFunction", TypeArrowFunction$0);
     }
-    var TypeArguments$0 = $TS($S($EXPECT($L154, 'TypeArguments "<"'), $P(TypeArgument), __, $EXPECT($L33, 'TypeArguments ">"')), function($skip, $loc, $0, $1, $2, $3, $4) {
+    var TypeArguments$0 = $TS($S(OpenAngleBracket, $P(TypeArgument), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4) {
       var args = $2;
-      return { ts: true, types: args.map(([, t]) => t), children: $0 };
+      return {
+        type: "TypeArguments",
+        ts: true,
+        types: args.map(([, t]) => t),
+        children: $0
+      };
     });
     function TypeArguments(ctx, state) {
       return $EVENT(ctx, state, "TypeArguments", TypeArguments$0);
@@ -12514,7 +12639,7 @@ var require_parser = __commonJS({
     function TypeArgumentDelimiter(ctx, state) {
       return $EVENT(ctx, state, "TypeArgumentDelimiter", TypeArgumentDelimiter$0);
     }
-    var TypeParameters$0 = $TS($S($E(_), $EXPECT($L154, 'TypeParameters "<"'), $P(TypeParameter), __, $EXPECT($L33, 'TypeParameters ">"')), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+    var TypeParameters$0 = $TS($S($E(_), OpenAngleBracket, $P(TypeParameter), __, CloseAngleBracket), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
       var parameters = $3;
       return {
         type: "TypeParameters",
@@ -12547,7 +12672,7 @@ var require_parser = __commonJS({
     function TypeParameterDelimiter(ctx, state) {
       return $EVENT_C(ctx, state, "TypeParameterDelimiter", TypeParameterDelimiter$$);
     }
-    var ThisType$0 = $T($S($C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
+    var ThisType$0 = $T($S($E(_), $C(This, AtThis), Colon, Type, ParameterElementDelimiter), function(value) {
       return { "type": "ThisType", "ts": true, "children": value };
     });
     function ThisType(ctx, state) {
@@ -12990,19 +13115,45 @@ var require_parser = __commonJS({
           };
           module2.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
         },
+        Falsy(FalsyRef) {
+          module2.prelude.push(["", [{
+            ts: true,
+            children: ["type ", FalsyRef, " = false | 0 | '' | 0n | null | undefined;", "\n"]
+          }]]);
+        },
         xor(xorRef) {
+          const Falsy = module2.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A extends ",
+              Falsy,
+              " ? B : B extends ",
+              Falsy,
+              " ? A : (false | (A & ",
+              Falsy,
+              " extends never ? never : B) | (B & ",
+              Falsy,
+              " extends never ? never : A))"
+            ]
           };
-          module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => (a ? !b && a : b)", asAny, ";", "\n"]]);
         },
         xnor(xnorRef) {
+          const Falsy = module2.getRef("Falsy");
           const typeSuffix = {
             ts: true,
-            children: [": (a: unknown, b: unknown) => boolean"]
+            children: [
+              ": <A, B>(a: A, b: B) => A & ",
+              Falsy,
+              " extends never ? B : (true | (B extends ",
+              Falsy,
+              " ? never : A) | (A extends ",
+              Falsy,
+              " ? never : B))"
+            ]
           };
-          module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+          module2.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => (a ? b : !b || a)", asAny, ";", "\n"]]);
         },
         returnSymbol(ref) {
           module2.prelude.push({
@@ -13342,6 +13493,10 @@ var require_parser = __commonJS({
     exports.ShortArrowParameters = ShortArrowParameters;
     exports.ArrowParameters = ArrowParameters;
     exports.NonEmptyParameters = NonEmptyParameters;
+    exports.ParameterList = ParameterList;
+    exports.NestedParameterList = NestedParameterList;
+    exports.NestedParameter = NestedParameter;
+    exports.Parameter = Parameter;
     exports.FunctionRestParameter = FunctionRestParameter;
     exports.ParameterElement = ParameterElement;
     exports.ParameterElementDelimiter = ParameterElementDelimiter;
@@ -13668,6 +13823,7 @@ var require_parser = __commonJS({
     exports.Case = Case;
     exports.Catch = Catch;
     exports.Class = Class;
+    exports.CloseAngleBracket = CloseAngleBracket;
     exports.CloseBrace = CloseBrace;
     exports.CloseBracket = CloseBracket;
     exports.CloseParen = CloseParen;