@danielx/civet 0.6.31 → 0.6.33

package/dist/browser.js

@@ -23,6 +23,10 @@ var Civet = (() => {
     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
   ));
@@ -523,9 +527,10 @@ ${input.slice(result.pos)}
       }
       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]];
@@ -604,6 +609,7 @@ ${input.slice(result.pos)}
             children: [...elements.slice(0, restIndex), {
               ...rest,
               children: rest.children.slice(0, -1)
+              // remove trailing comma
             }],
             blockPrefix,
             length
@@ -648,7 +654,9 @@ ${input.slice(result.pos)}
         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 = {
@@ -833,7 +841,8 @@ ${input.slice(result.pos)}
           ...wrapIIFE([
             ["", ["const ", resultsRef, "=[]"], ";"],
             ...children,
-            ["", ["; return ", resultsRef]]
+            ["", "; "],
+            ["", wrapWithReturn(resultsRef)]
           ], async)
         );
       }
@@ -948,6 +957,7 @@ ${input.slice(result.pos)}
                     part.children[3]?.token === ":" ? part.children[3] : ":",
                     value,
                     part.delim
+                    // comma delimiter
                   ]
                 });
               }
@@ -956,8 +966,10 @@ ${input.slice(result.pos)}
               type: "ObjectExpression",
               children: [
                 glob.object.children[0],
+                // {
                 ...parts,
                 glob.object.children.at(-1)
+                // whitespace and }
               ],
               properties: parts,
               hoistDec
@@ -972,12 +984,14 @@ ${input.slice(result.pos)}
             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,
@@ -1113,35 +1127,41 @@ ${input.slice(result.pos)}
         ;
         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) {
@@ -1297,7 +1317,6 @@ ${input.slice(result.pos)}
           default:
             return gatherNodes(node.children, predicate);
         }
-        return [];
       }
       function gatherRecursive(node, predicate, skipPredicate) {
         if (node == null)
@@ -1479,6 +1498,7 @@ ${input.slice(result.pos)}
             else
               exp.children.push(["", {
                 type: "ReturnStatement",
+                // NOTE: add a prefixed semi-colon because the if block may not be braced
                 children: [";return"]
               }]);
             return;
@@ -1498,17 +1518,9 @@ ${input.slice(result.pos)}
         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")
@@ -1647,6 +1659,7 @@ ${input.slice(result.pos)}
             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;
@@ -1714,6 +1727,7 @@ ${input.slice(result.pos)}
         return {
           declaration,
           children: [awaits, eachOwnError, open, declaration, ws, inOf, exp, step, close],
+          // omit declaration2, replace each with eachOwnError
           blockPrefix,
           hoistDec
         };
@@ -2090,14 +2104,6 @@ ${input.slice(result.pos)}
           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);
@@ -2477,7 +2483,7 @@ ${input.slice(result.pos)}
         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;
@@ -2583,10 +2589,6 @@ ${input.slice(result.pos)}
             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);
@@ -2726,14 +2728,12 @@ ${input.slice(result.pos)}
         assert.equal(m.forbidIndentedApplication.length, 1, "forbidIndentedApplication");
         assert.equal(m.forbidNewlineBinaryOp.length, 1, "forbidNewlineBinaryOp");
         assert.equal(m.forbidTrailingMemberProperty.length, 1, "forbidTrailingMemberProperty");
-        assert.equal(m.JSXTagStack.length, 0, "JSXTagStack should be empty");
+        assert.equal(m.JSXTagStack.length, 1, "JSXTagStack");
         addParentPointers(root);
         const { expressions: statements } = root;
         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);
@@ -2970,20 +2970,31 @@ ${input.slice(result.pos)}
         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 === "-") {
@@ -3180,31 +3191,53 @@ ${input.slice(result.pos)}
         ;
         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];
       }
       module.exports = {
         addParentPointers,
@@ -3616,6 +3649,8 @@ ${input.slice(result.pos)}
         RestoreAll,
         ExpressionStatement,
         KeywordStatement,
+        DebuggerStatement,
+        ThrowStatement,
         Break,
         Continue,
         Debugger,
@@ -4709,6 +4744,8 @@ ${input.slice(result.pos)}
         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],
@@ -5348,6 +5385,7 @@ ${input.slice(result.pos)}
         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, ")"] }
         ];
       });
@@ -5480,6 +5518,7 @@ ${input.slice(result.pos)}
           type: "PropertyBind",
           name: id.name,
           children: [modifier, dot, id]
+          // omit `@` from children
         };
       });
       function PropertyBind(ctx, state) {
@@ -5575,6 +5614,7 @@ ${input.slice(result.pos)}
               open,
               tt,
               ...pes,
+              // Remove delimiter
               { ...rest, children: rest.children.slice(0, -1) },
               close
             ],
@@ -5730,6 +5770,7 @@ ${input.slice(result.pos)}
         var c = $3;
         return {
           ...c,
+          // names, blockPrefix, length
           type: "ArrayBindingPattern",
           elements: c.children,
           children: [$1, $2, c.children, $4, $5]
@@ -5754,6 +5795,7 @@ ${input.slice(result.pos)}
         return elements.map(([element, delim]) => {
           return {
             ...element,
+            // BindingElement.children is a tuple of the form [ws, element]
             children: [...element.children, delim]
           };
         });
@@ -5770,6 +5812,7 @@ ${input.slice(result.pos)}
           return {
             ...element,
             children: [indent, ...element.children.slice(1)]
+            // replace ws wth indent
           };
         });
       });
@@ -5999,6 +6042,7 @@ ${input.slice(result.pos)}
           },
           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) {
@@ -6389,6 +6433,7 @@ ${input.slice(result.pos)}
         return {
           type: "BlockStatement",
           expressions: s.expressions,
+          // Remove !EOS assertion
           children: [o, s.children, ws, c]
         };
       });
