@danielx/civet 0.10.7 → 0.11.1

package/dist/main.mjs

@@ -28,9 +28,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../Hera/dist/machine.js
+// node_modules/@danielx/hera/dist/machine.js
 var require_machine = __commonJS({
-  "../Hera/dist/machine.js"(exports, module) {
+  "node_modules/@danielx/hera/dist/machine.js"(exports, module) {
     "use strict";
     var __defProp2 = Object.defineProperty;
     var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
@@ -604,7 +604,7 @@ function addParentPointers(node, parent) {
     node.parent = parent;
   }
   if (node.children) {
-    for (let ref = node.children, i1 = 0, len1 = ref.length; i1 < len1; i1++) {
+    for (let ref = node.children, i1 = 0, len12 = ref.length; i1 < len12; i1++) {
       const child = ref[i1];
       addParentPointers(child, node);
     }
@@ -1588,7 +1588,7 @@ function findChildIndex(parent, child) {
     }
   }
   function arrayRecurse(array) {
-    for (let i2 = 0, len1 = array.length; i2 < len1; i2++) {
+    for (let i2 = 0, len12 = array.length; i2 < len12; i2++) {
       const c = array[i2];
       if (c === child || Array.isArray(c) && arrayRecurse(c)) {
         return true;
@@ -1795,7 +1795,7 @@ function adjustBindingElements(elements) {
   const names = elements.flatMap(($2) => $2.names || []);
   const { length } = elements;
   let blockPrefix, restIndex = -1, restCount = 0;
-  for (let i2 = 0, len1 = elements.length; i2 < len1; i2++) {
+  for (let i2 = 0, len12 = elements.length; i2 < len12; i2++) {
     const i = i2;
     const { type } = elements[i2];
     if (type === "BindingRestElement") {
@@ -3054,7 +3054,7 @@ function patternBindings(pattern) {
   function recurse(pattern2) {
     switch (pattern2.type) {
       case "ArrayBindingPattern": {
-        for (let ref3 = pattern2.elements, i2 = 0, len1 = ref3.length; i2 < len1; i2++) {
+        for (let ref3 = pattern2.elements, i2 = 0, len12 = ref3.length; i2 < len12; i2++) {
           const element = ref3[i2];
           recurse(element);
         }
@@ -4057,14 +4057,23 @@ function expressionizeIteration(exp) {
   if (generator) {
     iterationDefaultBody(statement);
     assignResults(block, (node) => {
+      let star;
+      if (node && typeof node === "object" && "type" in node && node.type === "SpreadElement" && "expression" in node) {
+        const { expression } = node;
+        star = "*";
+        node = expression;
+      }
       return {
         type: "YieldExpression",
         expression: node,
+        star,
         children: [
           {
             type: "Yield",
-            token: "yield "
+            children: ["yield"]
           },
+          star,
+          " ",
           node
         ]
       };
@@ -4258,6 +4267,17 @@ function braceBlock(block) {
     }
   }
 }
+function unbraceBlock(block) {
+  if (block.bare) {
+    return;
+  }
+  let ref;
+  if (block.children[0] === " {" && (ref = block.children)[ref.length - 1] === "}") {
+    block.children.shift();
+    block.children.pop();
+    block.bare = true;
+  }
+}
 function duplicateBlock(block) {
   const expressions = [...block.expressions];
   let children;
@@ -4356,16 +4376,58 @@ function insertHoistDec(block, node, dec) {
 }
 function processBlocks(statements) {
   insertSemicolon(statements);
-  for (let ref = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len1 = ref.length; i2 < len1; i2++) {
-    const { expressions } = ref[i2];
-    processBlocks(expressions);
+  for (let ref1 = gatherRecursive(statements, ($) => $.type === "BlockStatement"), i2 = 0, len12 = ref1.length; i2 < len12; i2++) {
+    const block = ref1[i2];
+    let m;
+    if (block.unwrapObject && block.expressions.length === 1 && (m = block.expressions[0][1], typeof m === "object" && m != null && "type" in m && m.type === "ParenthesizedExpression" && "implicit" in m && m.implicit === true && "expression" in m && typeof m.expression === "object" && m.expression != null && "type" in m.expression && m.expression.type === "ObjectExpression")) {
+      const object = block.expressions[0][1].expression;
+      if (!(() => {
+        let results = true;
+        for (const prop of object.properties) {
+          if (!(prop.type === "Property" && prop.implicitName)) {
+            results = false;
+            break;
+          }
+        }
+        return results;
+      })()) {
+        continue;
+      }
+      block.expressions[0][1] = block.expressions[0][1].expression;
+      unbraceBlock(block);
+      for (let ref2 = object.properties, i3 = 0, len22 = ref2.length; i3 < len22; i3++) {
+        const i = i3;
+        const prop = ref2[i3];
+        let m1;
+        if (m1 = prop.name, typeof m1 === "object" && m1 != null && "type" in m1 && m1.type === "ComputedPropertyName" && "implicit" in m1 && m1.implicit === true) {
+          replaceNode(prop.name, prop.name.expression, prop);
+        }
+        if (prop.delim?.implicit) {
+          if (needsPrecedingSemicolon(object.properties[i + 1])) {
+            prop.delim.token = ";";
+          } else {
+            replaceNode(prop.delim, void 0, prop);
+            prop.delim = void 0;
+          }
+        }
+        const colon = prop.children.indexOf(": ");
+        if (colon < 0) {
+          continue;
+        }
+        if (!(prop.children[colon - 1] === prop.name)) {
+          continue;
+        }
+        prop.children.splice(colon - 1, 2);
+      }
+    }
+    processBlocks(block.expressions);
   }
 }
 function insertSemicolon(statements) {
   const l = statements.length;
-  for (let i3 = 0, len22 = statements.length; i3 < len22; i3++) {
-    const i = i3;
-    const s = statements[i3];
+  for (let i4 = 0, len3 = statements.length; i4 < len3; i4++) {
+    const i = i4;
+    const s = statements[i4];
     if (i < l - 1) {
       if (needsPrecedingSemicolon(statements[i + 1][1])) {
         const delim = s[2];
@@ -4383,8 +4445,8 @@ function needsPrecedingSemicolon(exp) {
     return false;
   }
   if (Array.isArray(exp)) {
-    for (let i4 = 0, len3 = exp.length; i4 < len3; i4++) {
-      const child = exp[i4];
+    for (let i5 = 0, len4 = exp.length; i5 < len4; i5++) {
+      const child = exp[i5];
       if (!(child != null)) {
         continue;
       }
@@ -4430,8 +4492,8 @@ function needsPrecedingSemicolon(exp) {
 function blockContainingStatement(exp) {
   let child = exp;
   let parent = exp.parent;
-  let m;
-  while (parent != null && (m = parent.type, m === "StatementExpression" || m === "PipelineExpression" || m === "UnwrappedExpression")) {
+  let m2;
+  while (parent != null && (m2 = parent.type, m2 === "StatementExpression" || m2 === "PipelineExpression" || m2 === "UnwrappedExpression")) {
     child = parent;
     parent = parent.parent;
   }
@@ -4484,7 +4546,7 @@ var precedenceMap = /* @__PURE__ */ new Map();
 for (let i1 = 0, len3 = precedenceOrder.length; i1 < len3; i1++) {
   const prec = i1;
   const ops = precedenceOrder[i1];
-  for (let i2 = 0, len1 = ops.length; i2 < len1; i2++) {
+  for (let i2 = 0, len12 = ops.length; i2 < len12; i2++) {
     const op = ops[i2];
     precedenceMap.set(op, prec);
   }
@@ -4506,6 +4568,19 @@ function getPrecedence(op) {
     return precedenceMap.get(op.prec ?? op.token) ?? (op.relational ? precedenceRelational : precedenceCustomDefault);
   }
 }
+function isShortCircuitOp(op) {
+  if (op && typeof op === "object" && "token" in op) {
+    const { token } = op;
+    return isShortCircuitOp(token);
+  } else if (typeof op === "string") {
+    if (op.endsWith("=") && !op.endsWith("==")) {
+      op = op.slice(0, -1);
+    }
+    return op === "||" || op === "&&" || op === "??";
+  } else {
+    return false;
+  }
+}
 function processBinaryOpExpression($0) {
   return processExpandedBinaryOpExpression(expandChainedComparisons($0));
 }
@@ -4815,7 +4890,7 @@ function processPatternMatching(statements) {
     let isPattern = false;
     if (clauses.some(($4) => $4.type === "PatternClause")) {
       isPattern = true;
-      for (let i2 = 0, len1 = clauses.length; i2 < len1; i2++) {
+      for (let i2 = 0, len12 = clauses.length; i2 < len12; i2++) {
         const c = clauses[i2];
         if (!(c.type === "PatternClause" || c.type === "DefaultClause")) {
           errors = true;
@@ -5349,7 +5424,7 @@ function processAssignmentDeclaration(decl, pattern, typeSuffix, ws, assign, e)
   });
 }
 function processDeclarations(statements) {
-  for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len1 = ref1.length; i1 < len1; i1++) {
+  for (let ref1 = gatherRecursiveAll(statements, ($) => $.type === "Declaration"), i1 = 0, len12 = ref1.length; i1 < len12; i1++) {
     const declaration = ref1[i1];
     const { bindings } = declaration;
     if (!(bindings != null)) {
@@ -5436,7 +5511,7 @@ function prependStatementExpressionBlock(initializer, statement) {
   }
   const pre = [];
   const statementExp = exp.statement;
-  const blockStatement = ["", statementExp];
+  const blockStatement = [ws || "", statementExp, ";"];
   let ref;
   if (statementExp.type === "IterationExpression") {
     if (statementExp.async || statementExp.generator) {
@@ -5458,9 +5533,9 @@ function prependStatementExpressionBlock(initializer, statement) {
       });
       const refDec = {
         type: "Declaration",
-        children: ["let ", ref, ";"]
+        children: ["let ", ref]
       };
-      pre.unshift(refDec);
+      pre.unshift(["", refDec, ";"]);
     } else {
       wrapIterationReturningResults(statement2, () => void 0);
       ref = initializer.expression = initializer.children[2] = statement2.resultsRef;
@@ -5476,14 +5551,11 @@ function prependStatementExpressionBlock(initializer, statement) {
     });
     const refDec = {
       type: "Declaration",
-      children: ["let ", ref, ";"]
+      children: ["let ", ref]
     };
-    pre.unshift(refDec);
-    if (ws) {
-      pre.push(ws);
-    }
+    pre.unshift(["", refDec, ";"]);
   }
-  statement.children.unshift(pre, blockStatement, ";");
+  statement.children.unshift(...pre, blockStatement);
   updateParentPointers(blockStatement, statement);
   return ref;
 }
@@ -5804,26 +5876,60 @@ function dynamizeImportDeclaration(decl) {
   };
 }
 function dynamizeImportDeclarationExpression($0) {
-  const [imp, ws1, named, ws2, from] = $0;
-  const object = convertNamedImportsToObject(named);
-  const dot = ".";
-  return processCallMemberExpression({
-    type: "CallExpression",
+  const [imp, ws1, imports, ws2, from] = $0;
+  const awaitExpression = {
+    type: "AwaitExpression",
     children: [
-      { type: "Await", children: "await" },
+      { type: "Await", children: ["await"] },
       " ",
       imp,
       trimFirstSpace(ws2),
-      dynamizeFromClause(from),
-      {
-        type: "PropertyGlob",
-        dot,
-        object,
-        children: [ws1, dot, object],
-        reversed: true
-      }
+      dynamizeFromClause(from)
     ]
-  });
+  };
+  const dot = {
+    type: "AccessStart",
+    children: ["."],
+    optional: false
+  };
+  switch (imports?.type) {
+    case "Identifier": {
+      return processCallMemberExpression({
+        type: "CallExpression",
+        children: [
+          parenthesizeExpression(awaitExpression),
+          {
+            type: "PropertyAccess",
+            dot,
+            name: "default",
+            children: [ws1, dot, "default"]
+          }
+        ]
+      });
+    }
+    case "Star": {
+      return parenthesizeExpression(awaitExpression);
+    }
+    case "Declaration": {
+      const object = convertNamedImportsToObject(imports);
+      return processCallMemberExpression({
+        type: "CallExpression",
+        children: [
+          parenthesizeExpression(awaitExpression),
+          {
+            type: "PropertyGlob",
+            dot,
+            object,
+            children: [ws1, dot, object],
+            reversed: true
+          }
+        ]
+      });
+    }
+    default: {
+      throw new Error("Unsupported dynamic import");
+    }
+  }
 }
 function convertWithClause(withClause, extendsClause) {
   let extendsToken, extendsTarget, ws;
@@ -6123,7 +6229,7 @@ function processPipelineExpressions(statements) {
     const children = [ws];
     const comma = blockContainingStatement(s) ? ";" : ",";
     let usingRef = null;
-    for (let i2 = 0, len1 = body.length; i2 < len1; i2++) {
+    for (let i2 = 0, len12 = body.length; i2 < len12; i2++) {
       const i = i2;
       const step = body[i2];
       const [leadingComment, pipe, trailingComment, expr] = step;
@@ -6915,7 +7021,7 @@ function dedentBlockSubstitutions($0, tab) {
   }
   const stringPart = (() => {
     const results1 = [];
-    for (let i2 = 0, len1 = strWithSubstitutions.length; i2 < len1; i2++) {
+    for (let i2 = 0, len12 = strWithSubstitutions.length; i2 < len12; i2++) {
       const part = strWithSubstitutions[i2];
       results1.push(part.token ?? "s");
     }
@@ -7005,6 +7111,9 @@ function quoteString(str) {
 
 // unplugin-civet:C:\Users\edemaine\Projects\Civet\source\parser\lib.civet.jsx
 var xor = (a, b) => a ? !b && a : b;
+function len1(arr, length) {
+  return arr.length === length;
+}
 function addPostfixStatement(statement, ws, post) {
   const expressions = [
     ...post.blockPrefix || [],
@@ -7382,7 +7491,7 @@ function processCallMemberExpression(node) {
       isComma(args[args.length - 1]).token = "";
     }
     let commaCount = 0;
-    for (let i2 = 0, len1 = args.length; i2 < len1; i2++) {
+    for (let i2 = 0, len22 = args.length; i2 < len22; i2++) {
       const i = i2;
       let arg = args[i2];
       if (isComma(arg)) {
@@ -7412,19 +7521,22 @@ function processCallMemberExpression(node) {
       }
     }
   }
-  for (let i3 = 0, len22 = children.length; i3 < len22; i3++) {
+  for (let i3 = 0, len3 = children.length; i3 < len3; i3++) {
     const i = i3;
     const glob = children[i3];
     if (glob?.type === "PropertyGlob") {
       let prefix = children.slice(0, i);
       const parts = [];
       let ref;
-      if (prefix.length > 1 && glob.object.properties.length > 1) {
+      if (needsRef(prefix) && glob.object.properties.length > 1) {
+        if (Array.isArray(prefix) && len1(prefix, 1) && typeof prefix[0] === "object" && prefix[0] != null && "type" in prefix[0] && prefix[0].type === "ParenthesizedExpression" && "implicit" in prefix[0] && prefix[0].implicit === true) {
+          prefix = [prefix[0].expression];
+        }
         ref = makeRef();
         const { refAssignment } = makeRefAssignment(ref, prefix);
         prefix = [makeLeftHandSideExpression(refAssignment)];
       }
-      prefix = prefix.concat(glob.dot);
+      let prefixDot = [...prefix, glob.dot];
       for (const part of glob.object.properties) {
         if (part.type === "Error") {
           parts.push(part);
@@ -7437,7 +7549,7 @@ function processCallMemberExpression(node) {
           });
           continue;
         }
-        if (part.value && !["CallExpression", "MemberExpression", "Identifier"].includes(part.value.type)) {
+        if (part.value && !["CallExpression", "MemberExpression", "Identifier", "StringLiteral", "ComputedPropertyName"].includes(part.value.type)) {
           parts.push({
             type: "Error",
             message: `Glob pattern must have call or member expression value, found ${JSON.stringify(part.value)}`
@@ -7453,9 +7565,28 @@ function processCallMemberExpression(node) {
           [name, value] = [value, name];
         }
         if (!suppressPrefix) {
-          value = prefix.concat(trimFirstSpace(value));
+          if (value.type === "StringLiteral") {
+            value = [
+              ...prefix,
+              {
+                type: "Index",
+                children: ["[", trimFirstSpace(value), "]"]
+              }
+            ];
+          } else if (value.type === "ComputedPropertyName") {
+            value = [
+              ...prefix,
+              {
+                type: "Index",
+                children: [trimFirstSpace(value)]
+              }
+            ];
+          } else {
+            value = [...prefixDot, trimFirstSpace(value)];
+          }
           if (ref != null) {
-            prefix = [ref].concat(glob.dot);
+            prefix = [ref];
+            prefixDot = [...prefix, glob.dot];
           }
         }
         if (wValue) value.unshift(wValue);
@@ -7858,7 +7989,7 @@ function processBindingPatternLHS(lhs, tail) {
   );
 }
 function processAssignments(statements) {
-  for (let ref8 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len3 = ref8.length; i5 < len3; i5++) {
+  for (let ref8 = gatherRecursiveAll(statements, ($4) => $4.type === "AssignmentExpression" || $4.type === "UpdateExpression"), i5 = 0, len4 = ref8.length; i5 < len4; i5++) {
     let extractAssignment = function(lhs) {
       let expr = lhs;
       while (expr.type === "ParenthesizedExpression") {
@@ -7887,7 +8018,7 @@ function processAssignments(statements) {
         if (!exp.lhs) {
           continue;
         }
-        for (let ref10 = exp.lhs, i6 = 0, len4 = ref10.length; i6 < len4; i6++) {
+        for (let ref10 = exp.lhs, i6 = 0, len5 = ref10.length; i6 < len5; i6++) {
           const lhsPart = ref10[i6];
           let ref11;
           if (ref11 = extractAssignment(lhsPart[1])) {
@@ -7932,7 +8063,7 @@ function processAssignments(statements) {
       }
     }
   }
-  for (let ref12 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len5 = ref12.length; i7 < len5; i7++) {
+  for (let ref12 = gatherRecursiveAll(statements, ($6) => $6.type === "AssignmentExpression"), i7 = 0, len6 = ref12.length; i7 < len6; i7++) {
     const exp = ref12[i7];
     if (!(exp.names === null)) {
       continue;
@@ -7940,14 +8071,15 @@ function processAssignments(statements) {
     let { lhs: $1, expression: $2 } = exp, tail = [], len3 = $1.length;
     let block;
     let ref13;
-    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special) {
+    let ref14;
+    if (blockContainingStatement(exp) && !(ref13 = $1[$1.length - 1])?.[ref13.length - 1]?.special && !isShortCircuitOp((ref14 = $1[$1.length - 1])?.[ref14.length - 1])) {
       block = makeBlockFragment();
-      let ref14;
-      if (ref14 = prependStatementExpressionBlock(
+      let ref15;
+      if (ref15 = prependStatementExpressionBlock(
         { type: "Initializer", expression: $2, children: [void 0, void 0, $2] },
         block
       )) {
-        const ref = ref14;
+        const ref = ref15;
         exp.children = exp.children.map(($7) => $7 === $2 ? ref : $7);
         $2 = ref;
       } else {
@@ -8003,7 +8135,7 @@ function processAssignments(statements) {
             c[1] = start;
             c[2] = ", ";
             if (end) {
-              c[3] = [end, " - ", start];
+              c[3] = [makeLeftHandSideExpression(end), " - ", makeLeftHandSideExpression(start)];
             } else {
               c[3] = ["1/0"];
             }
@@ -8128,9 +8260,9 @@ function unchainOptionalMemberExpression(exp, ref, innerExp) {
     }
     j++;
   }
-  let ref15;
-  if (ref15 = conditions.length) {
-    const l = ref15;
+  let ref16;
+  if (ref16 = conditions.length) {
+    const l = ref16;
     const cs = flatJoin(conditions, " && ");
     return {
       ...exp,
@@ -8166,8 +8298,8 @@ function attachPostfixStatementAsExpression(exp, post) {
 }
 function processTypes(node) {
   const results1 = [];
-  for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len6 = ref16.length; i8 < len6; i8++) {
-    const unary = ref16[i8];
+  for (let ref17 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len7 = ref17.length; i8 < len7; i8++) {
+    const unary = ref17[i8];
     let suffixIndex = unary.suffix.length - 1;
     const results2 = [];
     while (suffixIndex >= 0) {
@@ -8246,10 +8378,10 @@ function processTypes(node) {
         const outer = unary.suffix.splice(suffixIndex + 1, Infinity);
         const space = getTrimmingSpace(unary);
         inplaceInsertTrimmingSpace(unary, "");
-        let ref17;
-        if (unary.suffix.length) ref17 = unary;
-        else ref17 = unary.t;
-        const t = ref17;
+        let ref18;
+        if (unary.suffix.length) ref18 = unary;
+        else ref18 = unary.t;
+        const t = ref18;
         const arg = makeNode({
           type: "TypeArgument",
           ts: true,
@@ -8294,18 +8426,18 @@ function processTypes(node) {
   return results1;
 }
 function processStatementExpressions(statements) {
-  for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len7 = ref18.length; i9 < len7; i9++) {
-    const exp = ref18[i9];
+  for (let ref19 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len8 = ref19.length; i9 < len8; i9++) {
+    const exp = ref19[i9];
     const { maybe, statement } = exp;
     if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
       replaceNode(exp, statement);
       continue;
     }
-    let ref19;
+    let ref20;
     switch (statement.type) {
       case "IfStatement": {
-        if (ref19 = expressionizeIfStatement(statement)) {
-          const expression = ref19;
+        if (ref20 = expressionizeIfStatement(statement)) {
+          const expression = ref20;
           replaceNode(statement, expression, exp);
         } else {
           replaceNode(statement, wrapIIFE([["", statement]]), exp);
@@ -8364,13 +8496,13 @@ function processNegativeIndexAccess(statements) {
   });
 }
 function processFinallyClauses(statements) {
-  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref20.length; i10 < len8; i10++) {
-    let f = ref20[i10];
-    let ref21;
-    if (!((ref21 = blockContainingStatement(f)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21)) {
+  for (let ref21 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len9 = ref21.length; i10 < len9; i10++) {
+    let f = ref21[i10];
+    let ref22;
+    if (!((ref22 = blockContainingStatement(f)) && typeof ref22 === "object" && "block" in ref22 && "index" in ref22)) {
       throw new Error("finally clause must be inside try statement or block");
     }
-    const { block, index } = ref21;
+    const { block, index } = ref22;
     const indent = block.expressions[index][0];
     const expressions = block.expressions.slice(index + 1);
     const t = makeNode({
@@ -8442,8 +8574,8 @@ function processBreaksContinues(statements) {
   }
 }
 function processCoffeeClasses(statements) {
-  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref22.length; i11 < len9; i11++) {
-    const ce = ref22[i11];
+  for (let ref23 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len10 = ref23.length; i11 < len10; i11++) {
+    const ce = ref23[i11];
     const { expressions } = ce.body;
     const indent = expressions[0]?.[0] ?? "\n";
     const autoBinds = expressions.filter(($14) => $14[1]?.autoBind);
@@ -8487,7 +8619,7 @@ function processCoffeeClasses(statements) {
         0,
         ...(() => {
           const results3 = [];
-          for (let i12 = 0, len10 = autoBinds.length; i12 < len10; i12++) {
+          for (let i12 = 0, len11 = autoBinds.length; i12 < len11; i12++) {
             const [, a] = autoBinds[i12];
             results3.push([indent, ["this.", a.name, " = this.", a.name, ".bind(this)"], ";"]);
           }
@@ -8603,8 +8735,8 @@ async function processProgramAsync(root) {
 function processRepl(root, rootIIFE) {
   const topBlock = gatherRecursive(rootIIFE, ($21) => $21.type === "BlockStatement")[0];
   let i = 0;
-  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($22) => $22.type === "Declaration"), i14 = 0, len11 = ref23.length; i14 < len11; i14++) {
-    const decl = ref23[i14];
+  for (let ref24 = gatherRecursiveWithinFunction(topBlock, ($22) => $22.type === "Declaration"), i14 = 0, len12 = ref24.length; i14 < len12; i14++) {
+    const decl = ref24[i14];
     if (!decl.names?.length) {
       continue;
     }
@@ -8617,8 +8749,8 @@ function processRepl(root, rootIIFE) {
       root.expressions.splice(i++, 0, ["", `var ${decl.names.join(",")}`, ";"]);
     }
   }
-  for (let ref24 = gatherRecursive(topBlock, ($23) => $23.type === "FunctionExpression"), i15 = 0, len12 = ref24.length; i15 < len12; i15++) {
-    const func = ref24[i15];
+  for (let ref25 = gatherRecursive(topBlock, ($23) => $23.type === "FunctionExpression"), i15 = 0, len13 = ref25.length; i15 < len13; i15++) {
+    const func = ref25[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
         replaceNode(func, void 0);
@@ -8630,8 +8762,8 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($24) => $24.type === "ClassExpression"), i16 = 0, len13 = ref25.length; i16 < len13; i16++) {
-    const classExp = ref25[i16];
+  for (let ref26 = gatherRecursiveWithinFunction(topBlock, ($24) => $24.type === "ClassExpression"), i16 = 0, len14 = ref26.length; i16 < len14; i16++) {
+    const classExp = ref26[i16];
     let m8;
     if (classExp.name && classExp.parent === topBlock || (m8 = classExp.parent, typeof m8 === "object" && m8 != null && "type" in m8 && m8.type === "ReturnStatement" && "parent" in m8 && m8.parent === topBlock)) {
       classExp.children.unshift(classExp.name, "=");
@@ -8642,8 +8774,8 @@ function processRepl(root, rootIIFE) {
 function processPlaceholders(statements) {
   const placeholderMap = /* @__PURE__ */ new Map();
   const liftedIfs = /* @__PURE__ */ new Set();
-  for (let ref26 = gatherRecursiveAll(statements, ($25) => $25.type === "Placeholder"), i17 = 0, len14 = ref26.length; i17 < len14; i17++) {
-    const exp = ref26[i17];
+  for (let ref27 = gatherRecursiveAll(statements, ($25) => $25.type === "Placeholder"), i17 = 0, len15 = ref27.length; i17 < len15; i17++) {
+    const exp = ref27[i17];
     let ancestor;
     if (exp.subtype === ".") {
       ({ ancestor } = findAncestor(
@@ -8752,11 +8884,11 @@ function processPlaceholders(statements) {
   for (const [ancestor, placeholders] of placeholderMap) {
     let ref = makeRef("$");
     let typeSuffix;
-    for (let i18 = 0, len15 = placeholders.length; i18 < len15; i18++) {
+    for (let i18 = 0, len16 = placeholders.length; i18 < len16; i18++) {
       const placeholder = placeholders[i18];
       typeSuffix ??= placeholder.typeSuffix;
-      let ref27;
-      (ref27 = placeholder.children)[ref27.length - 1] = ref;
+      let ref28;
+      (ref28 = placeholder.children)[ref28.length - 1] = ref;
     }
     const { parent } = ancestor;
     const body = maybeUnwrap(ancestor);
@@ -8777,16 +8909,16 @@ function processPlaceholders(statements) {
       }
       case "PipelineExpression": {
         const i = findChildIndex(parent, ancestor);
-        let ref28;
+        let ref29;
         if (i === 1) {
-          ref28 = ancestor === parent.children[i];
+          ref29 = ancestor === parent.children[i];
         } else if (i === 2) {
-          ref28 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
+          ref29 = ancestor === parent.children[i][findChildIndex(parent.children[i], ancestor)][3];
         } else {
-          ref28 = void 0;
+          ref29 = void 0;
         }
         ;
-        outer = ref28;
+        outer = ref29;
         break;
       }
       case "AssignmentExpression":
@@ -8804,9 +8936,9 @@ function processPlaceholders(statements) {
     if (typeof parent === "object" && parent != null && "type" in parent && parent.type === "BlockStatement" && "parent" in parent && typeof parent.parent === "object" && parent.parent != null && "type" in parent.parent && parent.parent.type === "ArrowFunction" && "ampersandBlock" in parent.parent && parent.parent.ampersandBlock === true && "body" in parent.parent && parent.parent.body === body) {
       parent.parent.body = fnExp;
     }
-    let ref29;
-    if (ref29 = getTrimmingSpace(body)) {
-      const ws = ref29;
+    let ref30;
+    if (ref30 = getTrimmingSpace(body)) {
+      const ws = ref30;
       inplaceInsertTrimmingSpace(body, "");
       inplacePrepend(ws, fnExp);
     }
@@ -8850,8 +8982,8 @@ function reorderBindingRestProperty(props) {
       }
     ];
   }
-  let ref30;
-  if (Array.isArray(rest.delim) && (ref30 = rest.delim)[ref30.length - 1]?.token === ",") {
+  let ref31;
+  if (Array.isArray(rest.delim) && (ref31 = rest.delim)[ref31.length - 1]?.token === ",") {
     rest.delim = rest.delim.slice(0, -1);
     rest.children = [...rest.children.slice(0, -1), rest.delim];
   }
@@ -8866,10 +8998,12 @@ function reorderBindingRestProperty(props) {
 }
 function typeOfJSX(node, config2) {
   switch (node.type) {
-    case "JSXElement":
+    case "JSXElement": {
       return typeOfJSXElement(node, config2);
-    case "JSXFragment":
+    }
+    case "JSXFragment": {
       return typeOfJSXFragment(node, config2);
+    }
   }
 }
 function typeOfJSXElement(node, config2) {
@@ -8877,7 +9011,7 @@ function typeOfJSXElement(node, config2) {
     if (config2.server && !config2.client) {
       return ["string"];
     }
-    let { tag } = node;
+    const { tag } = node;
     const clientType = tag[0] === tag[0].toLowerCase() ? [getHelperRef("IntrinsicElements"), '<"', tag, '">'] : ["ReturnType<typeof ", tag, ">"];
     if (config2.server) {
       return ["string", " | ", clientType];
@@ -8892,33 +9026,40 @@ function typeOfJSXFragment(node, config2) {
   if (config2.solid) {
     let type = [];
     let lastType;
-    for (let child of node.jsxChildren) {
+    for (const child of node.jsxChildren) {
       switch (child.type) {
-        case "JSXText":
-          if (lastType !== "JSXText") {
+        case "JSXText": {
+          if (!(lastType === "JSXText")) {
             type.push("string");
           }
+          ;
           break;
-        case "JSXElement":
+        }
+        case "JSXElement": {
           type.push(typeOfJSXElement(child, config2));
           break;
-        case "JSXFragment":
+        }
+        case "JSXFragment": {
           type.push(...typeOfJSXFragment(child, config2));
           break;
-        case "JSXChildExpression":
+        }
+        case "JSXChildExpression": {
           if (child.expression) {
             type.push(["typeof ", child.expression]);
           }
+          ;
           break;
-        default:
+        }
+        default: {
           throw new Error(`unknown child in JSXFragment: ${JSON.stringify(child)}`);
+        }
       }
       lastType = child.type;
     }
     if (type.length === 1) {
       return type[0];
     } else {
-      type = type.flatMap((t) => [t, ", "]);
+      type = type.flatMap(($26) => [$26, ", "]);
       type.pop();
       return ["[", type, "]"];
     }
@@ -9143,6 +9284,8 @@ var grammar = {
   NonSingleBracedBlock,
   DeclarationOrStatement,
   SingleLineStatements,
+  ObjectSingleLineStatements,
+  BracedObjectSingleLineStatements,
   PostfixedSingleLineStatements,
   PostfixedSingleLineNoCommaStatements,
   NestedBlockStatements,
@@ -9323,6 +9466,10 @@ var grammar = {
   ForbidNewlineBinaryOp,
   RestoreNewlineBinaryOp,
   NewlineBinaryOpAllowed,
+  AllowImplicitFragment,
+  ForbidImplicitFragment,
+  RestoreImplicitFragment,
+  ImplicitFragmentAllowed,
   AllowPipeline,
   ForbidPipeline,
   RestorePipeline,
@@ -9348,11 +9495,15 @@ var grammar = {
   NameSpaceImport,
   NamedImports,
   OperatorNamedImports,
+  DynamicNamedImports,
+  DynamicImportContents,
   FromClause,
   ImportAssertion,
   TypeAndImportSpecifier,
   ImportSpecifier,
   OperatorImportSpecifier,
+  DynamicImportSpecifier,
+  DynamicModuleExportName,
   ImportAsToken,
   ModuleExportName,
   ModuleSpecifier,
@@ -10630,7 +10781,11 @@ function SingleLineBinaryOpRHS(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "SingleLineBinaryOpRHS", SingleLineBinaryOpRHS$0);
 }
 var RHS$0 = ExpressionizedStatementWithTrailingCallExpressions;
-var RHS$1 = UnaryExpression;
+var RHS$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(UnaryExpression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var exp = $2;
+  if (!exp) return $skip;
+  return exp;
+});
 var RHS$$ = [RHS$0, RHS$1];
 function RHS(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "RHS", RHS$$);
@@ -10964,8 +11119,9 @@ var FatArrowBody$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$N
     implicitlyReturned: true
   };
 });
-var FatArrowBody$1 = NoCommaBracedOrEmptyBlock;
-var FatArrowBody$$ = [FatArrowBody$0, FatArrowBody$1];
+var FatArrowBody$1 = BracedObjectSingleLineStatements;
+var FatArrowBody$2 = NoCommaBracedOrEmptyBlock;
+var FatArrowBody$$ = [FatArrowBody$0, FatArrowBody$1, FatArrowBody$2];
 function FatArrowBody(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "FatArrowBody", FatArrowBody$$);
 }
@@ -11676,10 +11832,10 @@ var CallExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Super, Arguments
     children: [$1, ...$2, ...rest.flat()]
   });
 });
-var CallExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Import, _, NamedImports, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+var CallExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Import, _, DynamicImportContents, __, FromClause), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   return dynamizeImportDeclarationExpression($0);
 });
-var CallExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(FromClause, __, Import, _, NamedImports), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+var CallExpression$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(FromClause, __, Import, _, DynamicImportContents), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
   var from = $1;
   var fws = $2;
   var i = $3;
@@ -13120,7 +13276,7 @@ var OperatorAssociativity$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
 function OperatorAssociativity(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorAssociativity", OperatorAssociativity$0);
 }
-var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), Arrow, NoCommaBracedOrEmptyBlock), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
+var ThinArrowFunction$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(Async, _)), ArrowParameters, (0, import_lib2.$E)(ReturnTypeSuffix), (0, import_lib2.$E)(_), Arrow, (0, import_lib2.$C)(BracedObjectSingleLineStatements, NoCommaBracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6) {
   var async = $1;
   var parameters = $2;
   var returnType = $3;
@@ -13274,8 +13430,9 @@ var ThenBlock$0 = (0, import_lib2.$T)((0, import_lib2.$S)(NoBlock, EmptyBlock),
   return value[1];
 });
 var ThenBlock$1 = ImplicitNestedBlock;
-var ThenBlock$2 = SingleLineStatements;
-var ThenBlock$$ = [ThenBlock$0, ThenBlock$1, ThenBlock$2];
+var ThenBlock$2 = ObjectSingleLineStatements;
+var ThenBlock$3 = SingleLineStatements;
+var ThenBlock$$ = [ThenBlock$0, ThenBlock$1, ThenBlock$2, ThenBlock$3];
 function ThenBlock(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "ThenBlock", ThenBlock$$);
 }
@@ -13334,11 +13491,12 @@ var BlockOrEmptyStatement$$ = [BlockOrEmptyStatement$0, BlockOrEmptyStatement$1]
 function BlockOrEmptyStatement(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "BlockOrEmptyStatement", BlockOrEmptyStatement$$);
 }
-var BlockOrEmpty$0 = Block;
-var BlockOrEmpty$1 = (0, import_lib2.$T)((0, import_lib2.$S)(NoBlock, EmptyBlock), function(value) {
+var BlockOrEmpty$0 = ObjectSingleLineStatements;
+var BlockOrEmpty$1 = Block;
+var BlockOrEmpty$2 = (0, import_lib2.$T)((0, import_lib2.$S)(NoBlock, EmptyBlock), function(value) {
   return value[1];
 });
-var BlockOrEmpty$$ = [BlockOrEmpty$0, BlockOrEmpty$1];
+var BlockOrEmpty$$ = [BlockOrEmpty$0, BlockOrEmpty$1, BlockOrEmpty$2];
 function BlockOrEmpty(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "BlockOrEmpty", BlockOrEmpty$$);
 }
@@ -13474,6 +13632,26 @@ var SingleLineStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidNewl
 function SingleLineStatements(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "SingleLineStatements", SingleLineStatements$0);
 }
+var ObjectSingleLineStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Y)((0, import_lib2.$S)((0, import_lib2.$E)(_), BracedObjectLiteral)), SingleLineStatements), function($skip, $loc, $0, $1, $2) {
+  var block = $2;
+  if (block.bare && block.expressions.length === 1) {
+    const expression = block.expressions[0][1];
+    if (expression.type === "ParenthesizedExpression" && expression.implicit && expression.expression.type === "ObjectExpression") {
+      block = { ...block, unwrapObject: true };
+    }
+  }
+  return block;
+});
+function ObjectSingleLineStatements(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ObjectSingleLineStatements", ObjectSingleLineStatements$0);
+}
+var BracedObjectSingleLineStatements$0 = (0, import_lib2.$TV)(ObjectSingleLineStatements, function($skip, $loc, $0, $1) {
+  var block = $0;
+  return bracedBlock(block);
+});
+function BracedObjectSingleLineStatements(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "BracedObjectSingleLineStatements", BracedObjectSingleLineStatements$0);
+}
 var PostfixedSingleLineStatements$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$Q)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$N)(EOS)), StatementListItem, SemicolonDelimiter)), (0, import_lib2.$E)((0, import_lib2.$S)((0, import_lib2.$S)((0, import_lib2.$E)(_), (0, import_lib2.$N)(EOS)), StatementListItem, (0, import_lib2.$E)(SemicolonDelimiter)))), function($skip, $loc, $0, $1, $2) {
   var stmts = $1;
   var last = $2;
@@ -14324,7 +14502,8 @@ var PropertyDefinition$2 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     children: [ws, id],
     name: id,
     names: id.names,
-    value: id
+    value: id,
+    implicitName: true
   };
 });
 var PropertyDefinition$3 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)(_), MethodDefinition), function($skip, $loc, $0, $1, $2) {
@@ -14383,7 +14562,8 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     if (refAssignment) {
       name = {
         type: "ComputedPropertyName",
-        children: [last.children[0], "(", refAssignment, ",", ref, ")", ...last.children.slice(-2)]
+        children: [last.children[0], "(", refAssignment, ",", ref, ")", ...last.children.slice(-2)],
+        implicit: true
       };
       value = {
         ...value,
@@ -14398,7 +14578,8 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     } else {
       name = {
         type: "ComputedPropertyName",
-        children: last.children
+        children: last.children,
+        implicit: true
       };
     }
   } else {
@@ -14411,7 +14592,8 @@ var PropertyDefinition$5 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_l
     children: [ws, name, ": ", processUnaryExpression(pre, value, post)],
     name,
     names: [],
-    value
+    value,
+    implicitName: true
   };
 });
 var PropertyDefinition$$ = [PropertyDefinition$0, PropertyDefinition$1, PropertyDefinition$2, PropertyDefinition$3, PropertyDefinition$4, PropertyDefinition$5];
@@ -14614,6 +14796,7 @@ function MethodDefinition(ctx, state2) {
 var MethodModifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(GetOrSet, (0, import_lib2.$E)(_), (0, import_lib2.$Y)(ClassElementName)), function($skip, $loc, $0, $1, $2, $3) {
   var kind = $1;
   var ws = $2;
+  if (!ws) ws = " ";
   return {
     // no async or generator, because getters and setters can't be
     modifier: {
@@ -15331,7 +15514,7 @@ function ShouldExpressionize(ctx, state2) {
 var NoCommaStatement$0 = KeywordStatement;
 var NoCommaStatement$1 = VariableStatement;
 var NoCommaStatement$2 = IfStatement;
-var NoCommaStatement$3 = IterationStatement;
+var NoCommaStatement$3 = IterationActualStatement;
 var NoCommaStatement$4 = SwitchStatement;
 var NoCommaStatement$5 = TryStatement;
 var NoCommaStatement$6 = EmptyStatement;
@@ -16363,8 +16546,8 @@ var SingleLineExpressionWithIndentedApplicationForbidden$0 = (0, import_lib2.$TS
 function SingleLineExpressionWithIndentedApplicationForbidden(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "SingleLineExpressionWithIndentedApplicationForbidden", SingleLineExpressionWithIndentedApplicationForbidden$0);
 }
-var ExpressionWithObjectApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidBracedApplication, ForbidIndentedApplication, (0, import_lib2.$E)(Expression), RestoreBracedApplication, RestoreIndentedApplication), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
-  var exp = $3;
+var ExpressionWithObjectApplicationForbidden$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidBracedApplication, ForbidIndentedApplication, ForbidImplicitFragment, (0, import_lib2.$E)(Expression), RestoreBracedApplication, RestoreIndentedApplication, RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3, $4, $5, $6, $7) {
+  var exp = $4;
   if (exp) return exp;
   return $skip;
 });
@@ -16541,6 +16724,33 @@ var NewlineBinaryOpAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0
 function NewlineBinaryOpAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "NewlineBinaryOpAllowed", NewlineBinaryOpAllowed$0);
 }
+var AllowImplicitFragment$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'AllowImplicitFragment ""'), function($skip, $loc, $0, $1) {
+  state.forbidImplicitFragment.push(false);
+});
+function AllowImplicitFragment(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "AllowImplicitFragment", AllowImplicitFragment$0);
+}
+var ForbidImplicitFragment$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'ForbidImplicitFragment ""'), function($skip, $loc, $0, $1) {
+  state.forbidImplicitFragment.push(true);
+});
+function ForbidImplicitFragment(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ForbidImplicitFragment", ForbidImplicitFragment$0);
+}
+var RestoreImplicitFragment$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'RestoreImplicitFragment ""'), function($skip, $loc, $0, $1) {
+  state.forbidImplicitFragment.pop();
+});
+function RestoreImplicitFragment(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "RestoreImplicitFragment", RestoreImplicitFragment$0);
+}
+var ImplicitFragmentAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'ImplicitFragmentAllowed ""'), function($skip, $loc, $0, $1) {
+  if (config.verbose) {
+    console.log("forbidImplicitFragment:", state.forbidImplicitFragment);
+  }
+  if (state.implicitFragmentForbidden) return $skip;
+});
+function ImplicitFragmentAllowed(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "ImplicitFragmentAllowed", ImplicitFragmentAllowed$0);
+}
 var AllowPipeline$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'AllowPipeline ""'), function($skip, $loc, $0, $1) {
   state.forbidPipeline.push(false);
 });
@@ -16568,11 +16778,11 @@ var PipelineAllowed$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Pipe
 function PipelineAllowed(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PipelineAllowed", PipelineAllowed$0);
 }
-var AllowAll$0 = (0, import_lib2.$S)(AllowTrailingMemberProperty, AllowBracedApplication, AllowIndentedApplication, AllowClassImplicitCall, AllowNestedBinaryOp, AllowNewlineBinaryOp, AllowPipeline);
+var AllowAll$0 = (0, import_lib2.$S)(AllowTrailingMemberProperty, AllowBracedApplication, AllowIndentedApplication, AllowClassImplicitCall, AllowNestedBinaryOp, AllowNewlineBinaryOp, AllowImplicitFragment, AllowPipeline);
 function AllowAll(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "AllowAll", AllowAll$0);
 }
-var RestoreAll$0 = (0, import_lib2.$S)(RestoreTrailingMemberProperty, RestoreBracedApplication, RestoreIndentedApplication, RestoreClassImplicitCall, RestoreNestedBinaryOp, RestoreNewlineBinaryOp, RestorePipeline);
+var RestoreAll$0 = (0, import_lib2.$S)(RestoreTrailingMemberProperty, RestoreBracedApplication, RestoreIndentedApplication, RestoreClassImplicitCall, RestoreNestedBinaryOp, RestoreNewlineBinaryOp, RestoreImplicitFragment, RestorePipeline);
 function RestoreAll(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "RestoreAll", RestoreAll$0);
 }
@@ -16675,7 +16885,11 @@ var MaybeNestedNonPipelineExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S
   if (!trailing) return expression;
   return [expression, trailing];
 });
-var MaybeNestedNonPipelineExpression$1 = NonPipelineExpression;
+var MaybeNestedNonPipelineExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(NonPipelineExpression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var expression = $2;
+  if (!expression) return $skip;
+  return expression;
+});
 var MaybeNestedNonPipelineExpression$$ = [MaybeNestedNonPipelineExpression$0, MaybeNestedNonPipelineExpression$1];
 function MaybeNestedNonPipelineExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedNonPipelineExpression", MaybeNestedNonPipelineExpression$$);
@@ -16687,7 +16901,11 @@ var MaybeNestedPostfixedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(
   if (!trailing) return expression;
   return [expression, trailing];
 });
-var MaybeNestedPostfixedExpression$1 = PostfixedExpression;
+var MaybeNestedPostfixedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(PostfixedExpression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var expression = $2;
+  if (!expression) return $skip;
+  return expression;
+});
 var MaybeNestedPostfixedExpression$$ = [MaybeNestedPostfixedExpression$0, MaybeNestedPostfixedExpression$1];
 function MaybeNestedPostfixedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedPostfixedExpression", MaybeNestedPostfixedExpression$$);
@@ -16710,7 +16928,11 @@ var MaybeNestedExpression$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, impor
   if (!trailing) return expression;
   return [expression, trailing];
 });
-var MaybeNestedExpression$1 = Expression;
+var MaybeNestedExpression$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(ForbidImplicitFragment, (0, import_lib2.$E)(Expression), RestoreImplicitFragment), function($skip, $loc, $0, $1, $2, $3) {
+  var expression = $2;
+  if (!expression) return $skip;
+  return expression;
+});
 var MaybeNestedExpression$$ = [MaybeNestedExpression$0, MaybeNestedExpression$1];
 function MaybeNestedExpression(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "MaybeNestedExpression", MaybeNestedExpression$$);
@@ -16905,6 +17127,24 @@ var OperatorNamedImports$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBrace,
 function OperatorNamedImports(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "OperatorNamedImports", OperatorNamedImports$0);
 }
+var DynamicNamedImports$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(OpenBrace, (0, import_lib2.$Q)(DynamicImportSpecifier), (0, import_lib2.$E)((0, import_lib2.$S)(__, Comma)), __, CloseBrace), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  var specifiers = $2;
+  return {
+    type: "Declaration",
+    children: $0,
+    specifiers
+  };
+});
+function DynamicNamedImports(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "DynamicNamedImports", DynamicNamedImports$0);
+}
+var DynamicImportContents$0 = DynamicNamedImports;
+var DynamicImportContents$1 = IdentifierName;
+var DynamicImportContents$2 = Star;
+var DynamicImportContents$$ = [DynamicImportContents$0, DynamicImportContents$1, DynamicImportContents$2];
+function DynamicImportContents(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "DynamicImportContents", DynamicImportContents$$);
+}
 var FromClause$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(From, __, ModuleSpecifier), function($skip, $loc, $0, $1, $2, $3) {
   var module = $3;
   if (!Array.isArray(module)) return $0;
@@ -16926,11 +17166,11 @@ var ImportAssertion$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2
 function ImportAssertion(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "ImportAssertion", ImportAssertion$0);
 }
-var TypeAndImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$E)((0, import_lib2.$S)(__, TypeKeyword)), ImportSpecifier), function($skip, $loc, $0, $1, $2) {
-  if (!$1) return $2;
-  return { ts: true, children: $0, binding: $2.binding };
+var TypeAndImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, TypeKeyword, ImportSpecifier), function($skip, $loc, $0, $1, $2, $3) {
+  return { ts: true, children: $0, binding: $3.binding };
 });
-var TypeAndImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Operator, OperatorImportSpecifier), function($skip, $loc, $0, $1, $2, $3) {
+var TypeAndImportSpecifier$1 = ImportSpecifier;
+var TypeAndImportSpecifier$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Operator, OperatorImportSpecifier), function($skip, $loc, $0, $1, $2, $3) {
   var ws = $1;
   var spec = $3;
   if (spec.binding.type !== "Identifier") {
@@ -16946,7 +17186,7 @@ var TypeAndImportSpecifier$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, Oper
     ]
   };
 });
-var TypeAndImportSpecifier$$ = [TypeAndImportSpecifier$0, TypeAndImportSpecifier$1];
+var TypeAndImportSpecifier$$ = [TypeAndImportSpecifier$0, TypeAndImportSpecifier$1, TypeAndImportSpecifier$2];
 function TypeAndImportSpecifier(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "TypeAndImportSpecifier", TypeAndImportSpecifier$$);
 }
@@ -16993,6 +17233,27 @@ var OperatorImportSpecifier$$ = [OperatorImportSpecifier$0, OperatorImportSpecif
 function OperatorImportSpecifier(ctx, state2) {
   return (0, import_lib2.$EVENT_C)(ctx, state2, "OperatorImportSpecifier", OperatorImportSpecifier$$);
 }
+var DynamicImportSpecifier$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(__, (0, import_lib2.$E)((0, import_lib2.$S)(TypeKeyword, __, (0, import_lib2.$Y)(DynamicModuleExportName))), DynamicModuleExportName, (0, import_lib2.$E)((0, import_lib2.$S)(ImportAsToken, __, DynamicModuleExportName)), ObjectPropertyDelimiter), function($skip, $loc, $0, $1, $2, $3, $4, $5) {
+  var ts2 = $2;
+  var source = $3;
+  var binding = $4;
+  return {
+    source,
+    binding: binding?.[2],
+    ts: !!ts2,
+    // true causes an error later
+    children: $0
+  };
+});
+function DynamicImportSpecifier(ctx, state2) {
+  return (0, import_lib2.$EVENT)(ctx, state2, "DynamicImportSpecifier", DynamicImportSpecifier$0);
+}
+var DynamicModuleExportName$0 = ModuleExportName;
+var DynamicModuleExportName$1 = ComputedPropertyName;
+var DynamicModuleExportName$$ = [DynamicModuleExportName$0, DynamicModuleExportName$1];
+function DynamicModuleExportName(ctx, state2) {
+  return (0, import_lib2.$EVENT_C)(ctx, state2, "DynamicModuleExportName", DynamicModuleExportName$$);
+}
 var ImportAsToken$0 = (0, import_lib2.$S)(__, As);
 var ImportAsToken$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(Loc, __, Colon, (0, import_lib2.$E)((0, import_lib2.$EXPECT)($L17, 'ImportAsToken " "'))), function($skip, $loc, $0, $1, $2, $3, $4) {
   var l = $1;
@@ -18284,7 +18545,7 @@ function SingleQuote(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "SingleQuote", SingleQuote$0);
 }
 var Star$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L75, 'Star "*"'), function($skip, $loc, $0, $1) {
-  return { $loc, token: $1 };
+  return { $loc, token: $1, type: "Star" };
 });
 function Star(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "Star", Star$0);
@@ -18437,18 +18698,22 @@ var Yield$0 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_lib2.$EXPECT)(
 function Yield(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "Yield", Yield$0);
 }
-var JSXImplicitFragment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(JSXTag, (0, import_lib2.$Q)((0, import_lib2.$S)(Nested, (0, import_lib2.$C)(JSXTag, JSXAngleChild)))), function($skip, $loc, $0, $1, $2) {
-  const jsx = $2.length === 0 ? $1 : {
+var JSXImplicitFragment$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(JSXTag, (0, import_lib2.$E)((0, import_lib2.$S)(ImplicitFragmentAllowed, NestedBinaryOpAllowed, NewlineBinaryOpAllowed, (0, import_lib2.$Q)((0, import_lib2.$S)(Nested, (0, import_lib2.$C)(JSXTag, JSXAngleChild)))))), function($skip, $loc, $0, $1, $2) {
+  var first = $1;
+  var rest = $2;
+  rest = rest ? rest[3] : [];
+  const jsx = rest.length === 0 ? first : {
     type: "JSXFragment",
     children: [
       "<>\n",
       state.currentIndent.token,
-      ...$0,
+      first,
+      ...rest,
       "\n",
       state.currentIndent.token,
       "</>"
     ],
-    jsxChildren: [$1].concat($2.map(([, tag]) => tag))
+    jsxChildren: [first, ...rest.map(([, tag]) => tag)]
   };
   const type = typeOfJSX(jsx, config);
   return type ? [
@@ -19183,13 +19448,7 @@ var JSXAngleChild$0 = (0, import_lib2.$T)((0, import_lib2.$S)(CloseAngleBracket,
 function JSXAngleChild(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "JSXAngleChild", JSXAngleChild$0);
 }
-var JSXCodeChild$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(InsertInlineOpenBrace, JSXCodeChildExpression, InsertCloseBrace), function($skip, $loc, $0, $1, $2, $3) {
-  var open = $1;
-  var expression = $2;
-  var close = $3;
-  if (!expression) return $skip;
-  return [open, expression, close];
-});
+var JSXCodeChild$0 = (0, import_lib2.$S)(InsertInlineOpenBrace, JSXCodeChildExpression, InsertCloseBrace);
 function JSXCodeChild(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "JSXCodeChild", JSXCodeChild$0);
 }
@@ -20853,6 +21112,7 @@ var Reset$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Reset ""'), fu
   state.forbidTrailingMemberProperty = [false];
   state.forbidNestedBinaryOp = [false];
   state.forbidNewlineBinaryOp = [false];
+  state.forbidImplicitFragment = [false];
   state.forbidPipeline = [false];
   state.JSXTagStack = [void 0];
   state.operators = /* @__PURE__ */ new Map();
@@ -21134,6 +21394,7 @@ var state = {
   forbidTrailingMemberProperty: [false],
   forbidNestedBinaryOp: [false],
   forbidNewlineBinaryOp: [false],
+  forbidImplicitFragment: [false],
   forbidPipeline: [false],
   JSXTagStack: [void 0]
 };
@@ -21185,6 +21446,12 @@ Object.defineProperties(state, {
       return s[s.length - 1];
     }
   },
+  implicitFragmentForbidden: {
+    get() {
+      const { forbidImplicitFragment: s } = state;
+      return s[s.length - 1];
+    }
+  },
   pipelineForbidden: {
     get() {
       const { forbidPipeline: s } = state;
@@ -21207,7 +21474,7 @@ function setOperatorBehavior(name, behavior) {
   }
 }
 function getStateKey() {
-  const stateInt = state.currentIndent.level % 256 << 8 | state.classImplicitCallForbidden << 7 | state.indentedApplicationForbidden << 6 | state.bracedApplicationForbidden << 5 | state.trailingMemberPropertyForbidden << 4 | state.nestedBinaryOpForbidden << 3 | state.newlineBinaryOpForbidden << 2 | state.pipelineForbidden << 1 | // This is slightly different than the rest of the state,
+  const stateInt = state.currentIndent.level % 256 << 9 | state.classImplicitCallForbidden << 8 | state.indentedApplicationForbidden << 7 | state.bracedApplicationForbidden << 6 | state.trailingMemberPropertyForbidden << 5 | state.nestedBinaryOpForbidden << 4 | state.newlineBinaryOpForbidden << 3 | state.implicitFragmentForbidden << 2 | state.pipelineForbidden << 1 | // This is slightly different than the rest of the state,
   // since it is affected by the directive prologue and may be hit
   // by the EOL rule early in the parse. Later if we wanted to
   // allow block scoping of the compat directives we would need to
@@ -21307,7 +21574,7 @@ var SourceMap = class {
         const line = ref1[i1];
         results.push((() => {
           const results1 = [];
-          for (let i2 = 0, len1 = line.length; i2 < len1; i2++) {
+          for (let i2 = 0, len12 = line.length; i2 < len12; i2++) {
             const entry = line[i2];
             if (entry.length === 4) {
               let [colDelta, sourceFileIndex, srcLine, srcCol] = entry;
@@ -21653,10 +21920,11 @@ var WorkerPool = class {
       }
     })();
     const worker = new Worker(path.join(__dirname, "node-worker.mjs"));
-    worker.on("message", (response) => {
+    worker.on("message", async (response) => {
       const callback = this.callbacks.get(response.id);
       this.callbacks.delete(response.id);
       if (response.error) {
+        await new Promise((done) => setTimeout(done, 0));
         const message = `${response.error.name}: ${response.error.message}`;
         let ref;
         if (response.error.type in globalThis) {