@danielx/civet 0.6.30 → 0.6.32

package/dist/main.js

@@ -22,6 +22,10 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
   isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
   mod
 ));
@@ -522,9 +526,10 @@ var require_lib = __commonJS({
     }
     function addPostfixStatement(statement, ws, post) {
       let children, expressions;
-      if (post.blockPrefix?.length) {
-        let indent = post.blockPrefix[0][0];
-        expressions = [...post.blockPrefix, [indent, statement]];
+      const prefix = post.blockPrefix || post.condition?.expression.blockPrefix;
+      if (prefix?.length) {
+        const indent = prefix[0][0];
+        expressions = [...prefix, [indent, statement]];
         children = [" {\n", ...expressions, "\n", indent?.slice?.(0, -2), "}"];
       } else {
         expressions = [["", statement]];
@@ -603,6 +608,7 @@ var require_lib = __commonJS({
           children: [...elements.slice(0, restIndex), {
             ...rest,
             children: rest.children.slice(0, -1)
+            // remove trailing comma
           }],
           blockPrefix,
           length
@@ -647,7 +653,9 @@ var require_lib = __commonJS({
       if (prefixStatements && prefixStatements.length) {
         const indent = getIndent(block.expressions[0]);
         if (indent) {
-          prefixStatements = prefixStatements.map((statement) => [indent, ...statement.slice(1)]);
+          prefixStatements = prefixStatements.map((statement) => {
+            return [indent, ...statement.slice(1)];
+          });
         }
         const expressions = [...prefixStatements, ...block.expressions];
         block = {
@@ -832,7 +840,8 @@ var require_lib = __commonJS({
         ...wrapIIFE([
           ["", ["const ", resultsRef, "=[]"], ";"],
           ...children,
-          ["", ["; return ", resultsRef]]
+          ["", "; "],
+          ["", wrapWithReturn(resultsRef)]
         ], async)
       );
     }
@@ -947,6 +956,7 @@ var require_lib = __commonJS({
                   part.children[3]?.token === ":" ? part.children[3] : ":",
                   value,
                   part.delim
+                  // comma delimiter
                 ]
               });
             }
@@ -955,8 +965,10 @@ var require_lib = __commonJS({
             type: "ObjectExpression",
             children: [
               glob.object.children[0],
+              // {
               ...parts,
               glob.object.children.at(-1)
+              // whitespace and }
             ],
             properties: parts,
             hoistDec
@@ -971,12 +983,14 @@ var require_lib = __commonJS({
           if (i === children.length - 1)
             return object;
           return processCallMemberExpression({
+            // in case there are more
             ...node,
             children: [object, ...children.slice(i + 1)]
           });
         } else if (glob?.type === "PropertyBind") {
           const prefix = children.slice(0, i);
           return processCallMemberExpression({
+            // in case there are more
             ...node,
             children: [
               prefix,
@@ -1112,35 +1126,41 @@ var require_lib = __commonJS({
       ;
       return;
     }
+    var relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
+    function isRelationalOp(op) {
+      return relationalOps.includes(op.token) || op.relational;
+    }
     function expandChainedComparisons([first, binops]) {
-      const relationalOps = ["==", "===", "!=", "!==", "<", "<=", ">", ">=", "in"];
       const lowerPrecedenceOps = ["??", "&&", "||", "&", "|", "^"];
-      let results = [];
+      const results = [];
       let i = 0;
       const l = binops.length;
       let start = 0;
       let chains = [];
+      let op;
       while (i < l) {
-        const [, op] = binops[i];
-        if (relationalOps.includes(op.token) || op.relational) {
+        [, op] = binops[i];
+        if (isRelationalOp(op)) {
           chains.push(i);
         } else if (lowerPrecedenceOps.includes(op.token)) {
-          processChains();
+          processChains(op);
           first = [];
         }
         i++;
       }
-      processChains();
+      processChains(op);
       return results;
-      function processChains() {
-        first = expandExistence(first);
+      function processChains(op2) {
+        if (isRelationalOp(op2)) {
+          first = expandExistence(first);
+        }
         if (chains.length > 1) {
           chains.forEach((index, k) => {
             if (k > 0) {
               results.push(" ", "&&", " ");
             }
             const binop = binops[index];
-            let [pre, op, post, exp] = binop;
+            let [pre, op3, post, exp] = binop;
             exp = binop[3] = expandExistence(exp);
             let endIndex;
             if (k < chains.length - 1) {
@@ -1296,7 +1316,6 @@ var require_lib = __commonJS({
         default:
           return gatherNodes(node.children, predicate);
       }
-      return [];
     }
     function gatherRecursive(node, predicate, skipPredicate) {
       if (node == null)
@@ -1478,6 +1497,7 @@ var require_lib = __commonJS({
           else
             exp.children.push(["", {
               type: "ReturnStatement",
+              // NOTE: add a prefixed semi-colon because the if block may not be braced
               children: [";return"]
             }]);
           return;
@@ -1497,17 +1517,9 @@ var require_lib = __commonJS({
       node.splice(1, 1, returnStatement);
     }
     function insertSwitchReturns(exp) {
-      switch (exp.type) {
-        case "SwitchStatement":
-          exp.caseBlock.clauses.forEach((clause) => {
-            insertReturn:
-              insertReturn(clause);
-          });
-          return;
-        case "SwitchExpression":
-          exp.caseBlock.clauses.forEach(insertReturn);
-          return;
-      }
+      exp.caseBlock.clauses.forEach((clause) => {
+        return insertReturn(clause);
+      });
     }
     function isEmptyBareBlock(node) {
       if (node?.type !== "BlockStatement")
@@ -1646,6 +1658,7 @@ var require_lib = __commonJS({
           declaration,
           blockPrefix,
           children: [awaits, eachOwnError, open, declaration, ws, inOf, expRef ?? exp, step, close]
+          // omit declaration2, replace eachOwn with eachOwnError, replace exp with expRef
         };
       }
       let ws2, decl2;
@@ -1713,6 +1726,7 @@ var require_lib = __commonJS({
       return {
         declaration,
         children: [awaits, eachOwnError, open, declaration, ws, inOf, exp, step, close],
+        // omit declaration2, replace each with eachOwnError
         blockPrefix,
         hoistDec
       };
@@ -2089,14 +2103,6 @@ var require_lib = __commonJS({
         return processReturn(f, config.implicitReturns);
       });
     }
-    function processSwitchExpressions(statements) {
-      gatherRecursiveAll(statements, (n) => n.type === "SwitchExpression").forEach(insertSwitchReturns);
-    }
-    function processTryExpressions(statements) {
-      gatherRecursiveAll(statements, (n) => n.type === "TryExpression").forEach(({ blocks }) => {
-        blocks.forEach(insertReturn);
-      });
-    }
     function processBindingPatternLHS(lhs, tail) {
       adjustAtBindings(lhs, true);
       const [splices, thisAssignments] = gatherBindingCode(lhs);
@@ -2476,7 +2482,7 @@ var require_lib = __commonJS({
       return declarations;
     }
     function processPatternMatching(statements, ReservedWord) {
-      gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
+      gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement").forEach((s) => {
         const { caseBlock } = s;
         const { clauses } = caseBlock;
         let errors = false;
@@ -2582,10 +2588,6 @@ var require_lib = __commonJS({
           refAssignment = [];
           return prev = next;
         });
-        if (s.type === "SwitchExpression") {
-          insertReturn(root[0]);
-          root.splice(0, 1, wrapIIFE(root[0]));
-        }
         s.type = "PatternMatchingStatement";
         s.children = [root];
         return addParentPointers(s, s.parent);
@@ -2731,8 +2733,6 @@ var require_lib = __commonJS({
       processPipelineExpressions(statements);
       processAssignments(statements);
       processPatternMatching(statements, ReservedWord);
-      processSwitchExpressions(statements);
-      processTryExpressions(statements);
       gatherRecursiveAll(statements, (n) => n.type === "IterationExpression").forEach((e) => expressionizeIteration(e));
       hoistRefDecs(statements);
       processFunctions(statements, config);
@@ -2969,20 +2969,31 @@ var require_lib = __commonJS({
       if (post?.token === "?") {
         post = {
           $loc: post.$loc,
-          token: "!="
+          token: " != null"
         };
         if (pre.length) {
-          exp = {
-            type: "UnaryExpression",
-            children: [...pre, exp, void 0]
-          };
+          const lastPre = pre[pre.length - 1];
+          if (lastPre.token === "!") {
+            post.token = " == null";
+            pre = pre.slice(0, -1);
+          } else if (lastPre.length === 2 && lastPre[0].token === "!") {
+            post.token = " == null";
+            pre = pre.slice(0, -1);
+          }
         }
         const existence = {
           type: "Existence",
           expression: exp,
-          children: [exp, " ", post, " ", "null"]
+          children: [exp, post]
         };
-        return makeLeftHandSideExpression(existence);
+        exp = makeLeftHandSideExpression(existence);
+        if (pre.length) {
+          return {
+            type: "UnaryExpression",
+            children: [...pre, exp]
+          };
+        }
+        return exp;
       }
       if (exp.type === "Literal") {
         if (pre.length === 1 && pre[0].token === "-") {
@@ -3179,31 +3190,53 @@ var require_lib = __commonJS({
       ;
       return;
     }
-    function wrapIIFE(exp, async) {
-      let prefix, suffix;
+    function wrapIIFE(expressions, async) {
+      let prefix;
       if (async) {
-        prefix = "(async ()=>";
-        suffix = ")()";
-      } else if (hasAwait(exp)) {
-        prefix = "(await (async ()=>";
-        suffix = ")())";
-      } else {
-        prefix = "(()=>";
-        suffix = ")()";
+        async = "async ";
+      } else if (hasAwait(expressions)) {
+        async = "async ";
+        prefix = {
+          type: "Await",
+          children: ["await "]
+        };
       }
-      const expressions = Array.isArray(exp) ? [...exp] : [exp];
       const block = {
         type: "BlockStatement",
         expressions,
         children: ["{", expressions, "}"],
         bare: false
       };
-      updateParentPointers(block);
-      return [
-        prefix,
+      const parameters = {
+        type: "Parameters",
+        children: ["()"],
+        names: []
+      };
+      const signature = {
+        modifier: {
+          async: !!async
+        },
+        returnType: void 0
+      };
+      const fn = {
+        type: "ArrowFunction",
+        signature,
+        parameters,
+        returnType: void 0,
+        ts: false,
+        async,
         block,
-        suffix
-      ];
+        children: [async, parameters, "=>", block]
+      };
+      updateParentPointers(block, fn);
+      const exp = {
+        type: "CallExpression",
+        children: [makeLeftHandSideExpression(fn), "()"]
+      };
+      if (prefix) {
+        return [makeLeftHandSideExpression([prefix, exp])];
+      }
+      return [exp];
     }
     module2.exports = {
       addParentPointers,
@@ -3615,6 +3648,8 @@ var require_parser = __commonJS({
       RestoreAll,
       ExpressionStatement,
       KeywordStatement,
+      DebuggerStatement,
+      ThrowStatement,
       Break,
       Continue,
       Debugger,
@@ -4708,6 +4743,8 @@ var require_parser = __commonJS({
       return {
         type: "AssignmentExpression",
         children: $0,
+        // NOTE: This null marks the assignment for later processing to distinguish it
+        // from fake assignments that only add a name to a scope
         names: null,
         lhs: $1,
         assigned: $1[0][1],
@@ -4748,7 +4785,8 @@ var require_parser = __commonJS({
         signature: {
           modifier: {
             async: !!async
-          }
+          },
+          returnType: suffix
         },
         parameters,
         returnType: suffix,
@@ -5346,6 +5384,7 @@ var require_parser = __commonJS({
       var num = $3;
       return [
         { type: "PropertyAccess", children: [dot, "at"] },
+        // not including `name` so that `{x.-1}` doesn't use it
         { type: "Call", children: ["(", neg, num, ")"] }
       ];
     });
@@ -5478,6 +5517,7 @@ var require_parser = __commonJS({
         type: "PropertyBind",
         name: id.name,
         children: [modifier, dot, id]
+        // omit `@` from children
       };
     });
     function PropertyBind(ctx, state) {
@@ -5573,6 +5613,7 @@ var require_parser = __commonJS({
             open,
             tt,
             ...pes,
+            // Remove delimiter
             { ...rest, children: rest.children.slice(0, -1) },
             close
           ],
@@ -5728,6 +5769,7 @@ var require_parser = __commonJS({
       var c = $3;
       return {
         ...c,
+        // names, blockPrefix, length
         type: "ArrayBindingPattern",
         elements: c.children,
         children: [$1, $2, c.children, $4, $5]
@@ -5752,6 +5794,7 @@ var require_parser = __commonJS({
       return elements.map(([element, delim]) => {
         return {
           ...element,
+          // BindingElement.children is a tuple of the form [ws, element]
           children: [...element.children, delim]
         };
       });
@@ -5768,6 +5811,7 @@ var require_parser = __commonJS({
         return {
           ...element,
           children: [indent, ...element.children.slice(1)]
+          // replace ws wth indent
         };
       });
     });
@@ -5997,6 +6041,7 @@ var require_parser = __commonJS({
         },
         block: null,
         children: !parameters.implicit ? [async, func, generator, wid, w, parameters, suffix] : [async, func, generator, wid, parameters, w, suffix]
+        // move whitespace w to after implicit () in parameters
       };
     });
     function FunctionSignature(ctx, state) {
@@ -6387,6 +6432,7 @@ var require_parser = __commonJS({
       return {
         type: "BlockStatement",
         expressions: s.expressions,
+        // Remove !EOS assertion
         children: [o, s.children, ws, c]
       };
     });
@@ -6405,6 +6451,7 @@ var require_parser = __commonJS({
       return {
         type: "BlockStatement",
         expressions: s.expressions,
+        // Remove !EOS assertion
         children: [o, s.children, ws, c]
       };
     });
@@ -6432,6 +6479,7 @@ var require_parser = __commonJS({
       return {
         type: "BlockStatement",
         expressions: [s],
+        // Remove &EOS assertion
         children: [$1, s, $3]
       };
     });
@@ -6455,6 +6503,7 @@ var require_parser = __commonJS({
         type: "BlockStatement",
         expressions,
         children: [expressions],
+        // avoid aliasing
         bare: true
       };
     });
@@ -6880,6 +6929,8 @@ var require_parser = __commonJS({
         last = {
           ...last,
           delim,
+          // __ will consume all whitespace that _? in PropertyDefinition could,
+          // so replace _? (via slice) with __
           children: [ws, ...last.children.slice(1), delim]
         };
         return [...prop.slice(0, prop.length - 1), last];
@@ -7321,6 +7372,7 @@ var require_parser = __commonJS({
         name,
         optional,
         modifier,
+        // get/set/async/generator
         returnType,
         parameters
       };
@@ -7600,6 +7652,7 @@ var require_parser = __commonJS({
         token: $1,
         relational: true,
         special: true
+        // for typeof shorthand
       };
     });
     var BinaryOpSymbol$40 = $TS($S(Not, __, $EXPECT($L93, 'BinaryOpSymbol "instanceof"'), NonIdContinue), function($skip, $loc, $0, $1, $2, $3, $4) {
@@ -7892,6 +7945,7 @@ var require_parser = __commonJS({
       condition = insertTrimmingSpace(condition, "");
       return {
         type: "IfStatement",
+        // TODO: Don't add unnecessary parens
         children: [kind, ["(!", condition, ")"]],
         condition
       };
@@ -8428,12 +8482,12 @@ var require_parser = __commonJS({
       return $EVENT(ctx, state, "EmptyCondition", EmptyCondition$0);
     }
     var SwitchExpression$0 = $TV(SwitchStatement, function($skip, $loc, $0, $1) {
-      var e = $0;
+      var s = $0;
       return {
         type: "SwitchExpression",
-        children: wrapIIFE(e.children),
-        expression: e.expression,
-        caseBlock: e.caseBlock
+        // wrap with IIFE
+        children: wrapIIFE([["", s]]),
+        statement: s
       };
     });
     function SwitchExpression(ctx, state) {
@@ -8473,6 +8527,7 @@ var require_parser = __commonJS({
       var clause = $2;
       return {
         ...clause,
+        // Bring the indent into the clause
         children: [indent, ...clause.children]
       };
     });
@@ -8624,7 +8679,7 @@ var require_parser = __commonJS({
       return {
         type: "TryExpression",
         blocks: t.blocks,
-        children: wrapIIFE(t)
+        children: wrapIIFE([["", t]])
       };
     });
     function TryExpression(ctx, state) {
@@ -8900,28 +8955,38 @@ var require_parser = __commonJS({
       return {
         type: "BreakStatement",
         children: $2 ? [$1, $2[0], $2[2]] : [$1]
+        // omit colon
       };
     });
     var KeywordStatement$1 = $TS($S(Continue, $E($S(_, $E(Colon), Identifier))), function($skip, $loc, $0, $1, $2) {
       return {
         type: "ContinueStatement",
         children: $2 ? [$1, $2[0], $2[2]] : [$1]
+        // omit colon
       };
     });
-    var KeywordStatement$2 = $T($S(Debugger), function(value) {
-      return { "type": "DebuggerStatement", "children": value };
-    });
+    var KeywordStatement$2 = DebuggerStatement;
     var KeywordStatement$3 = $T($S(Return, $N($C($EXPECT($L12, 'KeywordStatement ":"'), $EXPECT($L6, 'KeywordStatement "."'), AfterReturnShorthand)), $E(MaybeNestedExpression)), function(value) {
       var expression = value[2];
       return { "type": "ReturnStatement", "expression": expression, "children": value };
     });
-    var KeywordStatement$4 = $T($S(Throw, ExtendedExpression), function(value) {
-      return { "type": "ThrowStatement", "children": value };
-    });
+    var KeywordStatement$4 = ThrowStatement;
     var KeywordStatement$$ = [KeywordStatement$0, KeywordStatement$1, KeywordStatement$2, KeywordStatement$3, KeywordStatement$4];
     function KeywordStatement(ctx, state) {
       return $EVENT_C(ctx, state, "KeywordStatement", KeywordStatement$$);
     }
+    var DebuggerStatement$0 = $T($S(Debugger), function(value) {
+      return { "type": "DebuggerStatement", "children": value };
+    });
+    function DebuggerStatement(ctx, state) {
+      return $EVENT(ctx, state, "DebuggerStatement", DebuggerStatement$0);
+    }
+    var ThrowStatement$0 = $T($S(Throw, ExtendedExpression), function(value) {
+      return { "type": "ThrowStatement", "children": value };
+    });
+    function ThrowStatement(ctx, state) {
+      return $EVENT(ctx, state, "ThrowStatement", ThrowStatement$0);
+    }
     var Break$0 = $TS($S($EXPECT($L102, 'Break "break"'), NonIdContinue), function($skip, $loc, $0, $1, $2) {
       return { $loc, token: $1 };
     });
@@ -8940,19 +9005,21 @@ var require_parser = __commonJS({
     function Debugger(ctx, state) {
       return $EVENT(ctx, state, "Debugger", Debugger$0);
     }
-    var DebuggerExpression$0 = $TS($S(Debugger), function($skip, $loc, $0, $1) {
+    var DebuggerExpression$0 = $TV(DebuggerStatement, function($skip, $loc, $0, $1) {
+      var s = $0;
       return {
         type: "DebuggerExpression",
-        children: wrapIIFE($1)
+        children: wrapIIFE([["", s]])
       };
     });
     function DebuggerExpression(ctx, state) {
       return $EVENT(ctx, state, "DebuggerExpression", DebuggerExpression$0);
     }
-    var ThrowExpression$0 = $TS($S(Throw, ExtendedExpression), function($skip, $loc, $0, $1, $2) {
+    var ThrowExpression$0 = $TV(ThrowStatement, function($skip, $loc, $0, $1) {
+      var s = $0;
       return {
         type: "ThrowExpression",
-        children: wrapIIFE($0)
+        children: wrapIIFE([["", s]])
       };
     });
     function ThrowExpression(ctx, state) {
@@ -9501,6 +9568,7 @@ var require_parser = __commonJS({
       if (hasSubstitutions) {
         const result = [
           { ...open, token: "RegExp(`" },
+          // Escape backticks, backslashes, and '$' in the body text
           body.map(
             (e) => e.type === "Substitution" ? e : {
               ...e,
@@ -10380,7 +10448,9 @@ var require_parser = __commonJS({
         parts = [
           ...$0,
           "\n",
+          // InsertNewline
           module2.currentIndent.token,
+          // InsertIndent
           ["</", open[1], ">"]
         ];
       } else {
@@ -10448,7 +10518,9 @@ var require_parser = __commonJS({
       const parts = close ? $0 : [
         ...$0,
         "\n",
+        // InsertNewline
         module2.currentIndent.token,
+        // InsertIndent
         "</>"
       ];
       return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
@@ -12035,9 +12107,11 @@ var require_parser = __commonJS({
         react: false,
         solid: false,
         client: false,
+        // default behavior: client only
         rewriteTsImports: true,
         server: false,
         tab: void 0,
+        // default behavior = same as space
         verbose: false
       };
       const asAny = {
@@ -12175,7 +12249,12 @@ var require_parser = __commonJS({
         type: "ParserMeta",
         children: [],
         getStateKey() {
-          const stateInt = module2.currentIndent.level % 256 << 8 | module2.classImplicitCallForbidden << 7 | module2.indentedApplicationForbidden << 6 | module2.bracedApplicationForbidden << 5 | module2.trailingMemberPropertyForbidden << 4 | module2.newlineBinaryOpForbidden << 3 | module2.config.coffeeComment << 2;
+          const stateInt = module2.currentIndent.level % 256 << 8 | module2.classImplicitCallForbidden << 7 | module2.indentedApplicationForbidden << 6 | module2.bracedApplicationForbidden << 5 | module2.trailingMemberPropertyForbidden << 4 | module2.newlineBinaryOpForbidden << 3 | // 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
+          // add them all here.
+          module2.config.coffeeComment << 2;
           return [stateInt, module2.currentJSXTag];
         }
       };
@@ -12200,7 +12279,8 @@ var require_parser = __commonJS({
       if (module2.config.tab) {
         const tabs = $0.match(/\t/g);
         const numTabs = tabs ? tabs.length : 0;
-        level = numTabs * module2.config.tab + ($0.length - numTabs);
+        level = numTabs * module2.config.tab + /*spaces*/
+        ($0.length - numTabs);
       } else {
         level = $0.length;
       }
@@ -12623,6 +12703,8 @@ var require_parser = __commonJS({
     exports.RestoreAll = RestoreAll;
     exports.ExpressionStatement = ExpressionStatement;
     exports.KeywordStatement = KeywordStatement;
+    exports.DebuggerStatement = DebuggerStatement;
+    exports.ThrowStatement = ThrowStatement;
     exports.Break = Break;
     exports.Continue = Continue;
     exports.Debugger = Debugger;
@@ -13453,6 +13535,10 @@ var StateCache = class {
   get(key) {
     return this.cache.get(key[0])?.get(key[1])?.get(key[2])?.get(key[3]);
   }
+  /**
+   * Check if this multi-layer cache has the given key.
+   * Since the intermediate layers are always other maps we only need to check the last layer.
+   */
   has(key) {
     return !!this.cache.get(key[0])?.get(key[1])?.get(key[2])?.has(key[3]);
   }
@@ -13487,16 +13573,23 @@ var StateCache = class {
 var { parse } = import_parser.default;
 var { SourceMap: SourceMap2 } = util_exports;
 var uncacheable = /* @__PURE__ */ new Set([
+  // Meta
   "DebugHere",
   "Init",
   "Program",
   "Reset",
+  // Indentation
+  // We need to no-cache the state modifying rules up to the point where they
+  // balance within a parent so PushIndent needs to be marked no-cache even
+  // though it only calls TrackIndented which does the actual work.
   "PushIndent",
   "PopIndent",
   "TrackIndented",
+  // JSX
   "PushJSXOpeningElement",
   "PushJSXOpeningFragment",
   "PopJSXStack",
+  // State
   "AllowAll",
   "AllowClassImplicitCall",
   "AllowBracedApplication",
@@ -13599,7 +13692,8 @@ function makeCache() {
   return events;
 }
 var isCompileError = function(err) {
-  return err instanceof Error && [err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
+  return err instanceof Error && //@ts-ignore
+  [err.message, err.name, err.filename, err.line, err.column, err.offset].every(($1) => $1 !== void 0);
 };
 var main_default = { parse, generate: generate_default, util: util_exports, compile, isCompileError };
 // Annotate the CommonJS export names for ESM import in node: