@danielx/civet 0.11.2 → 0.11.3

package/dist/main.mjs

@@ -2912,20 +2912,7 @@ function wrapTypeInApplication(t, id, raw) {
 }
 function implicitFunctionBlock(f) {
   if (f.abstract || f.block || f.signature?.optional) return;
-  const { name, parent } = f;
-  let ancestor = parent;
-  let child = f;
-  if (ancestor?.type === "ExportDeclaration") {
-    child = ancestor;
-    ancestor = ancestor.parent;
-  }
-  const expressions = ancestor?.expressions ?? ancestor?.elements;
-  const currentIndex = expressions?.findIndex(([, def]) => def === child);
-  let following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
-  if (following?.type === "ExportDeclaration") {
-    following = following.declaration;
-  }
-  if (f.type === following?.type && name != null && name === following.name) {
+  if (followingOverloads(f).length) {
     f.ts = true;
   } else {
     const block = makeEmptyBlock();
@@ -2935,6 +2922,66 @@ function implicitFunctionBlock(f) {
     f.ts = false;
   }
 }
+function overloadsInDirection(f, direction) {
+  if (!(f.name != null)) {
+    return [];
+  }
+  let ancestor = f.parent;
+  let child = f;
+  if (ancestor?.type === "ExportDeclaration") {
+    child = ancestor;
+    ancestor = ancestor.parent;
+  }
+  if (!(ancestor?.type === "BlockStatement")) {
+    return [];
+  }
+  const { expressions } = ancestor;
+  let index = findChildIndex(expressions, child);
+  if (!(index >= 0)) {
+    return [];
+  }
+  if (direction < 0) {
+    const results1 = [];
+    while (--index >= 0) {
+      let candidate = expressions[index][1];
+      if (!candidate) {
+        break;
+      }
+      if (candidate.type === "ExportDeclaration") {
+        candidate = candidate.declaration;
+      }
+      if (!(candidate && candidate.type === f.type && candidate.name === f.name)) {
+        break;
+      }
+      results1.push(candidate);
+    }
+    ;
+    return results1;
+  } else {
+    const results2 = [];
+    while (++index < expressions.length) {
+      let candidate = expressions[index][1];
+      if (!candidate) {
+        break;
+      }
+      if (candidate.type === "ExportDeclaration") {
+        candidate = candidate.declaration;
+      }
+      if (!(candidate && candidate.type === f.type && candidate.name === f.name)) {
+        break;
+      }
+      results2.push(candidate);
+    }
+    ;
+    return results2;
+  }
+}
+function precedingOverloads(f) {
+  return overloadsInDirection(f, -1);
+}
+function followingOverloads(f) {
+  return overloadsInDirection(f, 1);
+}
 function processReturn(f, implicitReturns) {
   let { returnType } = f.signature;
   if (returnType && returnType.optional) {
@@ -3968,10 +4015,7 @@ function processParams(f) {
       const classExpressions = ancestor.body.expressions;
       let index2 = findChildIndex(classExpressions, f);
       assert.notEqual(index2, -1, "Could not find constructor in class");
-      let m7;
-      while (m7 = classExpressions[index2 - 1]?.[1], typeof m7 === "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor") {
-        index2--;
-      }
+      index2 -= precedingOverloads(f).length;
       const fStatement = classExpressions[index2];
       for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
         const parameter = ref20[i10];
@@ -4066,10 +4110,11 @@ function findSuperCall(block) {
 }
 function processSignature(f) {
   const { block, signature } = f;
+  let addAsync = false;
+  let addGenerator = false;
   if (!f.async?.length && hasAwait(block)) {
     if (f.async != null) {
-      f.async.push("async ");
-      signature.modifier.async = true;
+      addAsync = true;
     } else {
       for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
         const a = ref23[i13];
@@ -4083,8 +4128,7 @@ function processSignature(f) {
   }
   if (!f.generator?.length && hasYield(block)) {
     if (f.generator != null) {
-      f.generator.push("*");
-      signature.modifier.generator = true;
+      addGenerator = true;
     } else {
       for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
         const y = ref24[i14];
@@ -4096,17 +4140,28 @@ function processSignature(f) {
       }
     }
   }
-  if (signature.modifier.async && !signature.modifier.generator && signature.returnType && !isPromiseType(signature.returnType.t)) {
-    replaceNode(
-      signature.returnType.t,
-      wrapTypeInPromise(signature.returnType.t),
-      signature.returnType
-    );
+  for (let ref25 = [f, ...precedingOverloads(f)], i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
+    const overload = ref25[i15];
+    if (addAsync && overload.async != null && !overload.async.length) {
+      overload.async.push("async ");
+      overload.signature.modifier.async = true;
+    }
+    if (addGenerator && overload.generator != null && !overload.generator.length) {
+      overload.generator.push("*");
+      overload.signature.modifier.generator = true;
+    }
+    if (overload.signature.modifier.async && !overload.signature.modifier.generator && overload.signature.returnType && !isPromiseType(overload.signature.returnType.t)) {
+      replaceNode(
+        overload.signature.returnType.t,
+        wrapTypeInPromise(overload.signature.returnType.t),
+        overload.signature.returnType
+      );
+    }
   }
 }
 function processFunctions(statements, config2) {
-  for (let ref25 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i15 = 0, len14 = ref25.length; i15 < len14; i15++) {
-    const f = ref25[i15];
+  for (let ref26 = gatherRecursiveAll(statements, ($20) => $20.type === "FunctionExpression" || $20.type === "ArrowFunction" || $20.type === "MethodDefinition"), i16 = 0, len15 = ref26.length; i16 < len15; i16++) {
+    const f = ref26[i16];
     if (f.type === "FunctionExpression" || f.type === "MethodDefinition") {
       implicitFunctionBlock(f);
     }
@@ -4165,9 +4220,9 @@ function expressionizeIteration(exp) {
   }
   let done;
   if (!async) {
-    let ref26;
-    if ((ref26 = blockContainingStatement(exp)) && typeof ref26 === "object" && "block" in ref26 && "index" in ref26) {
-      const { block: parentBlock, index } = ref26;
+    let ref27;
+    if ((ref27 = blockContainingStatement(exp)) && typeof ref27 === "object" && "block" in ref27 && "index" in ref27) {
+      const { block: parentBlock, index } = ref27;
       statements[0][0] = parentBlock.expressions[index][0];
       parentBlock.expressions.splice(index, index + 1 - index, ...statements);
       updateParentPointers(parentBlock);
@@ -4184,8 +4239,8 @@ function expressionizeIteration(exp) {
   }
 }
 function processIterationExpressions(statements) {
-  for (let ref27 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i16 = 0, len15 = ref27.length; i16 < len15; i16++) {
-    const s = ref27[i16];
+  for (let ref28 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref28.length; i17 < len16; i17++) {
+    const s = ref28[i17];
     expressionizeIteration(s);
   }
 }
@@ -4208,13 +4263,13 @@ function processCoffeeDo(ws, expression) {
   if (typeof expression === "object" && expression != null && "type" in expression && expression.type === "ArrowFunction" || typeof expression === "object" && expression != null && "type" in expression && expression.type === "FunctionExpression") {
     let { parameters } = expression;
     const parameterList = parameters.parameters;
-    const results1 = [];
-    for (let i17 = 0, len16 = parameterList.length; i17 < len16; i17++) {
-      let parameter = parameterList[i17];
+    const results3 = [];
+    for (let i18 = 0, len17 = parameterList.length; i18 < len17; i18++) {
+      let parameter = parameterList[i18];
       if (typeof parameter === "object" && parameter != null && "type" in parameter && parameter.type === "Parameter") {
-        let ref28;
-        if (ref28 = parameter.initializer) {
-          const initializer = ref28;
+        let ref29;
+        if (ref29 = parameter.initializer) {
+          const initializer = ref29;
           args.push(initializer.expression, parameter.delim);
           parameter = {
             ...parameter,
@@ -4227,10 +4282,10 @@ function processCoffeeDo(ws, expression) {
           ));
         }
       }
-      results1.push(parameter);
+      results3.push(parameter);
     }
     ;
-    const newParameterList = results1;
+    const newParameterList = results3;
     const newParameters = {
       ...parameters,
       parameters: newParameterList,
@@ -9166,12 +9221,16 @@ var grammar = {
   CommaDelimiter,
   OptionalCommaDelimiter,
   ArgumentList,
+  PostfixedArgumentList,
   NestedArguments,
   NestedArgumentList,
   NestedArgument,
   SingleLineArgumentExpressions,
   WArgumentPart,
+  SingleLinePostfixedArgumentExpressions,
+  WPostfixedArgumentPart,
   ArgumentPart,
+  PostfixedArgumentPart,
   BinaryOpExpression,
   BinaryOpNotDedented,
   BinaryOpRHS,
@@ -9554,6 +9613,7 @@ var grammar = {
   Debugger,
   MaybeNestedNonPipelineExpression,
   MaybeNestedPostfixedExpression,
+  MaybeNestedPostfixedCommaExpression,
   NestedPostfixedExpressionNoTrailing,
   MaybeNestedExpression,
   MaybeParenNestedExpression,
@@ -10569,7 +10629,7 @@ var ImplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ApplicationSt
 function ImplicitArguments(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ImplicitArguments", ImplicitArguments$0);
 }
-var ExplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(ArgumentList, (0, import_lib2.$E)((0, import_lib2.$S)(__, Comma)))), __, RestoreAll, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ExplicitArguments$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenParen, AllowAll, (0, import_lib2.$E)((0, import_lib2.$S)(PostfixedArgumentList, (0, import_lib2.$E)((0, import_lib2.$S)(__, Comma)))), __, RestoreAll, CloseParen), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var open = $1;
   var args = $3;
   var ws = $4;
@@ -10707,6 +10767,35 @@ var ArgumentList$$ = [ArgumentList$0, ArgumentList$1, ArgumentList$2];
 function ArgumentList(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArgumentList", ArgumentList$$);
 }
+var PostfixedArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(EOS), PostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, (0, import_lib2.$N)(EOS), (0, import_lib2.$E)(_), PostfixedArgumentPart)), (0, import_lib2.$S)(CommaDelimiter, NestedArguments), (0, import_lib2.$Q)((0, import_lib2.$S)(OptionalCommaDelimiter, NestedArguments))), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  return [
+    $2,
+    ...$3.flatMap(([comma, eos, ws, arg]) => [comma, prepend(ws, arg)]),
+    ...Array.isArray($4[1]) ? [$4[0], ...$4[1]] : $4,
+    ...$5.flatMap(
+      ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
+    )
+  ];
+});
+var PostfixedArgumentList$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(NestedArguments, (0, import_lib2.$Q)((0, import_lib2.$S)(OptionalCommaDelimiter, NestedArguments))), function($skip, $loc, $0, $1, $2) {
+  if (!Array.isArray($1)) $1 = [$1];
+  return [
+    ...trimFirstSpace($1),
+    ...$2.flatMap(
+      ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
+    )
+  ];
+});
+var PostfixedArgumentList$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, (0, import_lib2.$E)(_), PostfixedArgumentPart))), function($skip, $loc, $0, $1, $2, $3) {
+  return [
+    prepend($1, $2),
+    ...$3.flatMap(([comma, ws, arg]) => [comma, prepend(ws, arg)])
+  ];
+});
+var PostfixedArgumentList$$ = [PostfixedArgumentList$0, PostfixedArgumentList$1, PostfixedArgumentList$2];
+function PostfixedArgumentList(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedArgumentList", PostfixedArgumentList$$);
+}
 var NestedArguments$0 = NestedBulletedArray;
 var NestedArguments$1 = NestedImplicitObjectLiteral;
 var NestedArguments$2 = NestedArgumentList;
@@ -10722,7 +10811,7 @@ var NestedArgumentList$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent,
 function NestedArgumentList(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NestedArgumentList", NestedArgumentList$0);
 }
-var NestedArgument$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedImplicitPropertyDefinition), Nested, (0, import_lib2.$N)(Bullet), SingleLineArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+var NestedArgument$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedImplicitPropertyDefinition), Nested, (0, import_lib2.$N)(Bullet), SingleLinePostfixedArgumentExpressions, ParameterElementDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var indent = $2;
   var args = $4;
   var comma = $5;
@@ -10745,6 +10834,18 @@ var WArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$
 function WArgumentPart(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "WArgumentPart", WArgumentPart$0);
 }
+var SingleLinePostfixedArgumentExpressions$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(WPostfixedArgumentPart, (0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), Comma), WPostfixedArgumentPart))), function($skip, $loc, $0, $1, $2) {
+  return [$1, ...$2.flat()];
+});
+function SingleLinePostfixedArgumentExpressions(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "SingleLinePostfixedArgumentExpressions", SingleLinePostfixedArgumentExpressions$0);
+}
+var WPostfixedArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixedArgumentPart), function($skip, $loc, $0, $1, $2) {
+  return prepend($1, $2);
+});
+function WPostfixedArgumentPart(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "WPostfixedArgumentPart", WPostfixedArgumentPart$0);
+}
 var ArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(DotDotDot, Expression), function($skip, $loc, $0, $1, $2) {
   var spread = $1;
   var expression = $2;
@@ -10769,6 +10870,30 @@ var ArgumentPart$$ = [ArgumentPart$0, ArgumentPart$1];
 function ArgumentPart(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ArgumentPart", ArgumentPart$$);
 }
+var PostfixedArgumentPart$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(DotDotDot, PostfixedExpression), function($skip, $loc, $0, $1, $2) {
+  var spread = $1;
+  var expression = $2;
+  return {
+    type: "Argument",
+    children: $0,
+    expression,
+    spread
+  };
+});
+var PostfixedArgumentPart$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(PostfixedExpression, (0, import_lib2.$E)(DotDotDot)), function($skip, $loc, $0, $1, $2) {
+  var expression = $1;
+  var spread = $2;
+  return {
+    type: "Argument",
+    children: spread ? [spread, expression] : [expression],
+    expression,
+    spread
+  };
+});
+var PostfixedArgumentPart$$ = [PostfixedArgumentPart$0, PostfixedArgumentPart$1];
+function PostfixedArgumentPart(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedArgumentPart", PostfixedArgumentPart$$);
+}
 var BinaryOpExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(UnaryExpression, (0, import_lib2.$Q)(BinaryOpRHS)), function($skip, $loc, $0, $1, $2) {
   if (!$2.length) return $1;
   return processBinaryOpExpression($0);
@@ -10801,10 +10926,13 @@ var BinaryOpRHS$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(BinaryOp, RHS), fun
 var BinaryOpRHS$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NewlineBinaryOpAllowed, NotDedentedBinaryOp, WRHS), function($skip, $loc, $0, $1, $2, $3) {
   var op = $2;
   var rhs = $3;
+  if (op[1].token === ">" && op[0].length === 0) return $skip;
   return [...op, ...rhs];
 });
