@danielx/civet 0.6.50 → 0.6.52

package/dist/browser.js

@@ -3883,6 +3883,10 @@ ${input.slice(result.pos)}
         ShortArrowParameters,
         ArrowParameters,
         NonEmptyParameters,
+        ParameterList,
+        NestedParameterList,
+        NestedParameter,
+        Parameter,
         FunctionRestParameter,
         ParameterElement,
         ParameterElementDelimiter,
@@ -4209,6 +4213,7 @@ ${input.slice(result.pos)}
         Case,
         Catch,
         Class,
+        CloseAngleBracket,
         CloseBrace,
         CloseBracket,
         CloseParen,
@@ -4680,7 +4685,7 @@ ${input.slice(result.pos)}
       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"));
@@ -5328,8 +5333,11 @@ ${input.slice(result.pos)}
       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;
@@ -5801,12 +5809,15 @@ ${input.slice(result.pos)}
         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)
@@ -6146,15 +6157,55 @@ ${input.slice(result.pos)}
       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 || []);
@@ -6171,7 +6222,7 @@ ${input.slice(result.pos)}
               tp,
               open,
               tt,
-              ...pes,
+              ...before,
               // Remove delimiter
               { ...rest, children: rest.children.slice(0, -1) },
               close
@@ -6183,19 +6234,61 @@ ${input.slice(result.pos)}
         }
         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
         };
@@ -6203,12 +6296,14 @@ ${input.slice(result.pos)}
       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) {
@@ -6603,8 +6698,8 @@ ${input.slice(result.pos)}
           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]
@@ -6627,9 +6722,11 @@ ${input.slice(result.pos)}
         }
         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,
@@ -6804,10 +6901,11 @@ ${input.slice(result.pos)}
       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("$");
@@ -6823,8 +6921,24 @@ ${input.slice(result.pos)}
         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
           };
@@ -10709,6 +10823,12 @@ ${input.slice(result.pos)}
       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 };
       });
@@ -12507,9 +12627,14 @@ ${input.slice(result.pos)}
       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);
@@ -12522,7 +12647,7 @@ ${input.slice(result.pos)}
       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",
@@ -12555,7 +12680,7 @@ ${input.slice(result.pos)}
       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) {
@@ -12998,19 +13123,45 @@ ${input.slice(result.pos)}
             };
             module.prelude.push(["", [preludeVar, moduloRef, typeSuffix, " = (a, b) => (a % b + b) % b;", "\n"]]);
           },
+          Falsy(FalsyRef) {
+            module.prelude.push(["", [{
+              ts: true,
+              children: ["type ", FalsyRef, " = false | 0 | '' | 0n | null | undefined;", "\n"]
+            }]]);
+          },
           xor(xorRef) {
+            const Falsy = module.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))"
+              ]
             };
-            module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => a ? !b && a : b;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xorRef, typeSuffix, " = (a, b) => (a ? !b && a : b)", asAny, ";", "\n"]]);
           },
           xnor(xnorRef) {
+            const Falsy = module.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))"
+              ]
             };
-            module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => a ? b : !b || a;", "\n"]]);
+            module.prelude.push(["", [preludeVar, xnorRef, typeSuffix, " = (a, b) => (a ? b : !b || a)", asAny, ";", "\n"]]);
           },
           returnSymbol(ref) {
             module.prelude.push({
@@ -13350,6 +13501,10 @@ ${input.slice(result.pos)}
       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;
@@ -13676,6 +13831,7 @@ ${input.slice(result.pos)}
       exports.Case = Case;
       exports.Catch = Catch;
       exports.Class = Class;
+      exports.CloseAngleBracket = CloseAngleBracket;
       exports.CloseBrace = CloseBrace;
       exports.CloseBracket = CloseBracket;
       exports.CloseParen = CloseParen;

package/dist/esbuild.js

@@ -42,14 +42,46 @@ var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_typescript = __toESM(require("typescript"));
 var tsvfs = __toESM(require("@typescript/vfs"));
+var import_os = __toESM(require("os"));
 var formatHost = {
   getCurrentDirectory: () => import_typescript.default.sys.getCurrentDirectory(),
   getNewLine: () => import_typescript.default.sys.newLine,
   getCanonicalFileName: import_typescript.default.sys.useCaseSensitiveFileNames ? (f) => f : (f) => f.toLowerCase()
 };
 var isCivet = (id) => /\.civet$/.test(id);
-var isCivetTranspiled = (id) => /\.civet\.(m?)(j|t)s(x?)(\?transform)?$/.test(id);
-var isCivetTranspiledTS = (id) => /\.civet\.(m?)ts(x?)$/.test(id);
+var isCivetTranspiled = (id) => /\.civet\.[jt]sx(\?transform)?$/.test(id);
+var isCivetTranspiledTS = (id) => /\.civet\.tsx$/.test(id);
+var postfixRE = /(\.[jt]sx)?[?#].*$/s;
+var isWindows = import_os.default.platform() === "win32";
+var windowsSlashRE = /\\/g;
+function cleanCivetId(id) {
+  return id.replace(postfixRE, "");
+}
+function tryStatSync(file) {
+  try {
+    return fs.statSync(file, { throwIfNoEntry: false });
+  } catch {
+    return void 0;
+  }
+}
+function slash(p) {
+  return p.replace(windowsSlashRE, "/");
+}
+function normalizePath(id) {
+  return import_path.default.posix.normalize(isWindows ? slash(id) : id);
+}
+function tryFsResolve(file) {
+  const fileStat = tryStatSync(file);
+  if (fileStat?.isFile())
+    return normalizePath(file);
+  return void 0;
+}
+function resolveAbsolutePath(rootDir, id) {
+  const resolved = tryFsResolve(import_path.default.join(rootDir, id));
+  if (!resolved)
+    return tryFsResolve(id);
+  return resolved;
+}
 var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   if (options.dts && options.js) {
     throw new Error("Can't have both `dts` and `js` be set to `true`.");
@@ -62,7 +94,7 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
   let fsMap = /* @__PURE__ */ new Map();
   const sourceMaps = /* @__PURE__ */ new Map();
   let compilerOptions;
-  let rootDir;
+  let rootDir = process.cwd();
   return {
     name: "unplugin-civet",
     enforce: "pre",
@@ -162,10 +194,11 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
         return null;
       if (!isCivet(id) && !isCivetTranspiled(id))
         return null;
-      const absolutePath = rootDir != null && import_path.default.isAbsolute(id) ? import_path.default.join(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      id = cleanCivetId(id);
+      const absolutePath = import_path.default.isAbsolute(id) ? resolveAbsolutePath(rootDir, id) : import_path.default.resolve(import_path.default.dirname(importer ?? ""), id);
+      if (!absolutePath)
+        return null;
       const relativeId = import_path.default.relative(process.cwd(), absolutePath);
-      if (isCivetTranspiled(id))
-        return relativeId.replace(/\?transform$/, "");
       const relativePath = relativeId + outExt;
       return relativePath;
     },
@@ -206,9 +239,9 @@ var civetUnplugin = (0, import_unplugin.createUnplugin)((options = {}) => {
       if (options.dts || options.typecheck) {
         const resolved = import_path.default.resolve(process.cwd(), id);
         fsMap.set(resolved, code);
-        const slash = resolved.replace(/\\/g, "/");
-        if (resolved !== slash)
-          fsMap.set(slash, code);
+        const slashed = slash(resolved);
+        if (resolved !== slashed)
+          fsMap.set(slashed, code);
       }
       return null;
     },