@danielx/civet 0.5.73 → 0.5.74

package/README.md

@@ -74,6 +74,11 @@ Civet is essentially a tasteful superset of TypeScript.
 
 ### Implementations of New and Proposed ES Features
 
+See the [documentation](https://civet.dev/) for examples of these
+and other features.
+
+- Pattern matching (based on [TC39 proposal](https://github.com/tc39/proposal-pattern-matching))
+  - `switch` can match patterns like `[{type: "text", name}, ...rest]`
 - Pipe operator (based on [F# pipes](https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/symbol-and-operator-reference/#function-symbols-and-operators), [Hack pipes](https://docs.hhvm.com/hack/expressions-and-operators/pipe) and the [TC39 proposal](https://github.com/tc39/proposal-pipeline-operator))
   - `data |> Object.keys |> console.log` equivalent to
     `console.log(Object.keys(data))`
@@ -82,14 +87,19 @@ Civet is essentially a tasteful superset of TypeScript.
   - `|> await`, `|> yield`, and `|> return` (at end)
     for wrapping left-hand side with that operation
 - Short function block syntax like [Ruby symbol to proc](https://ruby-doc.org/core-3.1.2/Symbol.html#method-i-to_proc), [Crystal](https://crystal-lang.org/reference/1.6/syntax_and_semantics/blocks_and_procs.html#short-one-parameter-syntax), [Elm record access](https://elm-lang.org/docs/records#access)
-  - Access: `x.map &.name` → `x.map(a => a.name)`
+  - Access: `x.map &.name` or `x.map .name` → `x.map(a => a.name)`
   - Nested access + slices: `x.map &.profile?.name[0...3]` → `x.map(a => a.profile?.name.slice(0, 3))`
   - Function call: `x.map &.callback a, b` → `x.map($ => $.callback(a, b))`
   - Unary operators: `x.map !!&` → `x.map($ => !!$)`
   - Binary operators: `x.map &+1` → `x.map($ => $+1)`
-- Flagging shorthand based on [from LiveScript](https://livescript.net/#literals-objects):
-  `{+debug, -live, !verbose}` → `{debug: true, live: false, verbose: false}`
-
+- Object literal shorthand
+  - `{foo()}` → `{foo: foo()}`, `{props.foo}` → `{foo: props.foo}`
+  - ``{`${x}${y}`: z}`` → ``{[`${x}${y}`]: z}``
+  - `data.{x,y}` or `data{x,y}` → `{x: data.x, y: data.y}`
+  - Flagging shorthand based on [from LiveScript](https://livescript.net/#literals-objects):
+    `{+debug, -live, !verbose}` → `{debug: true, live: false, verbose: false}`
+- Custom infix operators from any two-argument function
+- `do` expressions, `if` expressions, `for` expressions
 
 ### Convenience for ES6+ Features
 
@@ -194,7 +204,7 @@ could be a valid property `1.e10` → `1..e10`. The workaround is to add a trail
 - `when` inside switch automatically breaks and adds block scope.
 - `else` inside switch adds block scope.
 - No whitespace between unary operators and operands. Mandatory whitespace between condition and ternary `?` ex. `x ? a : b` since `x?` is the unary existential operator.
-- No labels (yet...)
+- Labels written `:label` (except for special case `$:` for Svelte)
 
 ### Scripting Improvements
 

package/dist/browser.js

@@ -642,6 +642,7 @@ ${input.slice(result.pos)}
         StatementListItem,
         PostfixedStatement,
         PostfixedExpression,
+        NonPipelinePostfixedExpression,
         PostfixStatement,
         Statement,
         EmptyStatement,
@@ -665,6 +666,7 @@ ${input.slice(result.pos)}
         LoopStatement,
         LoopClause,
         DoWhileStatement,
+        DoStatement,
         WhileStatement,
         WhileClause,
         ForStatement,
@@ -1038,6 +1040,7 @@ ${input.slice(result.pos)}
         TrackIndented,
         Samedent,
         IndentedFurther,
+        NotDedented,
         PushIndent,
         PopIndent,
         Nested
@@ -1966,7 +1969,7 @@ ${input.slice(result.pos)}
         var rhs = $2;
         return [[], op, [], rhs];
       });
-      var BinaryOpRHS$1 = $S(__, BinaryOp, $C(_, $S(EOS, __)), RHS);
+      var BinaryOpRHS$1 = $S(NotDedented, BinaryOp, $C(_, $S(EOS, __)), RHS);
       function BinaryOpRHS(state) {
         let eventData;
         if (state.events) {
@@ -2448,7 +2451,7 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var FatArrowBody$0 = $T($S($N(EOS), PostfixedExpression, $N(SemicolonDelimiter)), function(value) {
+      var FatArrowBody$0 = $T($S($N(EOS), NonPipelinePostfixedExpression, $N(SemicolonDelimiter)), function(value) {
         var exp = value[1];
         return exp;
       });
@@ -2579,12 +2582,13 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var PipelineExpression$0 = $TS($S(PipelineHeadItem, $P($S(__, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2) {
-        var head = $1;
-        var body = $2;
+      var PipelineExpression$0 = $TS($S($E(_), PipelineHeadItem, $P($S(NotDedented, Pipe, __, PipelineTailItem))), function($skip, $loc, $0, $1, $2, $3) {
+        var ws = $1;
+        var head = $2;
+        var body = $3;
         return {
           type: "PipelineExpression",
-          children: [head, body]
+          children: [ws, head, body]
         };
       });
       function PipelineExpression(state) {
@@ -8365,6 +8369,35 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var NonPipelinePostfixedExpression$0 = $TS($S(NonPipelineExtendedExpression, $E($S($Q(TrailingComment), PostfixStatement))), function($skip, $loc, $0, $1, $2) {
+        var expression = $1;
+        var post = $2;
+        if (post)
+          return module.attachPostfixStatementAsExpression(expression, post);
+        return expression;
+      });
+      function NonPipelinePostfixedExpression(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("NonPipelinePostfixedExpression", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("NonPipelinePostfixedExpression", state, NonPipelinePostfixedExpression$0(state));
+          if (state.events)
+            state.events.exit?.("NonPipelinePostfixedExpression", state, result, eventData);
+          return result;
+        } else {
+          const result = NonPipelinePostfixedExpression$0(state);
+          if (state.events)
+            state.events.exit?.("NonPipelinePostfixedExpression", state, result, eventData);
+          return result;
+        }
+      }
       var PostfixStatement$0 = ForClause;
       var PostfixStatement$1 = IfClause;
       var PostfixStatement$2 = LoopClause;
@@ -8901,8 +8934,11 @@ ${input.slice(result.pos)}
       var IterationStatement$1 = $T($S($N(CoffeeDoEnabled), DoWhileStatement), function(value) {
         return value[1];
       });
-      var IterationStatement$2 = WhileStatement;
-      var IterationStatement$3 = ForStatement;
+      var IterationStatement$2 = $T($S($N(CoffeeDoEnabled), DoStatement), function(value) {
+        return value[1];
+      });
+      var IterationStatement$3 = WhileStatement;
+      var IterationStatement$4 = ForStatement;
       function IterationStatement(state) {
         let eventData;
         if (state.events) {
@@ -8914,12 +8950,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state));
+          const result = $TOKEN("IterationStatement", state, IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state));
           if (state.events)
             state.events.exit?.("IterationStatement", state, result, eventData);
           return result;
         } else {
-          const result = IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state);
+          const result = IterationStatement$0(state) || IterationStatement$1(state) || IterationStatement$2(state) || IterationStatement$3(state) || IterationStatement$4(state);
           if (state.events)
             state.events.exit?.("IterationStatement", state, result, eventData);
           return result;
@@ -8928,6 +8964,7 @@ ${input.slice(result.pos)}
       var IterationExpression$0 = $TS($S(IterationStatement), function($skip, $loc, $0, $1) {
         return {
           type: "IterationExpression",
+          subtype: $1.type,
           children: [$1],
           block: $1.block
         };
@@ -9036,6 +9073,37 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var DoStatement$0 = $TS($S(Do, NoPostfixBracedBlock), function($skip, $loc, $0, $1, $2) {
+        var block = $2;
+        block = module.insertTrimmingSpace(block, "");
+        return {
+          type: "DoStatement",
+          children: [block],
+          block
+        };
+      });
+      function DoStatement(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("DoStatement", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("DoStatement", state, DoStatement$0(state));
+          if (state.events)
+            state.events.exit?.("DoStatement", state, result, eventData);
+          return result;
+        } else {
+          const result = DoStatement$0(state);
+          if (state.events)
+            state.events.exit?.("DoStatement", state, result, eventData);
+          return result;
+        }
+      }
       var WhileStatement$0 = $TS($S(WhileClause, Block), function($skip, $loc, $0, $1, $2) {
         var clause = $1;
         var block = $2;
@@ -9977,13 +10045,31 @@ ${input.slice(result.pos)}
         var c = $3;
         var f = $4;
         if (!c && !f) {
+          const e = [];
+          const emptyCatchBlock = {
+            type: "BlockStatement",
+            expressions: e,
+            children: ["{", e, "}"],
+            bare: false,
+            empty: true
+          };
+          c = {
+            type: "CatchClause",
+            children: [" catch(e) ", emptyCatchBlock],
+            block: emptyCatchBlock
+          };
           return {
             type: "TryStatement",
-            children: [t, b, " catch(e) {}"]
+            blocks: [b, emptyCatchBlock],
+            children: [t, b, c]
           };
         }
+        const blocks = [b];
+        if (c)
+          blocks.push(c.block);
         return {
           type: "TryStatement",
+          blocks,
           children: [t, b, c, f]
         };
       });
@@ -10013,7 +10099,7 @@ ${input.slice(result.pos)}
         var t = $0;
         return {
           type: "TryExpression",
-          blocks: [t.children[1], t.children[2]?.[3]],
+          blocks: t.blocks,
           children: ["(()=>{", t, "})()"]
         };
       });
@@ -10039,7 +10125,14 @@ ${input.slice(result.pos)}
           return result;
         }
       }
-      var CatchClause$0 = $S($C(Samedent, _), Catch, $E(CatchBind), $C(ThenClause, BracedOrEmptyBlock));
+      var CatchClause$0 = $TS($S($C(Samedent, _), Catch, $E(CatchBind), $C(ThenClause, BracedOrEmptyBlock)), function($skip, $loc, $0, $1, $2, $3, $4) {
+        var block = $4;
+        return {
+          type: "CatchClause",
+          children: $0,
+          block
+        };
+      });
       function CatchClause(state) {
         let eventData;
         if (state.events) {
@@ -13221,7 +13314,7 @@ ${input.slice(result.pos)}
         }
       }
       var StatementDelimiter$0 = SemicolonDelimiter;
-      var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
+      var StatementDelimiter$1 = $S($Y($S(Samedent, $C($EXPECT($L2, fail, 'StatementDelimiter "("'), $EXPECT($L97, fail, 'StatementDelimiter "["'), $EXPECT($L98, fail, 'StatementDelimiter "`"'), $EXPECT($L58, fail, 'StatementDelimiter "+"'), $EXPECT($L17, fail, 'StatementDelimiter "-"'), $EXPECT($L54, fail, 'StatementDelimiter "*"'), $EXPECT($L55, fail, 'StatementDelimiter "/"'), ObjectLiteral, Arrow, FatArrow, $S(Function, $E($S($E(_), Star)), $E(_), $EXPECT($L2, fail, 'StatementDelimiter "("'))))), InsertSemicolon);
       var StatementDelimiter$2 = $Y(EOS);
       function StatementDelimiter(state) {
         let eventData;
@@ -17454,6 +17547,9 @@ ${input.slice(result.pos)}
       var TypeSuffix$1 = $T($S(QuestionMark, $E(_)), function(value) {
         return { "type": "TypeSuffix", "ts": true, "children": value };
       });
+      var TypeSuffix$2 = $T($S(NonNullAssertion, $E(_), $E($S(Colon, Type))), function(value) {
+        return { "type": "TypeSuffix", "ts": true, "children": value };
+      });
       function TypeSuffix(state) {
         let eventData;
         if (state.events) {
@@ -17465,12 +17561,12 @@ ${input.slice(result.pos)}
           }
         }
         if (state.tokenize) {
-          const result = $TOKEN("TypeSuffix", state, TypeSuffix$0(state) || TypeSuffix$1(state));
+          const result = $TOKEN("TypeSuffix", state, TypeSuffix$0(state) || TypeSuffix$1(state) || TypeSuffix$2(state));
           if (state.events)
             state.events.exit?.("TypeSuffix", state, result, eventData);
           return result;
         } else {
-          const result = TypeSuffix$0(state) || TypeSuffix$1(state);
+          const result = TypeSuffix$0(state) || TypeSuffix$1(state) || TypeSuffix$2(state);
           if (state.events)
             state.events.exit?.("TypeSuffix", state, result, eventData);
           return result;
@@ -19875,15 +19971,29 @@ ${input.slice(result.pos)}
           return post;
         };
         function expressionizeIteration(exp) {
+          const i = exp.children.indexOf(exp.block);
+          if (exp.subtype === "DoStatement") {
+            insertReturn(exp.block);
+            exp.children.splice(i, 1, "(()=>", ...exp.children, ")()");
+            return;
+          }
           const resultsRef = {
             type: "Ref",
             base: "results",
             id: "results"
           };
           insertPush(exp.block, resultsRef);
-          exp.children = ["(()=>{const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef, "})()"];
+          exp.children.splice(i, 1, "(()=>{const ", resultsRef, "=[];", ...exp.children, "; return ", resultsRef, "})()");
         }
         function wrapIterationReturningResults(statement, outerRef) {
+          if (statement.type === "DoStatement") {
+            if (outerRef) {
+              insertPush(statement.block, outerRef);
+            } else {
+              insertReturn(statement.block);
+            }
+            return;
+          }
           const resultsRef = {
             type: "Ref",
             base: "results",
@@ -19906,7 +20016,12 @@ ${input.slice(result.pos)}
             return;
           switch (node.type) {
             case "BlockStatement":
-              insertPush(node.expressions[node.expressions.length - 1], ref);
+              if (node.expressions.length) {
+                const last = node.expressions[node.expressions.length - 1];
+                insertPush(last, ref);
+              } else {
+                node.expressions.push([ref, ".push(void 0);"]);
+              }
               return;
             case "CaseBlock":
               node.clauses.forEach((clause) => {
@@ -19939,6 +20054,7 @@ ${input.slice(result.pos)}
               return;
             case "ForStatement":
             case "IterationStatement":
+            case "DoStatement":
               wrapIterationReturningResults(exp, ref);
               return;
             case "BlockStatement":
@@ -19958,9 +20074,7 @@ ${input.slice(result.pos)}
               insertPush(exp.children[2], ref);
               return;
             case "TryStatement":
-              insertPush(exp.children[1], ref);
-              if (exp.children[2])
-                insertPush(exp.children[2][2], ref);
+              exp.blocks.forEach((block) => insertPush(block, ref));
               return;
           }
           node.splice(1, 0, ref, ".push(");
@@ -19996,7 +20110,14 @@ ${input.slice(result.pos)}
             return;
           switch (node.type) {
             case "BlockStatement":
-              insertReturn(node.expressions[node.expressions.length - 1]);
+              if (node.expressions.length) {
+                const last = node.expressions[node.expressions.length - 1];
+                insertReturn(last);
+              } else {
+                if (node.parent.type === "CatchClause") {
+                  node.expressions.push(["return"]);
+                }
+              }
               return;
             case "WhenClause":
               node.children.splice(node.children.indexOf(node.break), 1);
@@ -20029,6 +20150,7 @@ ${input.slice(result.pos)}
               return;
             case "ForStatement":
             case "IterationStatement":
+            case "DoStatement":
               wrapIterationReturningResults(exp);
               return;
             case "BlockStatement":
@@ -20048,9 +20170,7 @@ ${input.slice(result.pos)}
               insertSwitchReturns(exp);
               return;
             case "TryStatement":
-              insertReturn(exp.children[1]);
-              if (exp.children[2])
-                insertReturn(exp.children[2][3]);
+              exp.blocks.forEach((block) => insertReturn(block));
               return;
           }
           if (node[node.length - 1]?.type === "SemicolonDelimiter")
@@ -20226,10 +20346,12 @@ ${input.slice(result.pos)}
           if (Array.isArray(target)) {
             if (target.length === 1) {
               return module.skipIfOnlyWS(target[0]);
+            } else if (target.every((e) => module.skipIfOnlyWS(e) === void 0)) {
+              return void 0;
             }
             return target;
           }
-          if (target.token && target.token.trim() === "") {
+          if (target.token != null && target.token.trim() === "") {
             return void 0;
           }
           return target;
@@ -20764,8 +20886,9 @@ ${input.slice(result.pos)}
         module.attachPostfixStatementAsExpression = function(exp, post) {
           let clause;
           switch (post[1].type) {
-            case "IterationStatement":
             case "ForStatement":
+            case "IterationStatement":
+            case "DoStatement":
               clause = module.addPostfixStatement(exp, ...post);
               return {
                 type: "IterationExpression",
@@ -20970,6 +21093,37 @@ ${input.slice(result.pos)}
               return pattern;
           }
         }
+        function aggregateDuplicateBindings(bindings) {
+          const props2 = gatherRecursiveAll(bindings, (n) => n.type === "BindingMatchProperty");
+          const declarations = [];
+          const propsGroupedByName = /* @__PURE__ */ new Map();
+          for (const p of props2) {
+            const { name } = p;
+            const key = name.name;
+            if (propsGroupedByName.has(key)) {
+              propsGroupedByName.get(key).push(p);
+            } else {
+              propsGroupedByName.set(key, [p]);
+            }
+          }
+          propsGroupedByName.forEach((shared, key) => {
+            if (shared.length === 1)
+              return;
+            const refs = shared.map((p) => {
+              const ref = {
+                type: "Ref",
+                base: key,
+                id: key
+              };
+              p.children.push(": ", ref);
+              return ref;
+            });
+            declarations.push(["const ", key, " = [", ...refs.map((r, i) => {
+              return i === 0 ? r : [", ", r];
+            }), "]"]);
+          });
+          return declarations;
+        }
         function processPatternMatching(statements) {
           gatherRecursiveAll(statements, (n) => n.type === "SwitchStatement" || n.type === "SwitchExpression").forEach((s) => {
             const { caseBlock } = s;
@@ -21036,10 +21190,13 @@ ${input.slice(result.pos)}
                   if (pattern.properties?.length === 0)
                     break;
                   let [splices, thisAssignments] = gatherBindingCode(pattern);
+                  const patternBindings = nonMatcherBindings(pattern);
                   splices = splices.map((s2) => [", ", nonMatcherBindings(s2)]);
                   thisAssignments = thisAssignments.map((a) => [indent, a, ";\n"]);
-                  prefix.push([indent, "const ", nonMatcherBindings(pattern), " = ", ref, splices, ";\n"]);
+                  const duplicateDeclarations = aggregateDuplicateBindings([patternBindings, splices]);
+                  prefix.push([indent, "const ", patternBindings, " = ", ref, splices, ";\n"]);
                   prefix.push(...thisAssignments);
+                  prefix.push(...duplicateDeclarations.map((d) => [indent, d, ";\n"]));
                   break;
                 }
               }
@@ -21071,10 +21228,10 @@ ${input.slice(result.pos)}
         }
         function processPipelineExpressions(statements) {
           gatherRecursiveAll(statements, (n) => n.type === "PipelineExpression").forEach((s) => {
-            const [, body] = s.children;
-            let [arg] = s.children;
+            const [ws, , body] = s.children;
+            let [, arg] = s.children;
             let i = 0, l = body.length;
-            const children = [];
+            const children = [ws];
             for (i = 0; i < l; i++) {
               const step = body[i];
               const [leadingComment, pipe, trailingComment, expr] = step;
@@ -21099,7 +21256,17 @@ ${input.slice(result.pos)}
                 returns ? arg : null
               );
               if (result.type === "ReturnStatement") {
+                if (i < l - 1) {
+                  result.children.push({
+                    type: "Error",
+                    message: "Can't continue a pipeline after returning"
+                  });
+                }
                 arg = result;
+                if (children[children.length - 1] === ",") {
+                  children.pop();
+                  children.push(";");
+                }
                 break;
               }
               if (returning) {
@@ -21530,6 +21697,36 @@ ${input.slice(result.pos)}
           return result;
         }
       }
+      var NotDedented$0 = $TS($S($E($C(Samedent, IndentedFurther)), $E(_)), function($skip, $loc, $0, $1, $2) {
+        const ws = [];
+        if ($1)
+          ws.push(...$1);
+        if ($2)
+          ws.push(...$2);
+        return ws.flat(Infinity).filter(Boolean);
+      });
+      function NotDedented(state) {
+        let eventData;
+        if (state.events) {
+          const result = state.events.enter?.("NotDedented", state);
+          if (result) {
+            if (result.cache)
+              return result.cache;
+            eventData = result.data;
+          }
+        }
+        if (state.tokenize) {
+          const result = $TOKEN("NotDedented", state, NotDedented$0(state));
+          if (state.events)
+            state.events.exit?.("NotDedented", state, result, eventData);
+          return result;
+        } else {
+          const result = NotDedented$0(state);
+          if (state.events)
+            state.events.exit?.("NotDedented", state, result, eventData);
+          return result;
+        }
+      }
       var PushIndent$0 = $Y($S(EOS, TrackIndented));
       function PushIndent(state) {
         let eventData;
@@ -22057,7 +22254,7 @@ ${input.slice(result.pos)}
   var uncacheable;
   ({ parse } = import_parser.default);
   ({ SourceMap: SourceMap2, base64Encode: base64Encode2 } = util_exports);
-  uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidIndentedApplication", "ForbidTrailingMemberProperty", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedClassSignatureElement", "NestedClassSignatureElements", "NestedDeclareElement", "NestedDeclareElements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedModuleItem", "NestedModuleItems", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
+  uncacheable = /* @__PURE__ */ new Set(["ActualAssignment", "AllowAll", "AllowIndentedApplication", "AllowTrailingMemberProperty", "AllowedTrailingMemberExpressions", "ApplicationStart", "Arguments", "ArgumentsWithTrailingMemberExpressions", "ArrowFunction", "ArrowFunctionTail", "AssignmentExpression", "AssignmentExpressionTail", "BinaryOpExpression", "BinaryOpRHS", "BracedBlock", "BracedObjectLiteralContent", "BracedOrEmptyBlock", "CallExpression", "CallExpressionRest", "CoffeeCommentEnabled", "CommaDelimiter", "ConditionalExpression", "Declaration", "Debugger", "ElseClause", "Expression", "ExpressionStatement", "ExpressionWithIndentedApplicationForbidden", "ExtendedExpression", "FatArrowBody", "ForbidIndentedApplication", "ForbidTrailingMemberProperty", "FunctionDeclaration", "FunctionExpression", "HoistableDeclaration", "ImplicitArguments", "ImplicitInlineObjectPropertyDelimiter", "ImplicitNestedBlock", "IndentedApplicationAllowed", "IndentedFurther", "IndentedJSXChildExpression", "InlineObjectLiteral", "InsertIndent", "JSXChild", "JSXChildren", "JSXElement", "JSXFragment", "JSXImplicitFragment", "JSXMixedChildren", "JSXNested", "JSXNestedChildren", "JSXOptionalClosingElement", "JSXOptionalClosingFragment", "JSXTag", "LeftHandSideExpression", "MemberExpression", "MemberExpressionRest", "Nested", "NestedBindingElement", "NestedBindingElements", "NestedBlockExpression", "NestedBlockExpression", "NestedBlockStatement", "NestedBlockStatements", "NestedClassSignatureElement", "NestedClassSignatureElements", "NestedDeclareElement", "NestedDeclareElements", "NestedElement", "NestedElementList", "NestedImplicitObjectLiteral", "NestedImplicitPropertyDefinition", "NestedImplicitPropertyDefinitions", "NestedInterfaceProperty", "NestedJSXChildExpression", "NestedModuleItem", "NestedModuleItems", "NestedObject", "NestedPropertyDefinitions", "NonSingleBracedBlock", "NotDedented", "ObjectLiteral", "PopIndent", "PopJSXStack", "PostfixedExpression", "PostfixedStatement", "PrimaryExpression", "PushIndent", "PushJSXOpeningElement", "PushJSXOpeningFragment", "RestoreAll", "RestoreIndentedApplication", "RestoreTrailingMemberProperty", "RHS", "Samedent", "ShortCircuitExpression", "SingleLineAssignmentExpression", "SingleLineComment", "SingleLineStatements", "SnugNamedProperty", "Statement", "StatementListItem", "SuffixedExpression", "SuffixedStatement", "ThinArrowFunction", "TrackIndented", "TrailingMemberExpressions", "TrailingMemberPropertyAllowed", "TypedJSXElement", "TypedJSXFragment", "UnaryExpression", "UpdateExpression"]);
   var compile = function(src, options) {
     var ast, code, events, filename, ref, result, sm, srcMapJSON;
     if (!options) {