-var BinaryOpRHS$3 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
-  return value[1];
+var BinaryOpRHS$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function($skip, $loc, $0, $1, $2) {
+  const [ws1, op] = $2;
+  if (op.token === ">" && !ws1.length) return $skip;
+  return $2;
 });
 var BinaryOpRHS$$ = [BinaryOpRHS$0, BinaryOpRHS$1, BinaryOpRHS$2, BinaryOpRHS$3];
 function BinaryOpRHS(ctx, state2) {
@@ -11759,7 +11887,7 @@ var FieldDefinition$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CoffeeClassesEn
       };
   }
 });
-var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var FieldDefinition$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertReadonly, ClassElementName, (0, import_lib2.$E)(TypeSuffix), __, ConstAssignment, MaybeNestedPostfixedCommaExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var readonly = $1;
   var id = $2;
   var typeSuffix = $3;
@@ -15527,26 +15655,37 @@ var PostfixedNoCommaStatement$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(NoCom
 function PostfixedNoCommaStatement(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedNoCommaStatement", PostfixedNoCommaStatement$0);
 }
-var PostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+var PostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(AssignmentExpressionSpread, (0, import_lib2.$E)(_), (0, import_lib2.$N)(IfClause), PostfixStatement), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $1;
+  var ws = $2;
+  var post = $4;
+  return attachPostfixStatementAsExpression(expression, [ws, post]);
+});
+var PostfixedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement)), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (post) return attachPostfixStatementAsExpression(expression, post);
-  return expression;
+  return attachPostfixStatementAsExpression(expression, post);
 });
