@danielx/civet 0.11.2 → 0.11.3

package/CHANGELOG.md

@@ -4,6 +4,22 @@ This changelog is generated automatically by [`build/changelog.civet`](build/cha
 For each version of Civet, it lists and links to all incorporated PRs,
 as well as a full diff and commit list.
 
+## 0.11.3 (2026-02-25, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.2...v0.11.3), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.3))
+* Fix REPL continuation prompt to `...`, clarifying indentation [[#1843](https://github.com/DanielXMoore/Civet/pull/1843)]
+* Don't treat `package.js/civet` as config [[#1844](https://github.com/DanielXMoore/Civet/pull/1844)]
+  * BREAKING CHANGE: Civet can no longer be configured from a default export of `package.js` or `package.civet`
+* Make typescript an optional peer dep, bundle @typescript/vfs [[#1842](https://github.com/DanielXMoore/Civet/pull/1842)]
+* Tests for CLI output filename generation [[#1847](https://github.com/DanielXMoore/Civet/pull/1847)]
+* `>` closes type arguments; forbid binary `x> y` [[#1848](https://github.com/DanielXMoore/Civet/pull/1848)]
+  * BREAKING CHANGE: `x> y` no longer compares; use `x>y` or `x > y`
+* LSP: ensure immediate updates for opened dependent files on change [[#1779](https://github.com/DanielXMoore/Civet/pull/1779)]
+* Spreads and multiple items in parenthesized postfix loops, postfixes in declarations [[#1849](https://github.com/DanielXMoore/Civet/pull/1849)]
+* Syntax highlighting for import/export shorthands and `for` keywords [[#1580](https://github.com/DanielXMoore/Civet/pull/1580)]
+* Implicit `async`, `AutoPromise`, `function*` propagate to overloads [[#1852](https://github.com/DanielXMoore/Civet/pull/1852)]
+* Postfix support in parenthesized or indented function arguments [[#1853](https://github.com/DanielXMoore/Civet/pull/1853)]
+  * BREAKING CHANGE: Function application with a postfix on the last indented argument now applies the postfix to the argument, not the whole function application.
+* Website playground: tab key insert tabs or indents, escape key defocuses [[#1626](https://github.com/DanielXMoore/Civet/pull/1626)]
+
 ## 0.11.2 (2026-01-21, [diff](https://github.com/DanielXMoore/Civet/compare/v0.11.1...v0.11.2), [commits](https://github.com/DanielXMoore/Civet/commits/v0.11.2))
 * VSCode extension supports rename-symbol [[#1823](https://github.com/DanielXMoore/Civet/pull/1823)]
 * Fix scoping of unwrapped statement expressions [[#1833](https://github.com/DanielXMoore/Civet/pull/1833)]

package/README.md

@@ -46,6 +46,9 @@ civet < source.civet > output.ts
 civet source.civet ...args...
 # Execute a .civet source file in node
 node --import @danielx/civet/register source.civet
+# Type check entire project, which requires TypeScript installed
+npm install -g typescript
+civet --typecheck
 ```
 
 ![image](https://user-images.githubusercontent.com/18894/184558519-b675a903-7490-43ba-883e-0d8addacd4b9.png)

package/dist/browser.js

@@ -2328,17 +2328,49 @@ ${js}`
     };
   }
   function implicitFunctionBlock(f) {
-    if (f.abstract || f.block || f.signature?.optional) return;
-    let { name, parent } = f, ancestor = parent, child = f;
-    ancestor?.type === "ExportDeclaration" && (child = ancestor, ancestor = ancestor.parent);
-    let expressions = ancestor?.expressions ?? ancestor?.elements, currentIndex = expressions?.findIndex(([, def]) => def === child), following = currentIndex >= 0 && expressions[currentIndex + 1]?.[1];
-    if (following?.type === "ExportDeclaration" && (following = following.declaration), f.type === following?.type && name != null && name === following.name)
-      f.ts = !0;
-    else {
-      let block = makeEmptyBlock();
-      block.parent = f, f.block = block, f.children.push(block), f.ts = !1;
+    if (!(f.abstract || f.block || f.signature?.optional))
+      if (followingOverloads(f).length)
+        f.ts = !0;
+      else {
+        let block = makeEmptyBlock();
+        block.parent = f, f.block = block, f.children.push(block), f.ts = !1;
+      }
+  }
+  function overloadsInDirection(f, direction) {
+    if (f.name == null)
+      return [];
+    let ancestor = f.parent, child = f;
+    if (ancestor?.type === "ExportDeclaration" && (child = ancestor, ancestor = ancestor.parent), ancestor?.type !== "BlockStatement")
+      return [];
+    let { expressions } = ancestor, index = findChildIndex(expressions, child);
+    if (!(index >= 0))
+      return [];
+    if (direction < 0) {
+      let results1 = [];
+      for (; --index >= 0; ) {
+        let candidate = expressions[index][1];
+        if (!candidate || (candidate.type === "ExportDeclaration" && (candidate = candidate.declaration), !(candidate && candidate.type === f.type && candidate.name === f.name)))
+          break;
+        results1.push(candidate);
+      }
+      return results1;
+    } else {
+      let results2 = [];
+      for (; ++index < expressions.length; ) {
+        let candidate = expressions[index][1];
+        if (!candidate || (candidate.type === "ExportDeclaration" && (candidate = candidate.declaration), !(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 && convertOptionalType(returnType), !processReturnValue(f) && (implicitReturns || f.signature.implicitReturn)) {
@@ -3076,10 +3108,7 @@ ${js}`
       let { ancestor } = findAncestor(f, ($10) => $10.type === "ClassExpression");
       if (ancestor != null) {
         let fields = new Set(gatherRecursiveWithinFunction(ancestor, ($11) => $11.type === "FieldDefinition").map(($12) => $12.id).filter((a3) => typeof a3 == "object" && a3 != null && "type" in a3 && a3.type === "Identifier").map(($13) => $13.name)), classExpressions = ancestor.body.expressions, index2 = findChildIndex(classExpressions, f);
-        assert.notEqual(index2, -1, "Could not find constructor in class");
-        let m7;
-        for (; m7 = classExpressions[index2 - 1]?.[1], typeof m7 == "object" && m7 != null && "type" in m7 && m7.type === "MethodDefinition" && "name" in m7 && m7.name === "constructor"; )
-          index2--;
+        assert.notEqual(index2, -1, "Could not find constructor in class"), index2 -= precedingOverloads(f).length;
         let fStatement = classExpressions[index2];
         for (let ref20 = gatherRecursive(parameters, ($14) => $14.type === "Parameter"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
           let parameter = ref20[i10], { accessModifier } = parameter;
@@ -3145,10 +3174,10 @@ ${js}`
       return -1;
   }
   function processSignature(f) {
-    let { block, signature } = f;
+    let { block, signature } = f, addAsync = !1, addGenerator = !1;
     if (!f.async?.length && hasAwait(block))
       if (f.async != null)
-        f.async.push("async "), signature.modifier.async = !0;
+        addAsync = !0;
       else
         for (let ref23 = gatherRecursiveWithinFunction(block, ($17) => $17.type === "Await"), i13 = 0, len12 = ref23.length; i13 < len12; i13++) {
           let a = ref23[i13], i = findChildIndex(a.parent, a);
@@ -3159,7 +3188,7 @@ ${js}`
         }
     if (!f.generator?.length && hasYield(block))
       if (f.generator != null)
-        f.generator.push("*"), signature.modifier.generator = !0;
+        addGenerator = !0;
       else
         for (let ref24 = gatherRecursiveWithinFunction(block, ($18) => $18.type === "YieldExpression"), i14 = 0, len13 = ref24.length; i14 < len13; i14++) {
           let y = ref24[i14], i = y.children.findIndex(($19) => $19.type === "Yield");
@@ -3168,15 +3197,18 @@ ${js}`
             message: `yield invalid in ${f.type === "ArrowFunction" ? "=> arrow function" : signature.modifier.get ? "getter" : signature.modifier.set ? "setter" : signature.name}`
           });
         }
-    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++) {
+      let overload = ref25[i15];
+      addAsync && overload.async != null && !overload.async.length && (overload.async.push("async "), overload.signature.modifier.async = !0), addGenerator && overload.generator != null && !overload.generator.length && (overload.generator.push("*"), overload.signature.modifier.generator = !0), 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++) {
-      let 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++) {
+      let f = ref26[i16];
       (f.type === "FunctionExpression" || f.type === "MethodDefinition") && implicitFunctionBlock(f), processSignature(f), processParams(f), processReturn(f, config2.implicitReturns);
     }
   }
@@ -3223,17 +3255,17 @@ ${js}`
     }
     let done;
     if (!async) {
-      let ref26;
-      if ((ref26 = blockContainingStatement(exp)) && typeof ref26 == "object" && "block" in ref26 && "index" in ref26) {
-        let { block: parentBlock, index } = ref26;
+      let ref27;
+      if ((ref27 = blockContainingStatement(exp)) && typeof ref27 == "object" && "block" in ref27 && "index" in ref27) {
+        let { block: parentBlock, index } = ref27;
         statements[0][0] = parentBlock.expressions[index][0], parentBlock.expressions.splice(index, index + 1 - index, ...statements), updateParentPointers(parentBlock), braceBlock(parentBlock), done = !0;
       }
     }
     done || (generator || (statements[statements.length - 1][1] = wrapWithReturn(statements[statements.length - 1][1])), children.splice(i, 1, wrapIIFE(statements, async, generator)), updateParentPointers(exp));
   }
   function processIterationExpressions(statements) {
-    for (let ref27 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i16 = 0, len15 = ref27.length; i16 < len15; i16++) {
-      let s = ref27[i16];
+    for (let ref28 = gatherRecursiveAll(statements, ($21) => $21.type === "IterationExpression"), i17 = 0, len16 = ref28.length; i17 < len16; i17++) {
+      let s = ref28[i17];
       expressionizeIteration(s);
     }
   }
@@ -3248,13 +3280,13 @@ ${js}`
     ws = trimFirstSpace(ws);
     let args = [];
     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, parameterList = parameters.parameters, results1 = [];
-      for (let i17 = 0, len16 = parameterList.length; i17 < len16; i17++) {
-        let parameter = parameterList[i17];
+      let { parameters } = expression, parameterList = parameters.parameters, 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) {
-            let initializer = ref28;
+          let ref29;
+          if (ref29 = parameter.initializer) {
+            let initializer = ref29;
             args.push(initializer.expression, parameter.delim), parameter = {
               ...parameter,
               initializer: void 0,
@@ -3265,9 +3297,9 @@ ${js}`
               (a7) => a7 !== parameter.typeSuffix
             ));
         }
-        results1.push(parameter);
+        results3.push(parameter);
       }
-      let newParameterList = results1, newParameters = {
+      let newParameterList = results3, newParameters = {
         ...parameters,
         parameters: newParameterList,
         children: parameters.children.map(($22) => $22 === parameterList ? newParameterList : $22)
@@ -6734,12 +6766,16 @@ ${js}`
     CommaDelimiter,
     OptionalCommaDelimiter,
     ArgumentList,
+    PostfixedArgumentList,
     NestedArguments,
     NestedArgumentList,
     NestedArgument,
     SingleLineArgumentExpressions,
     WArgumentPart,
+    SingleLinePostfixedArgumentExpressions,
+    WPostfixedArgumentPart,
     ArgumentPart,
+    PostfixedArgumentPart,
     BinaryOpExpression,
     BinaryOpNotDedented,
     BinaryOpRHS,
@@ -7122,6 +7158,7 @@ ${js}`
     Debugger,
     MaybeNestedNonPipelineExpression,
     MaybeNestedPostfixedExpression,
+    MaybeNestedPostfixedCommaExpression,
     NestedPostfixedExpressionNoTrailing,
     MaybeNestedExpression,
     MaybeParenNestedExpression,
@@ -7729,7 +7766,7 @@ ${js}`
   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, args = $3, ws = $4, close = $6;
     return args ? args[1] ? args = [...args[0], args[1]] : args = args[0] : args = [], {
       type: "Call",
@@ -7828,6 +7865,31 @@ ${js}`
   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]
+      )
+    ];
+  }), 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) {
+    return Array.isArray($1) || ($1 = [$1]), [
+      ...trimFirstSpace($1),
+      ...$2.flatMap(
+        ([comma, args]) => Array.isArray(args) ? [comma, ...args] : [comma, args]
+      )
+    ];
+  }), 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)])
+    ];
+  }), 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, NestedArguments$1 = NestedImplicitObjectLiteral, NestedArguments$2 = NestedArgumentList, NestedArguments$$ = [NestedArguments$0, NestedArguments$1, NestedArguments$2];
   function NestedArguments(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "NestedArguments", NestedArguments$$);
@@ -7839,7 +7901,7 @@ ${js}`
   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, args = $4, comma = $5;
     let [arg0, ...rest] = args;
     return arg0 = prepend(indent, arg0), [arg0, ...rest, comma];
@@ -7859,6 +7921,18 @@ ${js}`
   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, expression = $2;
     return {
@@ -7879,6 +7953,26 @@ ${js}`
   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, expression = $2;
+    return {
+      type: "Argument",
+      children: $0,
+      expression,
+      spread
+    };
+  }), 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, spread = $2;
+    return {
+      type: "Argument",
+      children: spread ? [spread, expression] : [expression],
+      expression,
+      spread
+    };
+  }), 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) {
     return $2.length ? processBinaryOpExpression($0) : $1;
   });
@@ -7901,9 +7995,10 @@ ${js}`
     return [[], op, [], rhs];
   }), BinaryOpRHS$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(NewlineBinaryOpAllowed, NotDedentedBinaryOp, WRHS), function($skip, $loc, $0, $1, $2, $3) {
     var op = $2, rhs = $3;
-    return [...op, ...rhs];
-  }), BinaryOpRHS$3 = (0, import_lib2.$T)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function(value) {
-    return value[1];
+    return op[1].token === ">" && op[0].length === 0 ? $skip : [...op, ...rhs];
+  }), BinaryOpRHS$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N)(NewlineBinaryOpAllowed), SingleLineBinaryOpRHS), function($skip, $loc, $0, $1, $2) {
+    let [ws1, op] = $2;
+    return op.token === ">" && !ws1.length ? $skip : $2;
   }), BinaryOpRHS$$ = [BinaryOpRHS$0, BinaryOpRHS$1, BinaryOpRHS$2, BinaryOpRHS$3];
   function BinaryOpRHS(ctx, state2) {
     return (0, import_lib2.$EVENT_C)(ctx, state2, "BinaryOpRHS", BinaryOpRHS$$);
@@ -8627,7 +8722,7 @@ ${js}`
           children: [id, " = ", exp]
         };
     }
-  }), 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) {
+  }), 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, id = $2, typeSuffix = $3, ca = $5;
     return readonly.children[0].$loc = {
       pos: ca.$loc.pos - 1,
@@ -11478,19 +11573,25 @@ ${js}`
   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, ws = $2, post = $4;
+    return attachPostfixStatementAsExpression(expression, [ws, post]);
+  }), 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, post = $2;
-    return post ? attachPostfixStatementAsExpression(expression, post) : expression;
-  });
+    return attachPostfixStatementAsExpression(expression, post);
+  }), PostfixedExpression$2 = Expression, 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, ws = $2, post = $4;
+    return attachPostfixStatementAsExpression(expression, [ws, post]);
+  }), 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, post = $2;
-    return post.length ? post.length === 2 && !Array.isArray(post[1]) ? attachPostfixStatementAsExpression(expression, post) : $0 : $1;
-  });
+    return attachPostfixStatementAsExpression(expression, post);
+  }), PostfixedCommaExpression$2 = CommaExpression, 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];
@@ -12641,6 +12742,16 @@ ${js}`
   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, trailing = $6;
+    return expression ? trailing ? [expression, trailing] : expression : $skip;
+  }), 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;
+    return expression || $skip;
+  }), MaybeNestedPostfixedCommaExpression$$ = [MaybeNestedPostfixedCommaExpression$0, MaybeNestedPostfixedCommaExpression$1];
+  function MaybeNestedPostfixedCommaExpression(ctx, state2) {
+    return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedCommaExpression", MaybeNestedPostfixedCommaExpression$$);
+  }
   var NestedPostfixedExpressionNoTrailing$0 = NestedBulletedArray, NestedPostfixedExpressionNoTrailing$1 = NestedImplicitObjectLiteral, 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) {
     var expression = $2;
     return expression || $skip;
@@ -12980,7 +13091,7 @@ ${js}`
         children: [...$0.slice(0, -2), id]
       }
     ];
-  }), 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) {
+  }), 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 };
   }), ExportDeclaration$3 = (0, import_lib2.$TS)((0, import_lib2.$S)(Export, __, ExportFromClause, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
@@ -13070,7 +13181,7 @@ ${js}`
       splices: bindings.flatMap((b) => b.splices),
       thisAssignments: bindings.flatMap((b) => b.thisAssignments)
     };
-  }), 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) {
+  }), 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, assign = $5;
     return processAssignmentDeclaration(
       { $loc: loc, token: assign.decl },
@@ -13127,7 +13238,7 @@ ${js}`
   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, children: value };
   });

package/dist/civet

@@ -33,6 +33,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var cli_civet_exports = {};
 __export(cli_civet_exports, {
   cli: () => cli,
+  makeOutputFilename: () => makeOutputFilename,
   parseArgs: () => parseArgs,
   repl: () => repl,
   version: () => version
@@ -287,6 +288,22 @@ async function* readFiles(filenames, evalString) {
     }
   }
 }
+function makeOutputFilename(filename, options) {
+  let ref1;
+  const outputPath = (delete (ref1 = options.outputPath ?? import_node_path.default.parse(filename)).base, // use name and ext
+  ref1.ext += // default extension
+  options.js ? ".jsx" : ".tsx", (($) => {
+    if (options.outputDir != null) {
+      $.dir = options.outputDir;
+    }
+    if (options.outputExt != null) {
+      return $.ext = options.outputExt;
+    }
+    ;
+    return;
+  })(ref1), ref1);
+  return import_node_path.default.format(outputPath);
+}
 async function repl(args, options) {
   const vm = await import("node:vm");
   let importModuleDynamically = vm.constants?.USE_MAIN_CONTEXT_DEFAULT_LOADER;
@@ -326,20 +343,24 @@ async function repl(args, options) {
   })()} code.`);
   global.quit = global.exit = () => process.exit(0);
   const nodeRepl = await import("node:repl");
+  let ref2;
+  switch (false) {
+    case !options.ast: {
+      ref2 = "\u{1F332}> ";
+      break;
+    }
+    case !options.compile: {
+      ref2 = "\u{1F408}> ";
+      break;
+    }
+    default: {
+      ref2 = "\u{1F431}> ";
+    }
+  }
+  ;
+  const prompt = ref2;
   const r = nodeRepl.start({
-    prompt: (() => {
-      switch (false) {
-        case !options.ast: {
-          return "\u{1F332}> ";
-        }
-        case !options.compile: {
-          return "\u{1F408}> ";
-        }
-        default: {
-          return "\u{1F431}> ";
-        }
-      }
-    })(),
+    prompt,
     writer: (() => {
       if (options.ast) {
         return (obj) => {
@@ -444,7 +465,32 @@ ${" ".repeat(error.column - 1)}^ ${error.header}`);
       }
     }
   });
-  return r;
+  const bufferedCommandSymbol = Object.getOwnPropertySymbols(r).find((symbol) => {
+    return symbol.description === "bufferedCommand";
+  });
+  const interfaceSetPrompt = Object.getPrototypeOf(Object.getPrototypeOf(r))?.setPrompt;
+  const writeToOutputSymbol = Object.getOwnPropertySymbols(Object.getPrototypeOf(Object.getPrototypeOf(r))).find((symbol) => {
+    return symbol.description === "_writeToOutput";
+  });
+  if (bufferedCommandSymbol && interfaceSetPrompt && writeToOutputSymbol) {
+    const originalWriteToOutput = r[writeToOutputSymbol];
+    Object.defineProperty(r, writeToOutputSymbol, {
+      value: (text) => {
+        return originalWriteToOutput.call(r, text.replace(/(^|\n)\| /g, "$1... "));
+      },
+      configurable: true,
+      writable: true
+    });
+    return r.displayPrompt = (preserveCursor) => {
+      interfaceSetPrompt.call(
+        r,
+        r[bufferedCommandSymbol]?.length ? "... " : prompt
+      );
+      return r.prompt(preserveCursor);
+    };
+  }
+  ;
+  return;
 }
 async function cli(args = process.argv.slice(2)) {
   let { filenames, scriptArgs, options } = await parseArgs(args);
@@ -516,6 +562,28 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
     }
   }
   if (options.typescript) {
+    if (!import_meta.url) {
+      try {
+        require("typescript");
+      } catch {
+        const modulePkg = require("node:module");
+        let ref3;
+        if (ref3 = __dirname.match(/([/\\]@danielx)?[/\\][cC]ivet[/\\]dist[/\\]?$/)) {
+          const match = ref3;
+          if (match[1]) {
+            modulePkg.globalPaths?.push(import_node_path.default.join(__dirname, "..", "..", ".."));
+          } else {
+            modulePkg.globalPaths?.push(import_node_path.default.join(__dirname, "..", ".."));
+          }
+        }
+        try {
+          require("typescript");
+        } catch {
+          console.error("Civet could not find TypeScript, which is required for --typecheck or --emit-declaration. Please install typescript using the same package manager you used to install @danielx/civet. With NPM for example: `npm install typescript` if you are local to a project, or `npm install -g typescript` if you installed Civet globally.");
+          process.exit(1);
+        }
+      }
+    }
     const unpluginOptions = {
       ...options,
       ts: options.js ? "civet" : "preserve",
@@ -549,20 +617,7 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
       errors++;
       continue;
     }
-    let ref1;
-    const outputPath = (delete (ref1 = options.outputPath ?? import_node_path.default.parse(filename)).base, // use name and ext
-    ref1.ext += // default extension
-    options.js ? ".jsx" : ".tsx", (($) => {
-      if (options.outputDir != null) {
-        $.dir = options.outputDir;
-      }
-      if (options.outputExt != null) {
-        return $.ext = options.outputExt;
-      }
-      ;
-      return;
-    })(ref1), ref1);
-    const outputFilename = import_node_path.default.format(outputPath);
+    const outputFilename = makeOutputFilename(filename, options);
     let output;
     try {
       if (unplugin != null) {
@@ -598,17 +653,17 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
         }
       }
     } else if (options.run) {
-      let ref2;
+      let ref4;
       {
         if (typeof output === "string" && /\b(await|import|export)\b/.test(output)) {
           const ast = await (0, import_main.compile)(content, { ...options, ast: true, filename });
-          ref2 = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast) || import_main.lib.hasExportDeclaration(ast);
+          ref4 = import_main.lib.hasAwait(ast) || import_main.lib.hasImportDeclaration(ast) || import_main.lib.hasExportDeclaration(ast);
         } else {
-          ref2 = void 0;
+          ref4 = void 0;
         }
       }
       ;
-      const esm = ref2;
+      const esm = ref4;
       if (esm) {
         if (stdin) {
           filename = `.stdin-${process.pid}.civet`;
@@ -688,9 +743,9 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
         }
       }, !filenames.length);
     } catch (error) {
-      let ref3;
-      if (ref3 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
-        const match = ref3;
+      let ref5;
+      if (ref5 = error.message.match(/Aborting build because of (\d+) TypeScript diagnostic/)) {
+        const match = ref5;
         return process.exitCode = Math.min(255, errors + +match[1]);
       } else {
         process.exitCode = 1;
@@ -704,6 +759,7 @@ You can override this behavior via: --civet rewriteCivetImports=.ext
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   cli,
+  makeOutputFilename,
   parseArgs,
   repl,
   version

package/dist/config.js

@@ -71,6 +71,9 @@ async function findInDir(dirPath) {
     const configName = configNames[i];
     for (let i1 = 0, len1 = configExtensions.length; i1 < len1; i1++) {
       const extension = configExtensions[i1];
+      if (configName === "package" && (extension === ".civet" || extension === ".js")) {
+        continue;
+      }
       for (let ref = ["." + configName + extension, configName + extension], i2 = 0, len2 = ref.length; i2 < len2; i2++) {
         const entry = ref[i2];
         if (entries.has(entry) && await (async () => {

package/dist/config.mjs

@@ -35,6 +35,9 @@ async function findInDir(dirPath) {
     const configName = configNames[i];
     for (let i1 = 0, len1 = configExtensions.length; i1 < len1; i1++) {
       const extension = configExtensions[i1];
+      if (configName === "package" && (extension === ".civet" || extension === ".js")) {
+        continue;
+      }
       for (let ref = ["." + configName + extension, configName + extension], i2 = 0, len2 = ref.length; i2 < len2; i2++) {
         const entry = ref[i2];
         if (entries.has(entry) && await (async () => {