@danielx/civet 0.10.6 → 0.11.0

package/dist/main.js

@@ -490,6 +490,7 @@ __export(main_civet_exports, {
   ParseErrors: () => ParseErrors,
   SourceMap: () => SourceMap2,
   compile: () => compile,
+  decode: () => decode,
   default: () => main_civet_default,
   generate: () => generate_civet_default,
   isCompileError: () => isCompileError,
@@ -623,7 +624,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);
     }
@@ -1607,7 +1608,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;
@@ -1814,7 +1815,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") {
@@ -3073,7 +3074,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);
         }
@@ -4043,7 +4044,11 @@ function processSignature(f) {
     }
   }
   if (signature.modifier.async && !signature.modifier.generator && signature.returnType && !isPromiseType(signature.returnType.t)) {
-    replaceNode(signature.returnType.t, wrapTypeInPromise(signature.returnType.t));
+    replaceNode(
+      signature.returnType.t,
+      wrapTypeInPromise(signature.returnType.t),
+      signature.returnType
+    );
   }
 }
 function processFunctions(statements, config2) {
@@ -4072,14 +4077,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
         ]
       };
@@ -4273,6 +4287,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;
@@ -4371,16 +4396,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];
@@ -4398,8 +4465,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;
       }
@@ -4445,8 +4512,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;
   }
@@ -4499,7 +4566,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);
   }
@@ -4830,7 +4897,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;
@@ -5364,7 +5431,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)) {
@@ -5451,7 +5518,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) {
@@ -5473,9 +5540,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;
@@ -5491,14 +5558,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;
 }
@@ -5819,26 +5883,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;
@@ -6138,7 +6236,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;
@@ -6930,7 +7028,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");
     }