+var PostfixedExpression$2 = Expression;
+var PostfixedExpression$$ = [PostfixedExpression$0, PostfixedExpression$1, PostfixedExpression$2];
 function PostfixedExpression(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedExpression", PostfixedExpression$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedExpression", PostfixedExpression$$);
 }
-var PostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(PostfixedExpression, (0, import_lib2.$C)((0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement), (0, import_lib2.$Q)((0, import_lib2.$S)(CommaDelimiter, AssignmentExpression)))), function($skip, $loc, $0, $1, $2) {
+var PostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(CommaExpressionSpread, (0, import_lib2.$E)(_), (0, import_lib2.$N)(IfClause), PostfixStatement), function($skip, $loc, $0, $1, $2, $3, $4) {
+  var expression = $1;
+  var ws = $2;
+  var post = $4;
+  return attachPostfixStatementAsExpression(expression, [ws, post]);
+});
+var PostfixedCommaExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Expression, (0, import_lib2.$S)((0, import_lib2.$E)(_), PostfixStatement)), function($skip, $loc, $0, $1, $2) {
   var expression = $1;
   var post = $2;
-  if (!post.length) return $1;
-  if (post.length === 2 && !Array.isArray(post[1])) {
-    return attachPostfixStatementAsExpression(expression, post);
-  }
-  return $0;
+  return attachPostfixStatementAsExpression(expression, post);
 });