@@ -6407,6 +6452,7 @@ ${input.slice(result.pos)}
         return {
           type: "BlockStatement",
           expressions: s.expressions,
+          // Remove !EOS assertion
           children: [o, s.children, ws, c]
         };
       });
@@ -6434,6 +6480,7 @@ ${input.slice(result.pos)}
         return {
           type: "BlockStatement",
           expressions: [s],
+          // Remove &EOS assertion
           children: [$1, s, $3]
         };
       });
@@ -6457,6 +6504,7 @@ ${input.slice(result.pos)}
           type: "BlockStatement",
           expressions,
           children: [expressions],
+          // avoid aliasing
           bare: true
         };
       });
@@ -6882,6 +6930,8 @@ ${input.slice(result.pos)}
           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];
@@ -7323,6 +7373,7 @@ ${input.slice(result.pos)}
           name,
           optional,
           modifier,
+          // get/set/async/generator
           returnType,
           parameters
         };
@@ -7602,6 +7653,7 @@ ${input.slice(result.pos)}
           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) {
@@ -7894,6 +7946,7 @@ ${input.slice(result.pos)}
         condition = insertTrimmingSpace(condition, "");
         return {
           type: "IfStatement",
+          // TODO: Don't add unnecessary parens
           children: [kind, ["(!", condition, ")"]],
           condition
         };
@@ -8430,12 +8483,12 @@ ${input.slice(result.pos)}
         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) {
@@ -8475,6 +8528,7 @@ ${input.slice(result.pos)}
         var clause = $2;
         return {
           ...clause,
+          // Bring the indent into the clause
           children: [indent, ...clause.children]
         };
       });
@@ -8626,7 +8680,7 @@ ${input.slice(result.pos)}
         return {
           type: "TryExpression",
           blocks: t.blocks,
-          children: wrapIIFE(t)
+          children: wrapIIFE([["", t]])
         };
       });
       function TryExpression(ctx, state) {
@@ -8902,28 +8956,38 @@ ${input.slice(result.pos)}
         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 };
       });
@@ -8942,19 +9006,21 @@ ${input.slice(result.pos)}
       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) {
@@ -9503,6 +9569,7 @@ ${input.slice(result.pos)}
         if (hasSubstitutions) {
           const result = [
             { ...open, token: "RegExp(`" },
+            // Escape backticks, backslashes, and '$' in the body text
             body.map(
               (e) => e.type === "Substitution" ? e : {
                 ...e,
@@ -10382,7 +10449,9 @@ ${input.slice(result.pos)}
           parts = [
             ...$0,
             "\n",
+            // InsertNewline
             module.currentIndent.token,
+            // InsertIndent
             ["</", open[1], ">"]
           ];
         } else {
@@ -10450,7 +10519,9 @@ ${input.slice(result.pos)}
         const parts = close ? $0 : [
           ...$0,
           "\n",
+          // InsertNewline
           module.currentIndent.token,
+          // InsertIndent
           "</>"
         ];
         return { type: "JSXFragment", children: parts, jsxChildren: children.jsxChildren };
@@ -11964,7 +12035,7 @@ ${input.slice(result.pos)}
         module.forbidBracedApplication = [false];
         module.forbidTrailingMemberProperty = [false];
         module.forbidNewlineBinaryOp = [false];
-        module.JSXTagStack = [];
+        module.JSXTagStack = [void 0];
         module.operators = /* @__PURE__ */ new Set();
         if (!module._init) {
           module._init = true;
@@ -12037,9 +12108,11 @@ ${input.slice(result.pos)}
           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 = {
@@ -12177,7 +12250,12 @@ ${input.slice(result.pos)}
           type: "ParserMeta",
           children: [],
           getStateKey() {
-            const stateInt = module.currentIndent.level % 256 << 8 | module.classImplicitCallForbidden << 7 | module.indentedApplicationForbidden << 6 | module.bracedApplicationForbidden << 5 | module.trailingMemberPropertyForbidden << 4 | module.newlineBinaryOpForbidden << 3 | module.config.coffeeComment << 2;
+            const stateInt = module.currentIndent.level % 256 << 8 | module.classImplicitCallForbidden << 7 | module.indentedApplicationForbidden << 6 | module.bracedApplicationForbidden << 5 | module.trailingMemberPropertyForbidden << 4 | module.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.
+            module.config.coffeeComment << 2;
             return [stateInt, module.currentJSXTag];
           }
         };
@@ -12202,7 +12280,8 @@ ${input.slice(result.pos)}
         if (module.config.tab) {
           const tabs = $0.match(/\t/g);
           const numTabs = tabs ? tabs.length : 0;
-          level = numTabs * module.config.tab + ($0.length - numTabs);
+          level = numTabs * module.config.tab + /*spaces*/
+          ($0.length - numTabs);
         } else {
           level = $0.length;
         }
@@ -12625,6 +12704,8 @@ ${input.slice(result.pos)}
       exports.RestoreAll = RestoreAll;
       exports.ExpressionStatement = ExpressionStatement;
       exports.KeywordStatement = KeywordStatement;
+      exports.DebuggerStatement = DebuggerStatement;
+      exports.ThrowStatement = ThrowStatement;
       exports.Break = Break;
       exports.Continue = Continue;
       exports.Debugger = Debugger;
@@ -13454,6 +13535,10 @@ ${input.slice(result.pos)}
     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]);
     }
@@ -13488,16 +13573,23 @@ ${input.slice(result.pos)}
   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",
@@ -13600,7 +13692,8 @@ ${input.slice(result.pos)}
     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 };
   return __toCommonJS(main_exports);