@@ -7020,6 +7118,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 || [],
@@ -7397,7 +7498,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)) {
@@ -7427,19 +7528,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);
@@ -7452,7 +7556,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)}`
@@ -7468,9 +7572,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);
@@ -7646,21 +7769,18 @@ function makeExpressionStatement(expression) {
   }
 }
 function lastAccessInCallExpression(exp) {
-  if (exp.type === "Identifier") {
+  while (exp.type === "MemberExpression" || exp.type === "CallExpression") {
+    const { children } = exp;
+    let i = children.length - 1;
+    while (i >= 0 && typeof children[i] === "object" && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional")) i--;
+    if (i < 0) return;
+    exp = children[i];
+  }
+  if (exp.type === "Identifier" || exp.type === "PropertyAccess" || exp.type === "Index") {
     return exp;
   }
-  let children, i;
-  do {
-    if (!(exp.children != null)) {
-      return;
-    }
-    ;
-    ({ children } = exp);
-    i = children.length - 1;
-    while (i >= 0 && (children[i].type === "Call" || children[i].type === "NonNullAssertion" || children[i].type === "Optional")) i--;
-    if (i < 0) return;
-  } while (children[i].type === "MemberExpression" && (exp = children[i]));
-  return children[i];
+  ;
+  return;
 }
 function convertMethodToFunction(method) {
   const { signature, block } = method;
@@ -7876,7 +7996,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") {
@@ -7905,7 +8025,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])) {
@@ -7950,7 +8070,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;
@@ -8021,7 +8141,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"];
             }
@@ -8184,7 +8304,7 @@ 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++) {
+  for (let ref16 = gatherRecursiveAll(node, ($11) => $11.type === "TypeUnary"), i8 = 0, len7 = ref16.length; i8 < len7; i8++) {
     const unary = ref16[i8];
     let suffixIndex = unary.suffix.length - 1;
     const results2 = [];
@@ -8312,7 +8432,7 @@ 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++) {
+  for (let ref18 = gatherRecursiveAll(statements, ($12) => $12.type === "StatementExpression"), i9 = 0, len8 = ref18.length; i9 < len8; i9++) {
     const exp = ref18[i9];
     const { maybe, statement } = exp;
     if ((maybe || statement.type === "ThrowStatement") && blockContainingStatement(exp)) {
@@ -8382,7 +8502,7 @@ function processNegativeIndexAccess(statements) {
   });
 }
 function processFinallyClauses(statements) {
-  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len8 = ref20.length; i10 < len8; i10++) {
+  for (let ref20 = gatherRecursiveAll(statements, ($) => $.type === "FinallyClause" && $.parent?.type !== "TryStatement"), i10 = 0, len9 = ref20.length; i10 < len9; i10++) {
     let f = ref20[i10];
     let ref21;
     if (!((ref21 = blockContainingStatement(f)) && typeof ref21 === "object" && "block" in ref21 && "index" in ref21)) {
@@ -8460,7 +8580,7 @@ function processBreaksContinues(statements) {
   }
 }
 function processCoffeeClasses(statements) {
-  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len9 = ref22.length; i11 < len9; i11++) {
+  for (let ref22 = gatherRecursiveAll(statements, ($13) => $13.type === "ClassExpression"), i11 = 0, len10 = ref22.length; i11 < len10; i11++) {
     const ce = ref22[i11];
     const { expressions } = ce.body;
     const indent = expressions[0]?.[0] ?? "\n";
@@ -8505,7 +8625,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)"], ";"]);
           }
@@ -8621,7 +8741,7 @@ 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++) {
+  for (let ref23 = gatherRecursiveWithinFunction(topBlock, ($22) => $22.type === "Declaration"), i14 = 0, len12 = ref23.length; i14 < len12; i14++) {
     const decl = ref23[i14];
     if (!decl.names?.length) {
       continue;
@@ -8635,7 +8755,7 @@ 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++) {
+  for (let ref24 = gatherRecursive(topBlock, ($23) => $23.type === "FunctionExpression"), i15 = 0, len13 = ref24.length; i15 < len13; i15++) {
     const func = ref24[i15];
     if (func.name && func.parent?.type === "BlockStatement") {
       if (func.parent === topBlock) {
@@ -8648,7 +8768,7 @@ function processRepl(root, rootIIFE) {
       }
     }
   }
-  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($24) => $24.type === "ClassExpression"), i16 = 0, len13 = ref25.length; i16 < len13; i16++) {
+  for (let ref25 = gatherRecursiveWithinFunction(topBlock, ($24) => $24.type === "ClassExpression"), i16 = 0, len14 = ref25.length; i16 < len14; i16++) {
     const classExp = ref25[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)) {
@@ -8660,7 +8780,7 @@ 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++) {
+  for (let ref26 = gatherRecursiveAll(statements, ($25) => $25.type === "Placeholder"), i17 = 0, len15 = ref26.length; i17 < len15; i17++) {
     const exp = ref26[i17];
     let ancestor;
     if (exp.subtype === ".") {
@@ -8770,7 +8890,7 @@ 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;
@@ -8884,10 +9004,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) {
@@ -8895,7 +9017,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];
@@ -8910,33 +9032,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, "]"];
     }
@@ -9161,6 +9290,8 @@ var grammar = {
   NonSingleBracedBlock,
   DeclarationOrStatement,
   SingleLineStatements,
+  ObjectSingleLineStatements,
+  BracedObjectSingleLineStatements,
   PostfixedSingleLineStatements,
   PostfixedSingleLineNoCommaStatements,
   NestedBlockStatements,
@@ -9341,6 +9472,10 @@ var grammar = {
   ForbidNewlineBinaryOp,
   RestoreNewlineBinaryOp,
   NewlineBinaryOpAllowed,
+  AllowImplicitFragment,
+  ForbidImplicitFragment,
+  RestoreImplicitFragment,
+  ImplicitFragmentAllowed,
   AllowPipeline,
   ForbidPipeline,
   RestorePipeline,
@@ -9366,11 +9501,15 @@ var grammar = {
   NameSpaceImport,
   NamedImports,
   OperatorNamedImports,
+  DynamicNamedImports,
+  DynamicImportContents,
   FromClause,
   ImportAssertion,
   TypeAndImportSpecifier,
   ImportSpecifier,
   OperatorImportSpecifier,
+  DynamicImportSpecifier,
+  DynamicModuleExportName,
   ImportAsToken,
   ModuleExportName,
   ModuleSpecifier,
@@ -10648,7 +10787,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$$);
@@ -10982,8 +11125,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$$);
 }
@@ -11694,10 +11838,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;
@@ -13010,7 +13154,7 @@ var OperatorDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, (
   var behavior = $2;
   var w = $3;
   var decl = $4;
-  decl.names.forEach((name) => state.operators.set(name, behavior));
+  decl.names.forEach((name) => setOperatorBehavior(name, behavior));
   if (behavior?.error) decl = prepend(behavior.error, decl);
   decl = prepend(trimFirstSpace(w), decl);
   return decl;
@@ -13018,7 +13162,7 @@ var OperatorDeclaration$0 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, (
 var OperatorDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)(OperatorSignature, BracedBlock), function($skip, $loc, $0, $1, $2) {
   var signature = $1;
   var block = $2;
-  state.operators.set(signature.id.name, signature.behavior);
+  setOperatorBehavior(signature.id.name, signature.behavior);
   return {
     ...signature,
     type: "FunctionExpression",
@@ -13035,10 +13179,10 @@ var OperatorDeclaration$2 = (0, import_lib2.$TS)((0, import_lib2.$S)(Operator, _
   var behavior = $4;
   var ids = $5;
   const children = [];
-  state.operators.set(id.name, behavior);
+  setOperatorBehavior(id.name, behavior);
   if (behavior?.error) children.push(behavior.error);
   ids.forEach(([, , id2, behavior2]) => {
-    state.operators.set(id2.name, behavior2);
+    setOperatorBehavior(id2.name, behavior2);
     if (behavior2?.error) children.push(behavior2.error);
   });
   return {
@@ -13138,7 +13282,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;
@@ -13292,8 +13436,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$$);
 }
@@ -13352,11 +13497,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$$);
 }
@@ -13492,6 +13638,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;
@@ -14342,7 +14508,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) {
@@ -14401,7 +14568,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,
@@ -14416,7 +14584,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 {
@@ -14429,7 +14598,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];
@@ -14632,6 +14802,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: {
@@ -15349,7 +15520,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;
@@ -16381,8 +16552,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;
 });
@@ -16559,6 +16730,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);
 });
@@ -16586,11 +16784,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);
 }
@@ -16693,7 +16891,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$$);
@@ -16705,7 +16907,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$$);
@@ -16728,7 +16934,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$$);
@@ -16771,7 +16981,7 @@ var ImportDeclaration$1 = (0, import_lib2.$TS)((0, import_lib2.$S)((0, import_li
   const errors = [];
   if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
-    state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    setOperatorBehavior(spec.binding.name, spec.behavior ?? behavior);
     if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
@@ -16822,7 +17032,7 @@ var ImportDeclaration$5 = (0, import_lib2.$TS)((0, import_lib2.$S)(FromClause, _
   const errors = [];
   if (behavior?.error) errors.push(behavior.error);
   imports.specifiers.forEach((spec) => {
-    state.operators.set(spec.binding.name, spec.behavior ?? behavior);
+    setOperatorBehavior(spec.binding.name, spec.behavior ?? behavior);
     if (spec.behavior?.error) errors.push(spec.behavior.error);
   });
   return {
@@ -16923,6 +17133,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 module2 = $3;
   if (!Array.isArray(module2)) return $0;
@@ -16944,17 +17172,17 @@ 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") {
     throw new Error("Expected identifier after `operator`");
   }
-  state.operators.set(spec.binding.name, spec.behavior);
+  setOperatorBehavior(spec.binding.name, spec.behavior);
   return {
     ...spec,
     children: [
@@ -16964,7 +17192,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$$);
 }
@@ -17011,6 +17239,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;
@@ -18302,7 +18551,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);
@@ -18455,18 +18704,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 ? [
@@ -19201,13 +19454,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);
 }
@@ -20550,6 +20797,7 @@ var CivetOption$0 = (0, import_lib2.$TR)((0, import_lib2.$EXPECT)($R99, "CivetOp
       break;
     case "globals":
     case "symbols":
+    case "operators":
       value = value.split(",").filter(Boolean);
       break;
   }
@@ -20870,6 +21118,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();
@@ -20958,6 +21207,36 @@ var Reset$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Reset ""'), fu
       }
     }
   });
+  Object.defineProperty(config, "operators", {
+    set(o) {
+      if (!o) return;
+      if (typeof o !== "object") {
+        throw new Error("operators configuration must be an object or array");
+      }
+      if (Array.isArray(o)) {
+        o.forEach((name) => {
+          if (typeof name !== "string") {
+            throw new Error("operators configuration array must contain only strings");
+          }
+          setOperatorBehavior(name, void 0);
+        });
+      } else {
+        for (let [name, behavior] of Object.entries(o)) {
+          if (typeof behavior === "string") {
+            behavior = behavior.trim();
+            behavior = behavior ? parse(behavior, {
+              startRule: "OperatorBehavior",
+              filename: `operator config for ${name}`
+            }) : void 0;
+          }
+          if (behavior && typeof behavior !== "object") {
+            throw new Error("operators configuration object must have string or object values");
+          }
+          setOperatorBehavior(name, behavior);
+        }
+      }
+    }
+  });
   Object.assign(config, initialConfig);
 });
 function Reset(ctx, state2) {
@@ -21089,26 +21368,24 @@ var PushExtraIndent1$0 = (0, import_lib2.$TV)((0, import_lib2.$EXPECT)($L0, 'Pus
 function PushExtraIndent1(ctx, state2) {
   return (0, import_lib2.$EVENT)(ctx, state2, "PushExtraIndent1", PushExtraIndent1$0);
 }
-var parser = function() {
-  const { fail, validate, reset } = (0, import_lib2.Validator)();
-  let ctx = { expectation: "", fail };
-  return {
-    parse: (input, options = {}) => {
-      if (typeof input !== "string") throw new Error("Input must be a string");
-      const parser2 = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
-      if (!parser2) throw new Error(`Could not find rule with name '${options.startRule}'`);
-      const filename2 = options.filename || "<anonymous>";
-      reset();
-      Object.assign(ctx, { ...options.events, tokenize: options.tokenize });
-      return validate(input, parser2(ctx, {
-        input,
-        pos: 0
-      }), {
-        filename: filename2
-      });
-    }
-  };
-}();
+var parser = {
+  parse: (input, options = {}) => {
+    const { fail, validate, reset } = (0, import_lib2.Validator)();
+    let ctx = { expectation: "", fail };
+    if (typeof input !== "string") throw new Error("Input must be a string");
+    const parser2 = options.startRule != null ? grammar[options.startRule] : Object.values(grammar)[0];
+    if (!parser2) throw new Error(`Could not find rule with name '${options.startRule}'`);
+    const filename2 = options.filename || "<anonymous>";
+    reset();
+    Object.assign(ctx, { ...options.events, tokenize: options.tokenize });
+    return validate(input, parser2(ctx, {
+      input,
+      pos: 0
+    }), {
+      filename: filename2
+    });
+  }
+};
 var { parse } = parser;
 var filename;
 var initialConfig;
@@ -21123,6 +21400,7 @@ var state = {
   forbidTrailingMemberProperty: [false],
   forbidNestedBinaryOp: [false],
   forbidNewlineBinaryOp: [false],
+  forbidImplicitFragment: [false],
   forbidPipeline: [false],
   JSXTagStack: [void 0]
 };
@@ -21174,6 +21452,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;
@@ -21187,8 +21471,16 @@ Object.defineProperties(state, {
     }
   }
 });
+function setOperatorBehavior(name, behavior) {
+  const existing = state.operators.get(name);
+  if (existing && behavior) {
+    state.operators.set(name, { ...existing, ...behavior });
+  } else {
+    state.operators.set(name, behavior || existing);
+  }
+}
 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
@@ -21288,7 +21580,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;
@@ -21628,10 +21920,11 @@ var WorkerPool = class {
     const { Worker } = await import("node:worker_threads");
     const path = (await import("node:path")).default;
     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) {
@@ -21747,7 +22040,32 @@ var uncacheable = /* @__PURE__ */ new Set([
   "RestorePipeline"
 ]);
 var workerPool;
+function decode(src) {
+  if (typeof src === "string") {
+    return src;
+  }
+  if (typeof Buffer === "undefined") {
+    return src;
+  }
+  if (!Buffer?.isBuffer(src)) {
+    return src;
+  }
+  if (src[0] === 239 && src[1] === 187 && src[2] === 191) {
+    return src.toString("utf8", 3);
+  } else if (src[0] === 255 && src[1] === 254) {
+    return src.toString("utf16le", 2);
+  } else if (src[0] === 254 && src[1] === 255) {
+    for (let end = src.length - 2, i1 = 2; i1 <= end; i1 += 2) {
+      const i = i1;
+      [src[i], src[i + 1]] = [src[i + 1], src[i]];
+    }
+    return src.toString("utf16le", 2);
+  } else {
+    return src.toString("utf8");
+  }
+}
 function compile(src, options) {
+  src = decode(src);
   if (!(process.env.CIVET_THREADS == 0)) {
     const threads = parseInt(options?.threads ?? process.env.CIVET_THREADS, 10);
     if (threads === 0) {
@@ -21944,6 +22262,7 @@ var main_civet_default = { parse, parseProgram, ParseError: import_lib2.ParseErr
   ParseErrors,
   SourceMap,
   compile,
+  decode,
   generate,
   isCompileError,
   lib,