+var PostfixedCommaExpression$2 = CommaExpression;
+var PostfixedCommaExpression$$ = [PostfixedCommaExpression$0, PostfixedCommaExpression$1, PostfixedCommaExpression$2];
 function PostfixedCommaExpression(ctx, state2) {
-  return (0, import_lib2.$EVENT)(ctx, state2, "PostfixedCommaExpression", PostfixedCommaExpression$0);
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "PostfixedCommaExpression", PostfixedCommaExpression$$);
 }
 var PostfixStatement$0 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$EXPECT)($R31, "PostfixStatement /(?=for|if|loop|unless|until|while)/"), _PostfixStatement), function(value) {
   return value[1];
@@ -16998,6 +17137,22 @@ var MaybeNestedPostfixedExpression$$ = [MaybeNestedPostfixedExpression$0, MaybeN
 function MaybeNestedPostfixedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedExpression", MaybeNestedPostfixedExpression$$);
 }
+var MaybeNestedPostfixedCommaExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NestedBulletedArray), (0, import_lib2.$N)(NestedImplicitObjectLiteral), PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedCommaExpression)), PopIndent, (0, import_lib2.$E)(AllowedTrailingCallExpressions)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+  var expression = $4;
+  var trailing = $6;
+  if (!expression) return $skip;
+  if (!trailing) return expression;
+  return [expression, trailing];
+});
+var MaybeNestedPostfixedCommaExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(PostfixedCommaExpression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var expression = $2;
+  if (!expression) return $skip;
+  return expression;
+});
+var MaybeNestedPostfixedCommaExpression$$ = [MaybeNestedPostfixedCommaExpression$0, MaybeNestedPostfixedCommaExpression$1];
+function MaybeNestedPostfixedCommaExpression(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedCommaExpression", MaybeNestedPostfixedCommaExpression$$);
+}
 var NestedPostfixedExpressionNoTrailing$0 = NestedBulletedArray;
 var NestedPostfixedExpressionNoTrailing$1 = NestedImplicitObjectLiteral;
 var NestedPostfixedExpressionNoTrailing$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(PushIndent, (0, import_lib2.$E)((0, import_lib2.$S)(Nested, PostfixedExpression)), PopIndent), function($skip, $loc, $0, $1, $2, $3) {
@@ -17448,7 +17603,7 @@ var ExportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
     }
   ];
 });
-var ExportDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Decorators), Export, __, Default, __, (0, import_lib2.$C)(HoistableDeclaration, ClassDeclaration, InterfaceDeclaration, MaybeNestedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ExportDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(Decorators), Export, __, Default, __, (0, import_lib2.$C)(HoistableDeclaration, ClassDeclaration, InterfaceDeclaration, MaybeNestedPostfixedExpression)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var declaration = $6;
   return { type: "ExportDeclaration", declaration, ts: declaration.ts, children: $0 };
 });
@@ -17571,7 +17726,7 @@ var LexicalDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(LetOrConst,
     thisAssignments: bindings.flatMap((b) => b.thisAssignments)
   };
 });
-var LexicalDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(TypeSuffix), __, (0, import_lib2.$C)(ConstAssignment, LetAssignment), MaybeNestedPostfixedExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var LexicalDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, (0, import_lib2.$C)(BindingPattern, BindingIdentifier), (0, import_lib2.$E)(TypeSuffix), __, (0, import_lib2.$C)(ConstAssignment, LetAssignment), MaybeNestedPostfixedCommaExpression), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var loc = $1;
   var assign = $5;
   return processAssignmentDeclaration(
@@ -17637,7 +17792,7 @@ var LexicalBinding$$ = [LexicalBinding$0, LexicalBinding$1];
 function LexicalBinding(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "LexicalBinding", LexicalBinding$$);
 }
-var Initializer$0 = (0, import_lib2.$T)((0, import_lib2.$S)(__, Equals, MaybeNestedExpression), function(value) {
+var Initializer$0 = (0, import_lib2.$T)((0, import_lib2.$S)(__, Equals, MaybeNestedPostfixedExpression), function(value) {
   var expression = value[2];
   return { "type": "Initializer", "expression": expression, "children": value };
 });

package/dist/unplugin/unplugin.js

@@ -40,7 +40,180 @@ var import_config = require("@danielx/civet/config");
 var import_ts_diagnostic = require("@danielx/civet/ts-diagnostic");
 var fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
-var tsvfs = __toESM(require("@typescript/vfs"));
+
+// node_modules/@typescript/vfs/dist/vfs.esm.js
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+var hasLocalStorage = false;
+try {
+  hasLocalStorage = typeof localStorage !== "undefined";
+} catch (error) {
+}
+var hasProcess = typeof process !== "undefined";
+var shouldDebug = hasLocalStorage && /* @__PURE__ */ localStorage.getItem("DEBUG") || hasProcess && process.env.DEBUG;
+var debugLog = shouldDebug ? console.log : function(_message) {
+  return "";
+};
+function notImplemented(methodName) {
+  throw new Error("Method '" + methodName + "' is not implemented.");
+}
+function audit(name, fn) {
+  return function() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    var res = fn.apply(void 0, args);
+    var smallres = typeof res === "string" ? res.slice(0, 80) + "..." : res;
+    debugLog.apply(void 0, ["> " + name].concat(args));
+    debugLog("< " + smallres);
+    return res;
+  };
+}
+var defaultCompilerOptions = function defaultCompilerOptions2(ts) {
+  return _extends({}, ts.getDefaultCompilerOptions(), {
+    jsx: ts.JsxEmit.React,
+    strict: true,
+    esModuleInterop: true,
+    module: ts.ModuleKind.ESNext,
+    suppressOutputPathCheck: true,
+    skipLibCheck: true,
+    skipDefaultLibCheck: true,
+    moduleResolution: ts.ModuleResolutionKind.NodeJs
+  });
+};
+function createFSBackedSystem(files, _projectRoot, ts, tsLibDirectory) {
+  var root = _projectRoot + "/vfs";
+  var path2 = requirePath();
+  var nodeSys = ts.sys;
+  var tsLib = tsLibDirectory != null ? tsLibDirectory : path2.dirname(require.resolve("typescript"));
+  return {
+    // @ts-ignore
+    name: "fs-vfs",
+    root,
+    args: [],
+    createDirectory: function createDirectory() {
+      return notImplemented("createDirectory");
+    },
+    // TODO: could make a real file tree
+    directoryExists: audit("directoryExists", function(directory) {
+      return Array.from(files.keys()).some(function(path3) {
+        return path3.startsWith(directory);
+      }) || nodeSys.directoryExists(directory);
+    }),
+    exit: nodeSys.exit,
+    fileExists: audit("fileExists", function(fileName) {
+      if (files.has(fileName)) return true;
+      if (fileName.includes("tsconfig.json") || fileName.includes("tsconfig.json")) return false;
+      if (fileName.startsWith("/lib")) {
+        var tsLibName = tsLib + "/" + fileName.replace("/", "");
+        return nodeSys.fileExists(tsLibName);
+      }
+      return nodeSys.fileExists(fileName);
+    }),
+    getCurrentDirectory: function getCurrentDirectory() {
+      return root;
+    },
+    getDirectories: nodeSys.getDirectories,
+    getExecutingFilePath: function getExecutingFilePath() {
+      return notImplemented("getExecutingFilePath");
+    },
+    readDirectory: audit("readDirectory", function() {
+      if ((arguments.length <= 0 ? void 0 : arguments[0]) === "/") {
+        return Array.from(files.keys());
+      } else {
+        return nodeSys.readDirectory.apply(nodeSys, arguments);
+      }
+    }),
+    readFile: audit("readFile", function(fileName) {
+      if (files.has(fileName)) return files.get(fileName);
+      if (fileName.startsWith("/lib")) {
+        var tsLibName = tsLib + "/" + fileName.replace("/", "");
+        var result = nodeSys.readFile(tsLibName);
+        if (!result) {
+          var libs = nodeSys.readDirectory(tsLib);
+          throw new Error("TSVFS: A request was made for " + tsLibName + " but there wasn't a file found in the file map. You likely have a mismatch in the compiler options for the CDN download vs the compiler program. Existing Libs: " + libs + ".");
+        }
+        return result;
+      }
+      return nodeSys.readFile(fileName);
+    }),
+    resolvePath: function resolvePath(path3) {
+      if (files.has(path3)) return path3;
+      return nodeSys.resolvePath(path3);
+    },
+    newLine: "\n",
+    useCaseSensitiveFileNames: true,
+    write: function write() {
+      return notImplemented("write");
+    },
+    writeFile: function writeFile(fileName, contents) {
+      files.set(fileName, contents);
+    },
+    deleteFile: function deleteFile(fileName) {
+      files["delete"](fileName);
+    },
+    realpath: nodeSys.realpath
+  };
+}
+function createVirtualCompilerHost(sys, compilerOptions, ts) {
+  var sourceFiles = /* @__PURE__ */ new Map();
+  var save = function save2(sourceFile) {
+    sourceFiles.set(sourceFile.fileName, sourceFile);
+    return sourceFile;
+  };
+  var vHost = {
+    compilerHost: _extends({}, sys, {
+      getCanonicalFileName: function getCanonicalFileName(fileName) {
+        return fileName;
+      },
+      getDefaultLibFileName: function getDefaultLibFileName() {
+        return "/" + ts.getDefaultLibFileName(compilerOptions);
+      },
+      // '/lib.d.ts',
+      // getDefaultLibLocation: () => '/',
+      getNewLine: function getNewLine() {
+        return sys.newLine;
+      },
+      getSourceFile: function getSourceFile(fileName, languageVersionOrOptions) {
+        var _ref;
+        return sourceFiles.get(fileName) || save(ts.createSourceFile(fileName, sys.readFile(fileName), (_ref = languageVersionOrOptions != null ? languageVersionOrOptions : compilerOptions.target) != null ? _ref : defaultCompilerOptions(ts).target, false));
+      },
+      useCaseSensitiveFileNames: function useCaseSensitiveFileNames() {
+        return sys.useCaseSensitiveFileNames;
+      }
+    }),
+    updateFile: function updateFile(sourceFile) {
+      var alreadyExists = sourceFiles.has(sourceFile.fileName);
+      sys.writeFile(sourceFile.fileName, sourceFile.text);
+      sourceFiles.set(sourceFile.fileName, sourceFile);
+      return alreadyExists;
+    },
+    deleteFile: function deleteFile(sourceFile) {
+      var alreadyExists = sourceFiles.has(sourceFile.fileName);
+      sourceFiles["delete"](sourceFile.fileName);
+      sys.deleteFile(sourceFile.fileName);
+      return alreadyExists;
+    }
+  };
+  return vHost;
+}
+var requirePath = function requirePath2() {
+  return require(String.fromCharCode(112, 97, 116, 104));
+};
+
+// unplugin-civet:C:\Users\edemaine\Projects\Civet\source\unplugin\unplugin.civet.jsx
 var import_os = __toESM(require("os"));
 
 // source/unplugin/constants.mjs
@@ -219,7 +392,7 @@ var rawPlugin = (options = {}, meta) => {
     async buildEnd(useConfigFileNames = false) {
       if (transformTS) {
         const ts2 = await tsPromise;
-        const system = tsvfs.createFSBackedSystem(fsMap, process.cwd(), ts2);
+        const system = createFSBackedSystem(fsMap, process.cwd(), ts2);
         const {
           fileExists: systemFileExists,
           readFile: systemReadFile,
@@ -280,7 +453,7 @@ var rawPlugin = (options = {}, meta) => {
           sourceMaps.set(filename, sourceMap);
           return compiledTS;
         };
-        const host = tsvfs.createVirtualCompilerHost(
+        const host = createVirtualCompilerHost(
           system,
           compilerOptions,
           ts2