@zenuml/core 4.2.0 → 4.3.0

package/dist/parser/index.mjs

@@ -1,5 +1,5 @@
-import o from "antlr4";
-const ke = [
+import h from "antlr4";
+const M0 = [
   4,
   0,
   80,
@@ -12070,8 +12070,8 @@ const ke = [
   4,
   0,
   0
-], it = new o.atn.ATNDeserializer().deserialize(ke), be = it.decisionToState.map((s, t) => new o.dfa.DFA(s, t));
-class a extends o.Lexer {
+], Z = new h.atn.ATNDeserializer().deserialize(M0), B0 = Z.decisionToState.map((r, t) => new h.dfa.DFA(r, t));
+class a extends h.Lexer {
   static grammarFileName = "sequenceLexer.g4";
   static channelNames = [
     "DEFAULT_TOKEN_CHANNEL",
@@ -12318,24 +12318,24 @@ class a extends o.Lexer {
     "TITLE_END"
   ];
   constructor(t) {
-    super(t), this._interp = new o.atn.LexerATNSimulator(this, it, be, new o.PredictionContextCache()), this.isTitle = function() {
+    super(t), this._interp = new h.atn.LexerATNSimulator(this, Z, B0, new h.PredictionContextCache()), this.isTitle = function() {
       const e = this._tokenStartCharIndex;
       if (this._input.getText(0, e - 1).replace(/\/\/[^\n]*(?:\n|$)/g, "").trim().length) return !1;
-      const n = 32, c = 9, x = -1, p = 46, m = 61, L = 40;
-      let A = 1, y = this._input.LA(A);
-      for (; y === n || y === c; )
-        ++A, y = this._input.LA(A);
-      return y === x || y !== p && y !== m && y !== L;
+      const n = 32, c = 9, u = -1, x = 46, C = 61, A = 40;
+      let T = 1, _ = this._input.LA(T);
+      for (; _ === n || _ === c; )
+        ++T, _ = this._input.LA(T);
+      return _ === u || _ !== x && _ !== C && _ !== A;
     }, this.isNameStartAhead = function() {
       const e = this._input.LA(1);
       return e !== -1 && /[\p{L}_]/u.test(String.fromCodePoint(e));
     };
   }
   get atn() {
-    return it;
+    return Z;
   }
 }
-a.EOF = o.Token.EOF;
+a.EOF = h.Token.EOF;
 a.WS = 1;
 a.CONSTANT = 2;
 a.READONLY = 3;
@@ -12420,23 +12420,23 @@ a.COMMENT_CHANNEL = 2;
 a.MODIFIER_CHANNEL = 3;
 a.EVENT = 1;
 a.TITLE_MODE = 2;
-a.prototype.sempred = function(s, t, e) {
+a.prototype.sempred = function(r, t, e) {
   switch (t) {
     case 6:
-      return this.TITLE_sempred(s, e);
+      return this.TITLE_sempred(r, e);
     case 61:
-      return this.THEME_DIRECTIVE_sempred(s, e);
+      return this.THEME_DIRECTIVE_sempred(r, e);
     case 66:
-      return this.FLOAT_sempred(s, e);
+      return this.FLOAT_sempred(r, e);
     case 81:
-      return this.QUOTE_COMMENT_sempred(s, e);
+      return this.QUOTE_COMMENT_sempred(r, e);
     case 83:
-      return this.DIVIDER_sempred(s, e);
+      return this.DIVIDER_sempred(r, e);
     default:
       throw "No registered predicate for:" + t;
   }
 };
-a.prototype.TITLE_sempred = function(s, t) {
+a.prototype.TITLE_sempred = function(r, t) {
   switch (t) {
     case 0:
       return this.isTitle();
@@ -12444,7 +12444,7 @@ a.prototype.TITLE_sempred = function(s, t) {
       throw "No predicate with index:" + t;
   }
 };
-a.prototype.THEME_DIRECTIVE_sempred = function(s, t) {
+a.prototype.THEME_DIRECTIVE_sempred = function(r, t) {
   switch (t) {
     case 1:
       return this._tokenStartColumn === 0;
@@ -12452,7 +12452,7 @@ a.prototype.THEME_DIRECTIVE_sempred = function(s, t) {
       throw "No predicate with index:" + t;
   }
 };
-a.prototype.FLOAT_sempred = function(s, t) {
+a.prototype.FLOAT_sempred = function(r, t) {
   switch (t) {
     case 2:
       return !this.isNameStartAhead();
@@ -12460,7 +12460,7 @@ a.prototype.FLOAT_sempred = function(s, t) {
       throw "No predicate with index:" + t;
   }
 };
-a.prototype.QUOTE_COMMENT_sempred = function(s, t) {
+a.prototype.QUOTE_COMMENT_sempred = function(r, t) {
   switch (t) {
     case 3:
       return this._tokenStartColumn === 0;
@@ -12468,7 +12468,7 @@ a.prototype.QUOTE_COMMENT_sempred = function(s, t) {
       throw "No predicate with index:" + t;
   }
 };
-a.prototype.DIVIDER_sempred = function(s, t) {
+a.prototype.DIVIDER_sempred = function(r, t) {
   switch (t) {
     case 4:
       return this._tokenStartColumn === 0;
@@ -12476,7 +12476,7 @@ a.prototype.DIVIDER_sempred = function(s, t) {
       throw "No predicate with index:" + t;
   }
 };
-class h extends o.tree.ParseTreeListener {
+class o extends h.tree.ParseTreeListener {
   // Enter a parse tree produced by sequenceParser#prog.
   enterProg(t) {
   }
@@ -12964,7 +12964,7 @@ class h extends o.tree.ParseTreeListener {
   exitTextExpr(t) {
   }
 }
-const Fe = [
+const D0 = [
   4,
   1,
   81,
@@ -19080,8 +19080,8 @@ const Fe = [
   640,
   646,
   655
-], rt = new o.atn.ATNDeserializer().deserialize(Fe), Ge = rt.decisionToState.map((s, t) => new o.dfa.DFA(s, t)), ve = new o.PredictionContextCache();
-class i extends o.Parser {
+], q = new h.atn.ATNDeserializer().deserialize(D0), P0 = q.decisionToState.map((r, t) => new h.dfa.DFA(r, t)), k0 = new h.PredictionContextCache();
+class i extends h.Parser {
   static grammarFileName = "java-escape";
   static literalNames = [
     null,
@@ -19295,15 +19295,15 @@ class i extends o.Parser {
     "textExpr"
   ];
   constructor(t) {
-    super(t), this._interp = new o.atn.ParserATNSimulator(this, rt, Ge, ve), this.ruleNames = i.ruleNames, this.literalNames = i.literalNames, this.symbolicNames = i.symbolicNames;
+    super(t), this._interp = new h.atn.ParserATNSimulator(this, q, P0, k0), this.ruleNames = i.ruleNames, this.literalNames = i.literalNames, this.symbolicNames = i.symbolicNames;
   }
   get atn() {
-    return rt;
+    return q;
   }
-  sempred(t, e, r) {
+  sempred(t, e, s) {
     switch (e) {
       case 55:
-        return this.expr_sempred(t, r);
+        return this.expr_sempred(t, s);
       default:
         throw "No predicate with index:" + e;
     }
@@ -19329,13 +19329,13 @@ class i extends o.Parser {
     }
   }
   prog() {
-    let t = new Xt(this, this._ctx, this.state);
+    let t = new Yt(this, this._ctx, this.state);
     this.enterRule(t, 0, i.RULE_prog);
     var e = 0;
     try {
       this.state = 141, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 4, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 4, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 123, this._errHandler.sync(this), e = this._input.LA(1), e === 6 && (this.state = 122, this.title()), this.state = 125, this.match(i.EOF);
           break;
@@ -19344,12 +19344,12 @@ class i extends o.Parser {
           break;
         case 3:
           this.enterOuterAlt(t, 3), this.state = 133, this._errHandler.sync(this), e = this._input.LA(1), e === 6 && (this.state = 132, this.title()), this.state = 136, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 3, this._ctx);
-          r === 1 && (this.state = 135, this.head()), this.state = 138, this.block(), this.state = 139, this.match(i.EOF);
+          var s = this._interp.adaptivePredict(this._input, 3, this._ctx);
+          s === 1 && (this.state = 135, this.head()), this.state = 138, this.block(), this.state = 139, this.match(i.EOF);
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19359,23 +19359,23 @@ class i extends o.Parser {
     return t;
   }
   title() {
-    let t = new ot(this, this._ctx, this.state);
+    let t = new it(this, this._ctx, this.state);
     this.enterRule(t, 2, i.RULE_title);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 143, this.match(i.TITLE), this.state = 145, this._errHandler.sync(this), e = this._input.LA(1), e === 79 && (this.state = 144, this.match(i.TITLE_CONTENT)), this.state = 148, this._errHandler.sync(this), e = this._input.LA(1), e === 80 && (this.state = 147, this.match(i.TITLE_END));
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   head() {
-    let t = new ht(this, this._ctx, this.state);
+    let t = new st(this, this._ctx, this.state);
     this.enterRule(t, 4, i.RULE_head);
     try {
       this.state = 164, this._errHandler.sync(this);
@@ -19383,9 +19383,9 @@ class i extends o.Parser {
       switch (e) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 152, this._errHandler.sync(this);
-          var r = 1;
+          var s = 1;
           do {
-            switch (r) {
+            switch (s) {
               case 1:
                 switch (this.state = 152, this._errHandler.sync(this), this._input.LA(1)) {
                   case 46:
@@ -19403,19 +19403,19 @@ class i extends o.Parser {
                     this.state = 151, this.participant();
                     break;
                   default:
-                    throw new o.error.NoViableAltException(this);
+                    throw new h.error.NoViableAltException(this);
                 }
                 break;
               default:
-                throw new o.error.NoViableAltException(this);
+                throw new h.error.NoViableAltException(this);
             }
-            this.state = 154, this._errHandler.sync(this), r = this._interp.adaptivePredict(this._input, 8, this._ctx);
-          } while (r != 2 && r != o.atn.ATN.INVALID_ALT_NUMBER);
+            this.state = 154, this._errHandler.sync(this), s = this._interp.adaptivePredict(this._input, 8, this._ctx);
+          } while (s != 2 && s != h.atn.ATN.INVALID_ALT_NUMBER);
           break;
         case 2:
           this.enterOuterAlt(t, 2), this.state = 160, this._errHandler.sync(this);
-          for (var r = this._interp.adaptivePredict(this._input, 10, this._ctx); r != 2 && r != o.atn.ATN.INVALID_ALT_NUMBER; ) {
-            if (r === 1)
+          for (var s = this._interp.adaptivePredict(this._input, 10, this._ctx); s != 2 && s != h.atn.ATN.INVALID_ALT_NUMBER; ) {
+            if (s === 1)
               switch (this.state = 158, this._errHandler.sync(this), this._input.LA(1)) {
                 case 46:
                   this.state = 156, this.group();
@@ -19432,15 +19432,15 @@ class i extends o.Parser {
                   this.state = 157, this.participant();
                   break;
                 default:
-                  throw new o.error.NoViableAltException(this);
+                  throw new h.error.NoViableAltException(this);
               }
-            this.state = 162, this._errHandler.sync(this), r = this._interp.adaptivePredict(this._input, 10, this._ctx);
+            this.state = 162, this._errHandler.sync(this), s = this._interp.adaptivePredict(this._input, 10, this._ctx);
           }
           this.state = 163, this.starterExp();
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19450,22 +19450,22 @@ class i extends o.Parser {
     return t;
   }
   group() {
-    let t = new k(this, this._ctx, this.state);
+    let t = new B(this, this._ctx, this.state);
     this.enterRule(t, 6, i.RULE_group);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 166, this.match(i.GROUP), this.state = 168, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 12, this._ctx);
-      r === 1 && (this.state = 167, this.name()), this.state = 180, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 15, this._ctx);
-      if (r === 1) {
+      var s = this._interp.adaptivePredict(this._input, 12, this._ctx);
+      s === 1 && (this.state = 167, this.name()), this.state = 180, this._errHandler.sync(this);
+      var s = this._interp.adaptivePredict(this._input, 15, this._ctx);
+      if (s === 1) {
         this.state = 170, this.match(i.OBRACE), this.state = 174, this._errHandler.sync(this);
-        for (var n = this._interp.adaptivePredict(this._input, 13, this._ctx); n != 2 && n != o.atn.ATN.INVALID_ALT_NUMBER; )
+        for (var n = this._interp.adaptivePredict(this._input, 13, this._ctx); n != 2 && n != h.atn.ATN.INVALID_ALT_NUMBER; )
           n === 1 && (this.state = 171, this.participant()), this.state = 176, this._errHandler.sync(this), n = this._interp.adaptivePredict(this._input, 13, this._ctx);
         this.state = 178, this._errHandler.sync(this), e = this._input.LA(1), e === 36 && (this.state = 177, this.match(i.CBRACE));
       }
     } catch (c) {
-      if (c instanceof o.error.RecognitionException)
+      if (c instanceof h.error.RecognitionException)
         t.exception = c, this._errHandler.reportError(this, c), this._errHandler.recover(this, c);
       else
         throw c;
@@ -19475,7 +19475,7 @@ class i extends o.Parser {
     return t;
   }
   starterExp() {
-    let t = new at(this, this._ctx, this.state);
+    let t = new rt(this, this._ctx, this.state);
     this.enterRule(t, 8, i.RULE_starterExp);
     var e = 0;
     try {
@@ -19487,25 +19487,25 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 2), this.state = 190, this.match(i.ANNOTATION);
           break;
         default:
-          throw new o.error.NoViableAltException(this);
+          throw new h.error.NoViableAltException(this);
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   starter() {
-    let t = new ct(this, this._ctx, this.state);
+    let t = new nt(this, this._ctx, this.state);
     this.enterRule(t, 10, i.RULE_starter);
     try {
       this.enterOuterAlt(t, 1), this.state = 193, this.name();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19515,17 +19515,17 @@ class i extends o.Parser {
     return t;
   }
   participant() {
-    let t = new O(this, this._ctx, this.state);
+    let t = new L(this, this._ctx, this.state);
     this.enterRule(t, 12, i.RULE_participant);
     var e = 0;
     try {
       this.state = 216, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 25, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 25, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 196, this._errHandler.sync(this), e = this._input.LA(1), e === 59 && (this.state = 195, this.participantType()), this.state = 199, this._errHandler.sync(this), e = this._input.LA(1), (e === 8 || e === 20) && (this.state = 198, this.stereotype()), this.state = 202, this._errHandler.sync(this), e = this._input.LA(1), (e === 13 || e === 81) && (this.state = 201, this.emoji()), this.state = 204, this.name(), this.state = 206, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 22, this._ctx);
-          r === 1 && (this.state = 205, this.width()), this.state = 209, this._errHandler.sync(this), e = this._input.LA(1), e === 51 && (this.state = 208, this.label()), this.state = 212, this._errHandler.sync(this), e = this._input.LA(1), e === 12 && (this.state = 211, this.match(i.COLOR));
+          var s = this._interp.adaptivePredict(this._input, 22, this._ctx);
+          s === 1 && (this.state = 205, this.width()), this.state = 209, this._errHandler.sync(this), e = this._input.LA(1), e === 51 && (this.state = 208, this.label()), this.state = 212, this._errHandler.sync(this), e = this._input.LA(1), e === 12 && (this.state = 211, this.match(i.COLOR));
           break;
         case 2:
           this.enterOuterAlt(t, 2), this.state = 214, this.stereotype();
@@ -19535,7 +19535,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19545,13 +19545,13 @@ class i extends o.Parser {
     return t;
   }
   stereotype() {
-    let t = new lt(this, this._ctx, this.state);
+    let t = new ht(this, this._ctx, this.state);
     this.enterRule(t, 14, i.RULE_stereotype);
     var e = 0;
     try {
       this.state = 231, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 28, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 28, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 218, this.match(i.SOPEN), this.state = 219, this.name(), this.state = 220, this.match(i.SCLOSE);
           break;
@@ -19563,7 +19563,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19573,7 +19573,7 @@ class i extends o.Parser {
     return t;
   }
   label() {
-    let t = new ut(this, this._ctx, this.state);
+    let t = new ot(this, this._ctx, this.state);
     this.enterRule(t, 16, i.RULE_label);
     try {
       this.state = 236, this._errHandler.sync(this);
@@ -19586,23 +19586,23 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 2), this.state = 235, this.match(i.AS);
           break;
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   participantType() {
-    let t = new xt(this, this._ctx, this.state);
+    let t = new at(this, this._ctx, this.state);
     this.enterRule(t, 18, i.RULE_participantType);
     try {
       this.enterOuterAlt(t, 1), this.state = 238, this.match(i.ANNOTATION);
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19612,28 +19612,28 @@ class i extends o.Parser {
     return t;
   }
   name() {
-    let t = new R(this, this._ctx, this.state);
+    let t = new d(this, this._ctx, this.state);
     this.enterRule(t, 20, i.RULE_name);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 240, e = this._input.LA(1), (e - 62 & -32) == 0 && (1 << e - 62 & 225) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   width() {
-    let t = new pt(this, this._ctx, this.state);
+    let t = new ct(this, this._ctx, this.state);
     this.enterRule(t, 22, i.RULE_width);
     try {
       this.enterOuterAlt(t, 1), this.state = 242, this.match(i.INT);
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19643,7 +19643,7 @@ class i extends o.Parser {
     return t;
   }
   emoji() {
-    let t = new I(this, this._ctx, this.state);
+    let t = new N(this, this._ctx, this.state);
     this.enterRule(t, 24, i.RULE_emoji);
     try {
       switch (this.state = 249, this._errHandler.sync(this), this._input.LA(1)) {
@@ -19654,10 +19654,10 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 2), this.state = 248, this.match(i.EMOJI_SHORTCODE);
           break;
         default:
-          throw new o.error.NoViableAltException(this);
+          throw new h.error.NoViableAltException(this);
       }
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19667,7 +19667,7 @@ class i extends o.Parser {
     return t;
   }
   block() {
-    let t = new W(this, this._ctx, this.state);
+    let t = new G(this, this._ctx, this.state);
     this.enterRule(t, 26, i.RULE_block);
     var e = 0;
     try {
@@ -19675,26 +19675,26 @@ class i extends o.Parser {
       do
         this.state = 251, this.stat(), this.state = 254, this._errHandler.sync(this), e = this._input.LA(1);
       while (e === 13 || (e - 35 & -32) == 0 && (1 << e - 35 & 4169332669) !== 0 || (e - 67 & -32) == 0 && (1 << e - 67 & 16903) !== 0);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   ret() {
-    let t = new dt(this, this._ctx, this.state);
+    let t = new lt(this, this._ctx, this.state);
     this.enterRule(t, 28, i.RULE_ret);
     var e = 0;
     try {
       switch (this.state = 272, this._errHandler.sync(this), this._input.LA(1)) {
         case 43:
           this.enterOuterAlt(t, 1), this.state = 256, this.match(i.RETURN), this.state = 258, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 32, this._ctx);
-          r === 1 && (this.state = 257, this.expr(0)), this.state = 261, this._errHandler.sync(this), e = this._input.LA(1), e === 30 && (this.state = 260, this.match(i.SCOL));
+          var s = this._interp.adaptivePredict(this._input, 32, this._ctx);
+          s === 1 && (this.state = 257, this.expr(0)), this.state = 261, this._errHandler.sync(this), e = this._input.LA(1), e === 30 && (this.state = 260, this.match(i.SCOL));
           break;
         case 58:
           this.enterOuterAlt(t, 2), this.state = 263, this.match(i.ANNOTATION_RET), this.state = 264, this.asyncMessage(), this.state = 266, this._errHandler.sync(this), e = this._input.LA(1), e === 78 && (this.state = 265, this.match(i.EVENT_END));
@@ -19708,10 +19708,10 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 3), this.state = 268, this.returnAsyncMessage(), this.state = 270, this._errHandler.sync(this), e = this._input.LA(1), e === 78 && (this.state = 269, this.match(i.EVENT_END));
           break;
         default:
-          throw new o.error.NoViableAltException(this);
+          throw new h.error.NoViableAltException(this);
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19721,24 +19721,24 @@ class i extends o.Parser {
     return t;
   }
   returnAsyncMessage() {
-    let t = new ft(this, this._ctx, this.state);
+    let t = new ut(this, this._ctx, this.state);
     this.enterRule(t, 30, i.RULE_returnAsyncMessage);
     var e = 0;
     try {
       this.state = 286, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 39, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 39, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 274, this.from(), this.state = 275, this.match(i.RETURN_ARROW), this.state = 276, this.to(), this.state = 277, this.match(i.COL), this.state = 279, this._errHandler.sync(this), e = this._input.LA(1), e === 77 && (this.state = 278, this.content());
           break;
         case 2:
           this.enterOuterAlt(t, 2), this.state = 281, this.from(), this.state = 282, this.match(i.RETURN_ARROW), this.state = 284, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 38, this._ctx);
-          r === 1 && (this.state = 283, this.to());
+          var s = this._interp.adaptivePredict(this._input, 38, this._ctx);
+          s === 1 && (this.state = 283, this.to());
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19748,12 +19748,12 @@ class i extends o.Parser {
     return t;
   }
   divider() {
-    let t = new Rt(this, this._ctx, this.state);
+    let t = new xt(this, this._ctx, this.state);
     this.enterRule(t, 32, i.RULE_divider);
     try {
       this.enterOuterAlt(t, 1), this.state = 288, this.dividerNote();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19763,12 +19763,12 @@ class i extends o.Parser {
     return t;
   }
   dividerNote() {
-    let t = new Et(this, this._ctx, this.state);
+    let t = new pt(this, this._ctx, this.state);
     this.enterRule(t, 34, i.RULE_dividerNote);
     try {
       this.enterOuterAlt(t, 1), this.state = 290, this.match(i.DIVIDER);
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -19778,13 +19778,13 @@ class i extends o.Parser {
     return t;
   }
   stat() {
-    let t = new b(this, this._ctx, this.state);
+    let t = new D(this, this._ctx, this.state);
     this.enterRule(t, 36, i.RULE_stat);
     var e = 0;
     try {
       this.state = 308, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 41, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 41, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 292, this.alt();
           break;
@@ -19826,7 +19826,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19836,13 +19836,13 @@ class i extends o.Parser {
     return t;
   }
   par() {
-    let t = new Tt(this, this._ctx, this.state);
+    let t = new dt(this, this._ctx, this.state);
     this.enterRule(t, 38, i.RULE_par);
     var e = 0;
     try {
       this.state = 316, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 43, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 43, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 310, this.match(i.PAR), this.state = 312, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 311, this.parExpr()), this.state = 314, this.braceBlock();
           break;
@@ -19851,7 +19851,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19861,13 +19861,13 @@ class i extends o.Parser {
     return t;
   }
   opt() {
-    let t = new Ct(this, this._ctx, this.state);
+    let t = new ft(this, this._ctx, this.state);
     this.enterRule(t, 40, i.RULE_opt);
     var e = 0;
     try {
       this.state = 324, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 45, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 45, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 318, this.match(i.OPT), this.state = 320, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 319, this.parExpr()), this.state = 322, this.braceBlock();
           break;
@@ -19876,7 +19876,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19886,13 +19886,13 @@ class i extends o.Parser {
     return t;
   }
   critical() {
-    let t = new _t(this, this._ctx, this.state);
+    let t = new Rt(this, this._ctx, this.state);
     this.enterRule(t, 42, i.RULE_critical);
     var e = 0;
     try {
       this.state = 332, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 47, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 47, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 326, this.match(i.CRITICAL), this.state = 328, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 327, this.parExpr()), this.state = 330, this.braceBlock();
           break;
@@ -19901,7 +19901,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19911,13 +19911,13 @@ class i extends o.Parser {
     return t;
   }
   section() {
-    let t = new At(this, this._ctx, this.state);
+    let t = new Et(this, this._ctx, this.state);
     this.enterRule(t, 44, i.RULE_section);
     var e = 0;
     try {
       this.state = 345, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 50, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 50, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 334, this.match(i.SECTION), this.state = 340, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 335, this.match(i.OPAR), this.state = 337, this._errHandler.sync(this), e = this._input.LA(1), ((e - 37 & -32) == 0 && (1 << e - 37 & 4261412871) !== 0 || e === 69) && (this.state = 336, this.atom()), this.state = 339, this.match(i.CPAR)), this.state = 342, this.braceBlock();
           break;
@@ -19929,7 +19929,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -19939,24 +19939,24 @@ class i extends o.Parser {
     return t;
   }
   creation() {
-    let t = new V(this, this._ctx, this.state);
+    let t = new v(this, this._ctx, this.state);
     this.enterRule(t, 46, i.RULE_creation);
     try {
       this.enterOuterAlt(t, 1), this.state = 347, this.creationBody(), this.state = 350, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 51, this._ctx);
       e === 1 ? (this.state = 348, this.match(i.SCOL)) : e === 2 && (this.state = 349, this.braceBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   ref() {
-    let t = new yt(this, this._ctx, this.state);
+    let t = new Tt(this, this._ctx, this.state);
     this.enterRule(t, 48, i.RULE_ref);
     var e = 0;
     try {
@@ -19966,39 +19966,39 @@ class i extends o.Parser {
         this.state = 366, this._errHandler.sync(this), e = this._input.LA(1);
       }
       this.state = 367, this.match(i.CPAR), this.state = 369, this._errHandler.sync(this), e = this._input.LA(1), e === 30 && (this.state = 368, this.match(i.SCOL));
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   creationBody() {
-    let t = new mt(this, this._ctx, this.state);
+    let t = new _t(this, this._ctx, this.state);
     this.enterRule(t, 50, i.RULE_creationBody);
     var e = 0;
     try {
       this.state = 387, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 59, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 59, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 372, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 55, this._ctx);
-          r === 1 && (this.state = 371, this.assignment()), this.state = 374, this.match(i.NEW), this.state = 375, this.construct(), this.state = 381, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 57, this._ctx);
-          r === 1 && (this.state = 376, this.match(i.OPAR), this.state = 378, this._errHandler.sync(this), e = this._input.LA(1), ((e - 13 & -32) == 0 && (1 << e - 13 & 2266040321) !== 0 || (e - 62 & -32) == 0 && (1 << e - 62 & 524543) !== 0) && (this.state = 377, this.parameters()), this.state = 380, this.match(i.CPAR));
+          var s = this._interp.adaptivePredict(this._input, 55, this._ctx);
+          s === 1 && (this.state = 371, this.assignment()), this.state = 374, this.match(i.NEW), this.state = 375, this.construct(), this.state = 381, this._errHandler.sync(this);
+          var s = this._interp.adaptivePredict(this._input, 57, this._ctx);
+          s === 1 && (this.state = 376, this.match(i.OPAR), this.state = 378, this._errHandler.sync(this), e = this._input.LA(1), ((e - 13 & -32) == 0 && (1 << e - 13 & 2266040321) !== 0 || (e - 62 & -32) == 0 && (1 << e - 62 & 524543) !== 0) && (this.state = 377, this.parameters()), this.state = 380, this.match(i.CPAR));
           break;
         case 2:
           this.enterOuterAlt(t, 2), this.state = 384, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 58, this._ctx);
-          r === 1 && (this.state = 383, this.assignment()), this.state = 386, this.match(i.NEW);
+          var s = this._interp.adaptivePredict(this._input, 58, this._ctx);
+          s === 1 && (this.state = 383, this.assignment()), this.state = 386, this.match(i.NEW);
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20008,24 +20008,24 @@ class i extends o.Parser {
     return t;
   }
   message() {
-    let t = new Lt(this, this._ctx, this.state);
+    let t = new Ct(this, this._ctx, this.state);
     this.enterRule(t, 52, i.RULE_message);
     try {
       this.enterOuterAlt(t, 1), this.state = 389, this.messageBody(), this.state = 392, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 60, this._ctx);
       e === 1 ? (this.state = 390, this.match(i.SCOL)) : e === 2 && (this.state = 391, this.braceBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   messageBody() {
-    let t = new Nt(this, this._ctx, this.state);
+    let t = new At(this, this._ctx, this.state);
     this.enterRule(t, 54, i.RULE_messageBody);
     try {
       this.state = 407, this._errHandler.sync(this);
@@ -20049,153 +20049,153 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 3), this.state = 406, this.func();
           break;
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   fromTo() {
-    let t = new gt(this, this._ctx, this.state);
+    let t = new yt(this, this._ctx, this.state);
     this.enterRule(t, 56, i.RULE_fromTo);
     try {
       this.enterOuterAlt(t, 1), this.state = 412, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 65, this._ctx);
       e === 1 && (this.state = 409, this.from(), this.state = 410, this.match(i.ARROW)), this.state = 414, this.to(), this.state = 415, this.match(i.DOT);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   func() {
-    let t = new $(this, this._ctx, this.state);
+    let t = new S(this, this._ctx, this.state);
     this.enterRule(t, 58, i.RULE_func);
     try {
       this.enterOuterAlt(t, 1), this.state = 417, this.signature(), this.state = 422, this._errHandler.sync(this);
-      for (var e = this._interp.adaptivePredict(this._input, 66, this._ctx); e != 2 && e != o.atn.ATN.INVALID_ALT_NUMBER; )
+      for (var e = this._interp.adaptivePredict(this._input, 66, this._ctx); e != 2 && e != h.atn.ATN.INVALID_ALT_NUMBER; )
         e === 1 && (this.state = 418, this.match(i.DOT), this.state = 419, this.signature()), this.state = 424, this._errHandler.sync(this), e = this._interp.adaptivePredict(this._input, 66, this._ctx);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   from() {
-    let t = new B(this, this._ctx, this.state);
+    let t = new H(this, this._ctx, this.state);
     this.enterRule(t, 60, i.RULE_from);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 426, this._errHandler.sync(this), e = this._input.LA(1), (e === 13 || e === 81) && (this.state = 425, this.emoji()), this.state = 428, this.name();
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   to() {
-    let t = new H(this, this._ctx, this.state);
+    let t = new g(this, this._ctx, this.state);
     this.enterRule(t, 62, i.RULE_to);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 431, this._errHandler.sync(this), e = this._input.LA(1), (e === 13 || e === 81) && (this.state = 430, this.emoji()), this.state = 433, this.name();
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   signature() {
-    let t = new F(this, this._ctx, this.state);
+    let t = new P(this, this._ctx, this.state);
     this.enterRule(t, 64, i.RULE_signature);
     try {
       this.enterOuterAlt(t, 1), this.state = 435, this.methodName(), this.state = 437, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 69, this._ctx);
       e === 1 && (this.state = 436, this.invocation());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   invocation() {
-    let t = new Y(this, this._ctx, this.state);
+    let t = new W(this, this._ctx, this.state);
     this.enterRule(t, 66, i.RULE_invocation);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 439, this.match(i.OPAR), this.state = 441, this._errHandler.sync(this), e = this._input.LA(1), ((e - 13 & -32) == 0 && (1 << e - 13 & 2266040321) !== 0 || (e - 62 & -32) == 0 && (1 << e - 62 & 524543) !== 0) && (this.state = 440, this.parameters()), this.state = 443, this.match(i.CPAR);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   assignment() {
-    let t = new P(this, this._ctx, this.state);
+    let t = new U(this, this._ctx, this.state);
     this.enterRule(t, 68, i.RULE_assignment);
     try {
       this.enterOuterAlt(t, 1), this.state = 446, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 71, this._ctx);
       e === 1 && (this.state = 445, this.type()), this.state = 448, this.assignee(), this.state = 449, this.match(i.ASSIGN);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   asyncMessage() {
-    let t = new Q(this, this._ctx, this.state);
+    let t = new V(this, this._ctx, this.state);
     this.enterRule(t, 70, i.RULE_asyncMessage);
     var e = 0;
     try {
       this.state = 466, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 75, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 75, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 454, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 72, this._ctx);
-          r === 1 && (this.state = 451, this.from(), this.state = 452, this.match(i.ARROW)), this.state = 456, this.to(), this.state = 457, this.match(i.COL), this.state = 459, this._errHandler.sync(this), e = this._input.LA(1), e === 77 && (this.state = 458, this.content());
+          var s = this._interp.adaptivePredict(this._input, 72, this._ctx);
+          s === 1 && (this.state = 451, this.from(), this.state = 452, this.match(i.ARROW)), this.state = 456, this.to(), this.state = 457, this.match(i.COL), this.state = 459, this._errHandler.sync(this), e = this._input.LA(1), e === 77 && (this.state = 458, this.content());
           break;
         case 2:
           this.enterOuterAlt(t, 2), this.state = 461, this.from(), this.state = 462, e = this._input.LA(1), e === 11 || e === 24 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this), this.state = 464, this._errHandler.sync(this);
-          var r = this._interp.adaptivePredict(this._input, 74, this._ctx);
-          r === 1 && (this.state = 463, this.to());
+          var s = this._interp.adaptivePredict(this._input, 74, this._ctx);
+          s === 1 && (this.state = 463, this.to());
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20205,12 +20205,12 @@ class i extends o.Parser {
     return t;
   }
   content() {
-    let t = new j(this, this._ctx, this.state);
+    let t = new $(this, this._ctx, this.state);
     this.enterRule(t, 72, i.RULE_content);
     try {
       this.enterOuterAlt(t, 1), this.state = 468, this.match(i.EVENT_PAYLOAD_LXR);
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -20220,12 +20220,12 @@ class i extends o.Parser {
     return t;
   }
   construct() {
-    let t = new Ot(this, this._ctx, this.state);
+    let t = new mt(this, this._ctx, this.state);
     this.enterRule(t, 74, i.RULE_construct);
     try {
       this.enterOuterAlt(t, 1), this.state = 470, this.name();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -20235,12 +20235,12 @@ class i extends o.Parser {
     return t;
   }
   type() {
-    let t = new K(this, this._ctx, this.state);
+    let t = new Y(this, this._ctx, this.state);
     this.enterRule(t, 76, i.RULE_type);
     try {
       this.enterOuterAlt(t, 1), this.state = 472, this.name();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -20250,13 +20250,13 @@ class i extends o.Parser {
     return t;
   }
   assignee() {
-    let t = new It(this, this._ctx, this.state);
+    let t = new Lt(this, this._ctx, this.state);
     this.enterRule(t, 78, i.RULE_assignee);
     var e = 0;
     try {
       this.state = 486, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 77, this._ctx);
-      switch (r) {
+      var s = this._interp.adaptivePredict(this._input, 77, this._ctx);
+      switch (s) {
         case 1:
           this.enterOuterAlt(t, 1), this.state = 474, this.atom();
           break;
@@ -20275,7 +20275,7 @@ class i extends o.Parser {
           break;
       }
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20285,32 +20285,32 @@ class i extends o.Parser {
     return t;
   }
   methodName() {
-    let t = new Ht(this, this._ctx, this.state);
+    let t = new Nt(this, this._ctx, this.state);
     this.enterRule(t, 80, i.RULE_methodName);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 489, this._errHandler.sync(this), e = this._input.LA(1), (e === 13 || e === 81) && (this.state = 488, this.emoji()), this.state = 491, this.name();
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   parameters() {
-    let t = new z(this, this._ctx, this.state);
+    let t = new Q(this, this._ctx, this.state);
     this.enterRule(t, 82, i.RULE_parameters);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 493, this.parameter(), this.state = 498, this._errHandler.sync(this);
-      for (var r = this._interp.adaptivePredict(this._input, 79, this._ctx); r != 2 && r != o.atn.ATN.INVALID_ALT_NUMBER; )
-        r === 1 && (this.state = 494, this.match(i.COMMA), this.state = 495, this.parameter()), this.state = 500, this._errHandler.sync(this), r = this._interp.adaptivePredict(this._input, 79, this._ctx);
+      for (var s = this._interp.adaptivePredict(this._input, 79, this._ctx); s != 2 && s != h.atn.ATN.INVALID_ALT_NUMBER; )
+        s === 1 && (this.state = 494, this.match(i.COMMA), this.state = 495, this.parameter()), this.state = 500, this._errHandler.sync(this), s = this._interp.adaptivePredict(this._input, 79, this._ctx);
       this.state = 502, this._errHandler.sync(this), e = this._input.LA(1), e === 31 && (this.state = 501, this.match(i.COMMA));
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20320,7 +20320,7 @@ class i extends o.Parser {
     return t;
   }
   parameter() {
-    let t = new G(this, this._ctx, this.state);
+    let t = new k(this, this._ctx, this.state);
     this.enterRule(t, 84, i.RULE_parameter);
     try {
       this.state = 507, this._errHandler.sync(this);
@@ -20336,73 +20336,73 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 3), this.state = 506, this.expr(0);
           break;
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   namedParameter() {
-    let t = new wt(this, this._ctx, this.state);
+    let t = new gt(this, this._ctx, this.state);
     this.enterRule(t, 86, i.RULE_namedParameter);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 509, e = this._input.LA(1), e === 62 || e === 67 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this), this.state = 510, this.match(i.ASSIGN), this.state = 512, this._errHandler.sync(this), e = this._input.LA(1), ((e - 13 & -32) == 0 && (1 << e - 13 & 2266040321) !== 0 || (e - 62 & -32) == 0 && (1 << e - 62 & 524543) !== 0) && (this.state = 511, this.expr(0));
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   declaration() {
-    let t = new Ut(this, this._ctx, this.state);
+    let t = new Ot(this, this._ctx, this.state);
     this.enterRule(t, 88, i.RULE_declaration);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 514, this.type(), this.state = 515, e = this._input.LA(1), e === 62 || e === 67 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   tcf() {
-    let t = new Mt(this, this._ctx, this.state);
+    let t = new It(this, this._ctx, this.state);
     this.enterRule(t, 90, i.RULE_tcf);
     var e = 0;
     try {
       for (this.enterOuterAlt(t, 1), this.state = 517, this.tryBlock(), this.state = 521, this._errHandler.sync(this), e = this._input.LA(1); e === 53; )
         this.state = 518, this.catchBlock(), this.state = 523, this._errHandler.sync(this), e = this._input.LA(1);
       this.state = 525, this._errHandler.sync(this), e = this._input.LA(1), e === 54 && (this.state = 524, this.finallyBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   tryBlock() {
-    let t = new Bt(this, this._ctx, this.state);
+    let t = new Ht(this, this._ctx, this.state);
     this.enterRule(t, 92, i.RULE_tryBlock);
     try {
       this.enterOuterAlt(t, 1), this.state = 527, this.match(i.TRY), this.state = 528, this.braceBlock();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -20412,28 +20412,28 @@ class i extends o.Parser {
     return t;
   }
   catchBlock() {
-    let t = new v(this, this._ctx, this.state);
+    let t = new b(this, this._ctx, this.state);
     this.enterRule(t, 94, i.RULE_catchBlock);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 530, this.match(i.CATCH), this.state = 532, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 531, this.invocation()), this.state = 534, this.braceBlock();
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   finallyBlock() {
-    let t = new Pt(this, this._ctx, this.state);
+    let t = new Ut(this, this._ctx, this.state);
     this.enterRule(t, 96, i.RULE_finallyBlock);
     try {
       this.enterOuterAlt(t, 1), this.state = 536, this.match(i.FINALLY), this.state = 537, this.braceBlock();
     } catch (e) {
-      if (e instanceof o.error.RecognitionException)
+      if (e instanceof h.error.RecognitionException)
         t.exception = e, this._errHandler.reportError(this, e), this._errHandler.recover(this, e);
       else
         throw e;
@@ -20443,16 +20443,16 @@ class i extends o.Parser {
     return t;
   }
   alt() {
-    let t = new Dt(this, this._ctx, this.state);
+    let t = new wt(this, this._ctx, this.state);
     this.enterRule(t, 98, i.RULE_alt);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 539, this.ifBlock(), this.state = 543, this._errHandler.sync(this);
-      for (var r = this._interp.adaptivePredict(this._input, 86, this._ctx); r != 2 && r != o.atn.ATN.INVALID_ALT_NUMBER; )
-        r === 1 && (this.state = 540, this.elseIfBlock()), this.state = 545, this._errHandler.sync(this), r = this._interp.adaptivePredict(this._input, 86, this._ctx);
+      for (var s = this._interp.adaptivePredict(this._input, 86, this._ctx); s != 2 && s != h.atn.ATN.INVALID_ALT_NUMBER; )
+        s === 1 && (this.state = 540, this.elseIfBlock()), this.state = 545, this._errHandler.sync(this), s = this._interp.adaptivePredict(this._input, 86, this._ctx);
       this.state = 547, this._errHandler.sync(this), e = this._input.LA(1), e === 41 && (this.state = 546, this.elseBlock());
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20462,82 +20462,82 @@ class i extends o.Parser {
     return t;
   }
   ifBlock() {
-    let t = new kt(this, this._ctx, this.state);
+    let t = new Mt(this, this._ctx, this.state);
     this.enterRule(t, 100, i.RULE_ifBlock);
     try {
       this.enterOuterAlt(t, 1), this.state = 549, this.match(i.IF), this.state = 550, this.parExpr(), this.state = 552, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 88, this._ctx);
       e === 1 && (this.state = 551, this.braceBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   elseIfBlock() {
-    let t = new S(this, this._ctx, this.state);
+    let t = new F(this, this._ctx, this.state);
     this.enterRule(t, 102, i.RULE_elseIfBlock);
     try {
       this.enterOuterAlt(t, 1), this.state = 554, this.match(i.ELSE), this.state = 555, this.match(i.IF), this.state = 556, this.parExpr(), this.state = 558, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 89, this._ctx);
       e === 1 && (this.state = 557, this.braceBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   elseBlock() {
-    let t = new bt(this, this._ctx, this.state);
+    let t = new Bt(this, this._ctx, this.state);
     this.enterRule(t, 104, i.RULE_elseBlock);
     try {
       this.enterOuterAlt(t, 1), this.state = 560, this.match(i.ELSE), this.state = 562, this._errHandler.sync(this);
       var e = this._interp.adaptivePredict(this._input, 90, this._ctx);
       e === 1 && (this.state = 561, this.braceBlock());
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   braceBlock() {
-    let t = new E(this, this._ctx, this.state);
+    let t = new f(this, this._ctx, this.state);
     this.enterRule(t, 106, i.RULE_braceBlock);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 564, this.match(i.OBRACE), this.state = 566, this._errHandler.sync(this), e = this._input.LA(1), (e === 13 || (e - 35 & -32) == 0 && (1 << e - 35 & 4169332669) !== 0 || (e - 67 & -32) == 0 && (1 << e - 67 & 16903) !== 0) && (this.state = 565, this.block()), this.state = 568, this.match(i.CBRACE);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   loop() {
-    let t = new Ft(this, this._ctx, this.state);
+    let t = new Dt(this, this._ctx, this.state);
     this.enterRule(t, 108, i.RULE_loop);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 570, this.match(i.WHILE), this.state = 572, this._errHandler.sync(this), e = this._input.LA(1), e === 33 && (this.state = 571, this.parExpr()), this.state = 575, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 93, this._ctx);
-      r === 1 && (this.state = 574, this.braceBlock());
+      var s = this._interp.adaptivePredict(this._input, 93, this._ctx);
+      s === 1 && (this.state = 574, this.braceBlock());
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20548,150 +20548,150 @@ class i extends o.Parser {
   }
   expr(t) {
     t === void 0 && (t = 0);
-    const e = this._ctx, r = this.state;
-    let n = new l(this, this._ctx, r), c = n;
-    const x = 110;
+    const e = this._ctx, s = this.state;
+    let n = new l(this, this._ctx, s), c = n;
+    const u = 110;
     this.enterRecursionRule(n, 110, i.RULE_expr, t);
-    var p = 0;
+    var x = 0;
     try {
       this.enterOuterAlt(n, 1), this.state = 597, this._errHandler.sync(this);
-      var m = this._interp.adaptivePredict(this._input, 95, this._ctx);
-      switch (m) {
+      var C = this._interp.adaptivePredict(this._input, 95, this._ctx);
+      switch (C) {
         case 1:
-          n = new qt(this, n), this._ctx = n, c = n, this.state = 578, this.atom();
+          n = new Kt(this, n), this._ctx = n, c = n, this.state = 578, this.atom();
           break;
         case 2:
-          n = new ne(this, n), this._ctx = n, c = n, this.state = 579, this.match(i.MINUS), this.state = 580, this.expr(13);
+          n = new t0(this, n), this._ctx = n, c = n, this.state = 579, this.match(i.MINUS), this.state = 580, this.expr(13);
           break;
         case 3:
-          n = new se(this, n), this._ctx = n, c = n, this.state = 581, this.match(i.NOT), this.state = 582, this.expr(12);
+          n = new qt(this, n), this._ctx = n, c = n, this.state = 581, this.match(i.NOT), this.state = 582, this.expr(12);
           break;
         case 4:
-          n = new Zt(this, n), this._ctx = n, c = n, this.state = 586, this._errHandler.sync(this);
-          var m = this._interp.adaptivePredict(this._input, 94, this._ctx);
-          m === 1 && (this.state = 583, this.to(), this.state = 584, this.match(i.DOT)), this.state = 588, this.func();
+          n = new jt(this, n), this._ctx = n, c = n, this.state = 586, this._errHandler.sync(this);
+          var C = this._interp.adaptivePredict(this._input, 94, this._ctx);
+          C === 1 && (this.state = 583, this.to(), this.state = 584, this.match(i.DOT)), this.state = 588, this.func();
           break;
         case 5:
-          n = new oe(this, n), this._ctx = n, c = n, this.state = 589, this.creation();
+          n = new e0(this, n), this._ctx = n, c = n, this.state = 589, this.creation();
           break;
         case 6:
-          n = new he(this, n), this._ctx = n, c = n, this.state = 590, this.match(i.OPAR), this.state = 591, this.expr(0), this.state = 592, this.match(i.CPAR);
+          n = new i0(this, n), this._ctx = n, c = n, this.state = 590, this.match(i.OPAR), this.state = 591, this.expr(0), this.state = 592, this.match(i.CPAR);
           break;
         case 7:
-          n = new Jt(this, n), this._ctx = n, c = n, this.state = 594, this.assignment(), this.state = 595, this.expr(1);
+          n = new Qt(this, n), this._ctx = n, c = n, this.state = 594, this.assignment(), this.state = 595, this.expr(1);
           break;
       }
       this._ctx.stop = this._input.LT(-1), this.state = 622, this._errHandler.sync(this);
-      for (var L = this._interp.adaptivePredict(this._input, 97, this._ctx); L != 2 && L != o.atn.ATN.INVALID_ALT_NUMBER; ) {
-        if (L === 1) {
+      for (var A = this._interp.adaptivePredict(this._input, 97, this._ctx); A != 2 && A != h.atn.ATN.INVALID_ALT_NUMBER; ) {
+        if (A === 1) {
           this._parseListeners !== null && this.triggerExitRuleEvent(), c = n, this.state = 620, this._errHandler.sync(this);
-          var m = this._interp.adaptivePredict(this._input, 96, this._ctx);
-          switch (m) {
+          var C = this._interp.adaptivePredict(this._input, 96, this._ctx);
+          switch (C) {
             case 1:
-              if (n = new ae(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 599, !this.precpred(this._ctx, 11))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 11)");
-              this.state = 600, n.op = this._input.LT(1), p = this._input.LA(1), (p & -32) == 0 && (1 << p & 234881024) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 601, this.expr(12);
+              if (n = new s0(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 599, !this.precpred(this._ctx, 11))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 11)");
+              this.state = 600, n.op = this._input.LT(1), x = this._input.LA(1), (x & -32) == 0 && (1 << x & 234881024) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 601, this.expr(12);
               break;
             case 2:
-              if (n = new ee(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 602, !this.precpred(this._ctx, 10))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 10)");
-              this.state = 603, n.op = this._input.LT(1), p = this._input.LA(1), p === 23 || p === 24 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 604, this.expr(11);
+              if (n = new Xt(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 602, !this.precpred(this._ctx, 10))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 10)");
+              this.state = 603, n.op = this._input.LT(1), x = this._input.LA(1), x === 23 || x === 24 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 604, this.expr(11);
               break;
             case 3:
-              if (n = new ie(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 605, !this.precpred(this._ctx, 9))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 9)");
-              this.state = 606, n.op = this._input.LT(1), p = this._input.LA(1), (p & -32) == 0 && (1 << p & 7864320) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 607, this.expr(10);
+              if (n = new Jt(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 605, !this.precpred(this._ctx, 9))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 9)");
+              this.state = 606, n.op = this._input.LT(1), x = this._input.LA(1), (x & -32) == 0 && (1 << x & 7864320) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 607, this.expr(10);
               break;
             case 4:
-              if (n = new ce(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 608, !this.precpred(this._ctx, 8))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)");
-              this.state = 609, n.op = this._input.LT(1), p = this._input.LA(1), p === 17 || p === 18 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 610, this.expr(9);
+              if (n = new r0(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 608, !this.precpred(this._ctx, 8))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 8)");
+              this.state = 609, n.op = this._input.LT(1), x = this._input.LA(1), x === 17 || x === 18 ? (this._errHandler.reportMatch(this), this.consume()) : n.op = this._errHandler.recoverInline(this), this.state = 610, this.expr(9);
               break;
             case 5:
-              if (n = new le(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 611, !this.precpred(this._ctx, 7))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)");
+              if (n = new n0(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 611, !this.precpred(this._ctx, 7))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 7)");
               this.state = 612, this.match(i.AND), this.state = 613, this.expr(8);
               break;
             case 6:
-              if (n = new te(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 614, !this.precpred(this._ctx, 6))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
+              if (n = new zt(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 614, !this.precpred(this._ctx, 6))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 6)");
               this.state = 615, this.match(i.OR), this.state = 616, this.expr(7);
               break;
             case 7:
-              if (n = new re(this, new l(this, e, r)), this.pushNewRecursionContext(n, x, i.RULE_expr), this.state = 617, !this.precpred(this._ctx, 5))
-                throw new o.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
+              if (n = new Zt(this, new l(this, e, s)), this.pushNewRecursionContext(n, u, i.RULE_expr), this.state = 617, !this.precpred(this._ctx, 5))
+                throw new h.error.FailedPredicateException(this, "this.precpred(this._ctx, 5)");
               this.state = 618, this.match(i.PLUS), this.state = 619, this.expr(6);
               break;
           }
         }
-        this.state = 624, this._errHandler.sync(this), L = this._interp.adaptivePredict(this._input, 97, this._ctx);
+        this.state = 624, this._errHandler.sync(this), A = this._interp.adaptivePredict(this._input, 97, this._ctx);
       }
-    } catch (A) {
-      if (A instanceof o.error.RecognitionException)
-        n.exception = A, this._errHandler.reportError(this, A), this._errHandler.recover(this, A);
+    } catch (T) {
+      if (T instanceof h.error.RecognitionException)
+        n.exception = T, this._errHandler.reportError(this, T), this._errHandler.recover(this, T);
       else
-        throw A;
+        throw T;
     } finally {
       this.unrollRecursionContexts(e);
     }
     return n;
   }
   atom() {
-    let t = new C(this, this._ctx, this.state);
+    let t = new R(this, this._ctx, this.state);
     this.enterRule(t, 112, i.RULE_atom);
     var e = 0;
     try {
       switch (this.state = 633, this._errHandler.sync(this), this._input.LA(1)) {
         case 63:
         case 64:
-          t = new Re(this, t), this.enterOuterAlt(t, 1), this.state = 625, e = this._input.LA(1), e === 63 || e === 64 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
+          t = new u0(this, t), this.enterOuterAlt(t, 1), this.state = 625, e = this._input.LA(1), e === 63 || e === 64 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
           break;
         case 66:
-          t = new Ee(this, t), this.enterOuterAlt(t, 2), this.state = 626, this.match(i.NUMBER_UNIT);
+          t = new x0(this, t), this.enterOuterAlt(t, 2), this.state = 626, this.match(i.NUMBER_UNIT);
           break;
         case 65:
-          t = new pe(this, t), this.enterOuterAlt(t, 3), this.state = 627, this.match(i.MONEY);
+          t = new a0(this, t), this.enterOuterAlt(t, 3), this.state = 627, this.match(i.MONEY);
           break;
         case 37:
         case 38:
-          t = new ue(this, t), this.enterOuterAlt(t, 4), this.state = 628, e = this._input.LA(1), e === 37 || e === 38 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
+          t = new h0(this, t), this.enterOuterAlt(t, 4), this.state = 628, e = this._input.LA(1), e === 37 || e === 38 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
           break;
         case 62:
-          t = new xe(this, t), this.enterOuterAlt(t, 5), this.state = 629, this.match(i.ID);
+          t = new o0(this, t), this.enterOuterAlt(t, 5), this.state = 629, this.match(i.ID);
           break;
         case 67:
-          t = new Te(this, t), this.enterOuterAlt(t, 6), this.state = 630, this.match(i.DIGIT_LEADING_NAME);
+          t = new p0(this, t), this.enterOuterAlt(t, 6), this.state = 630, this.match(i.DIGIT_LEADING_NAME);
           break;
         case 68:
         case 69:
-          t = new de(this, t), this.enterOuterAlt(t, 7), this.state = 631, e = this._input.LA(1), e === 68 || e === 69 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
+          t = new c0(this, t), this.enterOuterAlt(t, 7), this.state = 631, e = this._input.LA(1), e === 68 || e === 69 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
           break;
         case 39:
-          t = new fe(this, t), this.enterOuterAlt(t, 8), this.state = 632, this.match(i.NIL);
+          t = new l0(this, t), this.enterOuterAlt(t, 8), this.state = 632, this.match(i.NIL);
           break;
         default:
-          throw new o.error.NoViableAltException(this);
+          throw new h.error.NoViableAltException(this);
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   parExpr() {
-    let t = new N(this, this._ctx, this.state);
+    let t = new y(this, this._ctx, this.state);
     this.enterRule(t, 114, i.RULE_parExpr);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 635, this.match(i.OPAR), this.state = 637, this._errHandler.sync(this);
-      var r = this._interp.adaptivePredict(this._input, 99, this._ctx);
-      r === 1 && (this.state = 636, this.condition()), this.state = 640, this._errHandler.sync(this), e = this._input.LA(1), e === 34 && (this.state = 639, this.match(i.CPAR));
+      var s = this._interp.adaptivePredict(this._input, 99, this._ctx);
+      s === 1 && (this.state = 636, this.condition()), this.state = 640, this._errHandler.sync(this), e = this._input.LA(1), e === 34 && (this.state = 639, this.match(i.CPAR));
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20701,7 +20701,7 @@ class i extends o.Parser {
     return t;
   }
   condition() {
-    let t = new Gt(this, this._ctx, this.state);
+    let t = new Pt(this, this._ctx, this.state);
     this.enterRule(t, 116, i.RULE_condition);
     try {
       this.state = 646, this._errHandler.sync(this);
@@ -20720,51 +20720,51 @@ class i extends o.Parser {
           this.enterOuterAlt(t, 4), this.state = 645, this.textExpr();
           break;
       }
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   inExpr() {
-    let t = new vt(this, this._ctx, this.state);
+    let t = new kt(this, this._ctx, this.state);
     this.enterRule(t, 118, i.RULE_inExpr);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 648, e = this._input.LA(1), e === 62 || e === 67 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this), this.state = 649, this.match(i.IN), this.state = 650, e = this._input.LA(1), e === 62 || e === 67 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
-    } catch (r) {
-      if (r instanceof o.error.RecognitionException)
-        t.exception = r, this._errHandler.reportError(this, r), this._errHandler.recover(this, r);
+    } catch (s) {
+      if (s instanceof h.error.RecognitionException)
+        t.exception = s, this._errHandler.reportError(this, s), this._errHandler.recover(this, s);
       else
-        throw r;
+        throw s;
     } finally {
       this.exitRule();
     }
     return t;
   }
   textExpr() {
-    let t = new St(this, this._ctx, this.state);
+    let t = new bt(this, this._ctx, this.state);
     this.enterRule(t, 120, i.RULE_textExpr);
     var e = 0;
     try {
       this.enterOuterAlt(t, 1), this.state = 653, this._errHandler.sync(this);
-      var r = 1;
+      var s = 1;
       do {
-        switch (r) {
+        switch (s) {
           case 1:
             this.state = 652, e = this._input.LA(1), (e - 62 & -32) == 0 && (1 << e - 62 & 49) !== 0 ? (this._errHandler.reportMatch(this), this.consume()) : this._errHandler.recoverInline(this);
             break;
           default:
-            throw new o.error.NoViableAltException(this);
+            throw new h.error.NoViableAltException(this);
         }
-        this.state = 655, this._errHandler.sync(this), r = this._interp.adaptivePredict(this._input, 102, this._ctx);
-      } while (r != 2 && r != o.atn.ATN.INVALID_ALT_NUMBER);
+        this.state = 655, this._errHandler.sync(this), s = this._interp.adaptivePredict(this._input, 102, this._ctx);
+      } while (s != 2 && s != h.atn.ATN.INVALID_ALT_NUMBER);
     } catch (n) {
-      if (n instanceof o.error.RecognitionException)
+      if (n instanceof h.error.RecognitionException)
         t.exception = n, this._errHandler.reportError(this, n), this._errHandler.recover(this, n);
       else
         throw n;
@@ -20774,7 +20774,7 @@ class i extends o.Parser {
     return t;
   }
 }
-i.EOF = o.Token.EOF;
+i.EOF = h.Token.EOF;
 i.WS = 1;
 i.CONSTANT = 2;
 i.READONLY = 3;
@@ -20917,31 +20917,31 @@ i.RULE_parExpr = 57;
 i.RULE_condition = 58;
 i.RULE_inExpr = 59;
 i.RULE_textExpr = 60;
-let Xt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_prog;
+let Yt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_prog;
   }
   EOF() {
     return this.getToken(i.EOF, 0);
   }
   title() {
-    return this.getTypedRuleContext(ot, 0);
+    return this.getTypedRuleContext(it, 0);
   }
   head() {
-    return this.getTypedRuleContext(ht, 0);
+    return this.getTypedRuleContext(st, 0);
   }
   block() {
-    return this.getTypedRuleContext(W, 0);
+    return this.getTypedRuleContext(G, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterProg(this);
+    t instanceof o && t.enterProg(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitProg(this);
+    t instanceof o && t.exitProg(this);
   }
-}, ot = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_title;
+}, it = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_title;
   }
   TITLE() {
     return this.getToken(i.TITLE, 0);
@@ -20953,61 +20953,61 @@ let Xt = class extends o.ParserRuleContext {
     return this.getToken(i.TITLE_END, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterTitle(this);
+    t instanceof o && t.enterTitle(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitTitle(this);
+    t instanceof o && t.exitTitle(this);
   }
 };
-class ht extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_head;
+class st extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_head;
   }
   group = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(k) : this.getTypedRuleContext(k, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(B) : this.getTypedRuleContext(B, t);
   };
   participant = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(O) : this.getTypedRuleContext(O, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(L) : this.getTypedRuleContext(L, t);
   };
   starterExp() {
-    return this.getTypedRuleContext(at, 0);
+    return this.getTypedRuleContext(rt, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterHead(this);
+    t instanceof o && t.enterHead(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitHead(this);
+    t instanceof o && t.exitHead(this);
   }
 }
-class k extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_group;
+class B extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_group;
   }
   GROUP() {
     return this.getToken(i.GROUP, 0);
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   OBRACE() {
     return this.getToken(i.OBRACE, 0);
   }
   participant = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(O) : this.getTypedRuleContext(O, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(L) : this.getTypedRuleContext(L, t);
   };
   CBRACE() {
     return this.getToken(i.CBRACE, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterGroup(this);
+    t instanceof o && t.enterGroup(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitGroup(this);
+    t instanceof o && t.exitGroup(this);
   }
 }
-class at extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_starterExp;
+class rt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_starterExp;
   }
   STARTER_LXR() {
     return this.getToken(i.STARTER_LXR, 0);
@@ -21019,73 +21019,73 @@ class at extends o.ParserRuleContext {
     return this.getToken(i.CPAR, 0);
   }
   starter() {
-    return this.getTypedRuleContext(ct, 0);
+    return this.getTypedRuleContext(nt, 0);
   }
   ANNOTATION() {
     return this.getToken(i.ANNOTATION, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterStarterExp(this);
+    t instanceof o && t.enterStarterExp(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitStarterExp(this);
+    t instanceof o && t.exitStarterExp(this);
   }
 }
-class ct extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_starter;
+class nt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_starter;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterStarter(this);
+    t instanceof o && t.enterStarter(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitStarter(this);
+    t instanceof o && t.exitStarter(this);
   }
 }
-class O extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_participant;
+class L extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_participant;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   participantType() {
-    return this.getTypedRuleContext(xt, 0);
+    return this.getTypedRuleContext(at, 0);
   }
   stereotype() {
-    return this.getTypedRuleContext(lt, 0);
+    return this.getTypedRuleContext(ht, 0);
   }
   emoji() {
-    return this.getTypedRuleContext(I, 0);
+    return this.getTypedRuleContext(N, 0);
   }
   width() {
-    return this.getTypedRuleContext(pt, 0);
+    return this.getTypedRuleContext(ct, 0);
   }
   label() {
-    return this.getTypedRuleContext(ut, 0);
+    return this.getTypedRuleContext(ot, 0);
   }
   COLOR() {
     return this.getToken(i.COLOR, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterParticipant(this);
+    t instanceof o && t.enterParticipant(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParticipant(this);
+    t instanceof o && t.exitParticipant(this);
   }
 }
-class lt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_stereotype;
+class ht extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_stereotype;
   }
   SOPEN() {
     return this.getToken(i.SOPEN, 0);
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   SCLOSE() {
     return this.getToken(i.SCLOSE, 0);
@@ -21097,46 +21097,46 @@ class lt extends o.ParserRuleContext {
     return this.getToken(i.LT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterStereotype(this);
+    t instanceof o && t.enterStereotype(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitStereotype(this);
+    t instanceof o && t.exitStereotype(this);
   }
 }
-class ut extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_label;
+class ot extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_label;
   }
   AS() {
     return this.getToken(i.AS, 0);
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterLabel(this);
+    t instanceof o && t.enterLabel(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitLabel(this);
+    t instanceof o && t.exitLabel(this);
   }
 }
-class xt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_participantType;
+class at extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_participantType;
   }
   ANNOTATION() {
     return this.getToken(i.ANNOTATION, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterParticipantType(this);
+    t instanceof o && t.enterParticipantType(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParticipantType(this);
+    t instanceof o && t.exitParticipantType(this);
   }
 }
-class R extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_name;
+class d extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_name;
   }
   ID() {
     return this.getToken(i.ID, 0);
@@ -21151,35 +21151,35 @@ class R extends o.ParserRuleContext {
     return this.getToken(i.USTRING, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterName(this);
+    t instanceof o && t.enterName(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitName(this);
+    t instanceof o && t.exitName(this);
   }
 }
-class pt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_width;
+class ct extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_width;
   }
   INT() {
     return this.getToken(i.INT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterWidth(this);
+    t instanceof o && t.enterWidth(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitWidth(this);
+    t instanceof o && t.exitWidth(this);
   }
 }
-class I extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_emoji;
+class N extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_emoji;
   }
   LBRACKET() {
     return this.getToken(i.LBRACKET, 0);
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   RBRACKET() {
     return this.getToken(i.RBRACKET, 0);
@@ -21188,29 +21188,29 @@ class I extends o.ParserRuleContext {
     return this.getToken(i.EMOJI_SHORTCODE, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterEmoji(this);
+    t instanceof o && t.enterEmoji(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitEmoji(this);
+    t instanceof o && t.exitEmoji(this);
   }
 }
-class W extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_block;
+class G extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_block;
   }
   stat = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(b) : this.getTypedRuleContext(b, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(D) : this.getTypedRuleContext(D, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterBlock(this);
+    t instanceof o && t.enterBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitBlock(this);
+    t instanceof o && t.exitBlock(this);
   }
 }
-let dt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_ret;
+let lt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_ret;
   }
   RETURN() {
     return this.getToken(i.RETURN, 0);
@@ -21225,195 +21225,195 @@ let dt = class extends o.ParserRuleContext {
     return this.getToken(i.ANNOTATION_RET, 0);
   }
   asyncMessage() {
-    return this.getTypedRuleContext(Q, 0);
+    return this.getTypedRuleContext(V, 0);
   }
   EVENT_END() {
     return this.getToken(i.EVENT_END, 0);
   }
   returnAsyncMessage() {
-    return this.getTypedRuleContext(ft, 0);
+    return this.getTypedRuleContext(ut, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterRet(this);
+    t instanceof o && t.enterRet(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitRet(this);
+    t instanceof o && t.exitRet(this);
   }
-}, ft = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_returnAsyncMessage;
+}, ut = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_returnAsyncMessage;
   }
   from() {
-    return this.getTypedRuleContext(B, 0);
+    return this.getTypedRuleContext(H, 0);
   }
   RETURN_ARROW() {
     return this.getToken(i.RETURN_ARROW, 0);
   }
   to() {
-    return this.getTypedRuleContext(H, 0);
+    return this.getTypedRuleContext(g, 0);
   }
   COL() {
     return this.getToken(i.COL, 0);
   }
   content() {
-    return this.getTypedRuleContext(j, 0);
+    return this.getTypedRuleContext($, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterReturnAsyncMessage(this);
+    t instanceof o && t.enterReturnAsyncMessage(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitReturnAsyncMessage(this);
+    t instanceof o && t.exitReturnAsyncMessage(this);
   }
-}, Rt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_divider;
+}, xt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_divider;
   }
   dividerNote() {
-    return this.getTypedRuleContext(Et, 0);
+    return this.getTypedRuleContext(pt, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterDivider(this);
+    t instanceof o && t.enterDivider(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitDivider(this);
+    t instanceof o && t.exitDivider(this);
   }
 };
-class Et extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_dividerNote;
+class pt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_dividerNote;
   }
   DIVIDER() {
     return this.getToken(i.DIVIDER, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterDividerNote(this);
+    t instanceof o && t.enterDividerNote(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitDividerNote(this);
+    t instanceof o && t.exitDividerNote(this);
   }
 }
-let b = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_stat;
+let D = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_stat;
   }
   alt() {
-    return this.getTypedRuleContext(Dt, 0);
+    return this.getTypedRuleContext(wt, 0);
   }
   par() {
-    return this.getTypedRuleContext(Tt, 0);
+    return this.getTypedRuleContext(dt, 0);
   }
   opt() {
-    return this.getTypedRuleContext(Ct, 0);
+    return this.getTypedRuleContext(ft, 0);
   }
   critical() {
-    return this.getTypedRuleContext(_t, 0);
+    return this.getTypedRuleContext(Rt, 0);
   }
   section() {
-    return this.getTypedRuleContext(At, 0);
+    return this.getTypedRuleContext(Et, 0);
   }
   ref() {
-    return this.getTypedRuleContext(yt, 0);
+    return this.getTypedRuleContext(Tt, 0);
   }
   loop() {
-    return this.getTypedRuleContext(Ft, 0);
+    return this.getTypedRuleContext(Dt, 0);
   }
   creation() {
-    return this.getTypedRuleContext(V, 0);
+    return this.getTypedRuleContext(v, 0);
   }
   message() {
-    return this.getTypedRuleContext(Lt, 0);
+    return this.getTypedRuleContext(Ct, 0);
   }
   asyncMessage() {
-    return this.getTypedRuleContext(Q, 0);
+    return this.getTypedRuleContext(V, 0);
   }
   EVENT_END() {
     return this.getToken(i.EVENT_END, 0);
   }
   ret() {
-    return this.getTypedRuleContext(dt, 0);
+    return this.getTypedRuleContext(lt, 0);
   }
   divider() {
-    return this.getTypedRuleContext(Rt, 0);
+    return this.getTypedRuleContext(xt, 0);
   }
   tcf() {
-    return this.getTypedRuleContext(Mt, 0);
+    return this.getTypedRuleContext(It, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterStat(this);
+    t instanceof o && t.enterStat(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitStat(this);
+    t instanceof o && t.exitStat(this);
   }
 };
-class Tt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_par;
+class dt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_par;
   }
   PAR() {
     return this.getToken(i.PAR, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterPar(this);
+    t instanceof o && t.enterPar(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitPar(this);
+    t instanceof o && t.exitPar(this);
   }
 }
-class Ct extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_opt;
+class ft extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_opt;
   }
   OPT() {
     return this.getToken(i.OPT, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterOpt(this);
+    t instanceof o && t.enterOpt(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitOpt(this);
+    t instanceof o && t.exitOpt(this);
   }
 }
-class _t extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_critical;
+class Rt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_critical;
   }
   CRITICAL() {
     return this.getToken(i.CRITICAL, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCritical(this);
+    t instanceof o && t.enterCritical(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCritical(this);
+    t instanceof o && t.exitCritical(this);
   }
 }
-class At extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_section;
+class Et extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_section;
   }
   SECTION() {
     return this.getToken(i.SECTION, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   OPAR() {
     return this.getToken(i.OPAR, 0);
@@ -21422,37 +21422,37 @@ class At extends o.ParserRuleContext {
     return this.getToken(i.CPAR, 0);
   }
   atom() {
-    return this.getTypedRuleContext(C, 0);
+    return this.getTypedRuleContext(R, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterSection(this);
+    t instanceof o && t.enterSection(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitSection(this);
+    t instanceof o && t.exitSection(this);
   }
 }
-let V = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_creation;
+let v = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_creation;
   }
   creationBody() {
-    return this.getTypedRuleContext(mt, 0);
+    return this.getTypedRuleContext(_t, 0);
   }
   SCOL() {
     return this.getToken(i.SCOL, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCreation(this);
+    t instanceof o && t.enterCreation(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCreation(this);
+    t instanceof o && t.exitCreation(this);
   }
-}, yt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_ref;
+}, Tt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_ref;
   }
   REF() {
     return this.getToken(i.REF, 0);
@@ -21464,7 +21464,7 @@ let V = class extends o.ParserRuleContext {
     return this.getToken(i.CPAR, 0);
   }
   name = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(R) : this.getTypedRuleContext(R, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(d) : this.getTypedRuleContext(d, t);
   };
   SCOL() {
     return this.getToken(i.SCOL, 0);
@@ -21473,24 +21473,24 @@ let V = class extends o.ParserRuleContext {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.COMMA) : this.getToken(i.COMMA, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterRef(this);
+    t instanceof o && t.enterRef(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitRef(this);
+    t instanceof o && t.exitRef(this);
   }
 };
-class mt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_creationBody;
+class _t extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_creationBody;
   }
   NEW() {
     return this.getToken(i.NEW, 0);
   }
   construct() {
-    return this.getTypedRuleContext(Ot, 0);
+    return this.getTypedRuleContext(mt, 0);
   }
   assignment() {
-    return this.getTypedRuleContext(P, 0);
+    return this.getTypedRuleContext(U, 0);
   }
   OPAR() {
     return this.getToken(i.OPAR, 0);
@@ -21499,149 +21499,149 @@ class mt extends o.ParserRuleContext {
     return this.getToken(i.CPAR, 0);
   }
   parameters() {
-    return this.getTypedRuleContext(z, 0);
+    return this.getTypedRuleContext(Q, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCreationBody(this);
+    t instanceof o && t.enterCreationBody(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCreationBody(this);
+    t instanceof o && t.exitCreationBody(this);
   }
 }
-let Lt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_message;
+let Ct = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_message;
   }
   messageBody() {
-    return this.getTypedRuleContext(Nt, 0);
+    return this.getTypedRuleContext(At, 0);
   }
   SCOL() {
     return this.getToken(i.SCOL, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterMessage(this);
+    t instanceof o && t.enterMessage(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitMessage(this);
+    t instanceof o && t.exitMessage(this);
   }
 };
-class Nt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_messageBody;
+class At extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_messageBody;
   }
   assignment() {
-    return this.getTypedRuleContext(P, 0);
+    return this.getTypedRuleContext(U, 0);
   }
   fromTo() {
-    return this.getTypedRuleContext(gt, 0);
+    return this.getTypedRuleContext(yt, 0);
   }
   func() {
-    return this.getTypedRuleContext($, 0);
+    return this.getTypedRuleContext(S, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterMessageBody(this);
+    t instanceof o && t.enterMessageBody(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitMessageBody(this);
+    t instanceof o && t.exitMessageBody(this);
   }
 }
-class gt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_fromTo;
+class yt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_fromTo;
   }
   to() {
-    return this.getTypedRuleContext(H, 0);
+    return this.getTypedRuleContext(g, 0);
   }
   DOT() {
     return this.getToken(i.DOT, 0);
   }
   from() {
-    return this.getTypedRuleContext(B, 0);
+    return this.getTypedRuleContext(H, 0);
   }
   ARROW() {
     return this.getToken(i.ARROW, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterFromTo(this);
+    t instanceof o && t.enterFromTo(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitFromTo(this);
+    t instanceof o && t.exitFromTo(this);
   }
 }
-class $ extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_func;
+class S extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_func;
   }
   signature = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(F) : this.getTypedRuleContext(F, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(P) : this.getTypedRuleContext(P, t);
   };
   DOT = function(t) {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.DOT) : this.getToken(i.DOT, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterFunc(this);
+    t instanceof o && t.enterFunc(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitFunc(this);
+    t instanceof o && t.exitFunc(this);
   }
 }
-class B extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_from;
+class H extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_from;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   emoji() {
-    return this.getTypedRuleContext(I, 0);
+    return this.getTypedRuleContext(N, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterFrom(this);
+    t instanceof o && t.enterFrom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitFrom(this);
+    t instanceof o && t.exitFrom(this);
   }
 }
-class H extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_to;
+class g extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_to;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   emoji() {
-    return this.getTypedRuleContext(I, 0);
+    return this.getTypedRuleContext(N, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterTo(this);
+    t instanceof o && t.enterTo(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitTo(this);
+    t instanceof o && t.exitTo(this);
   }
 }
-class F extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_signature;
+class P extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_signature;
   }
   methodName() {
-    return this.getTypedRuleContext(Ht, 0);
+    return this.getTypedRuleContext(Nt, 0);
   }
   invocation() {
-    return this.getTypedRuleContext(Y, 0);
+    return this.getTypedRuleContext(W, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterSignature(this);
+    t instanceof o && t.enterSignature(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitSignature(this);
+    t instanceof o && t.exitSignature(this);
   }
 }
-class Y extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_invocation;
+class W extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_invocation;
   }
   OPAR() {
     return this.getToken(i.OPAR, 0);
@@ -21650,112 +21650,112 @@ class Y extends o.ParserRuleContext {
     return this.getToken(i.CPAR, 0);
   }
   parameters() {
-    return this.getTypedRuleContext(z, 0);
+    return this.getTypedRuleContext(Q, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterInvocation(this);
+    t instanceof o && t.enterInvocation(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitInvocation(this);
+    t instanceof o && t.exitInvocation(this);
   }
 }
-class P extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_assignment;
+class U extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_assignment;
   }
   assignee() {
-    return this.getTypedRuleContext(It, 0);
+    return this.getTypedRuleContext(Lt, 0);
   }
   ASSIGN() {
     return this.getToken(i.ASSIGN, 0);
   }
   type() {
-    return this.getTypedRuleContext(K, 0);
+    return this.getTypedRuleContext(Y, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAssignment(this);
+    t instanceof o && t.enterAssignment(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAssignment(this);
+    t instanceof o && t.exitAssignment(this);
   }
 }
-let Q = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_asyncMessage;
+let V = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_asyncMessage;
   }
   to() {
-    return this.getTypedRuleContext(H, 0);
+    return this.getTypedRuleContext(g, 0);
   }
   COL() {
     return this.getToken(i.COL, 0);
   }
   from() {
-    return this.getTypedRuleContext(B, 0);
+    return this.getTypedRuleContext(H, 0);
   }
   ARROW() {
     return this.getToken(i.ARROW, 0);
   }
   content() {
-    return this.getTypedRuleContext(j, 0);
+    return this.getTypedRuleContext($, 0);
   }
   MINUS() {
     return this.getToken(i.MINUS, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAsyncMessage(this);
+    t instanceof o && t.enterAsyncMessage(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAsyncMessage(this);
+    t instanceof o && t.exitAsyncMessage(this);
   }
 };
-class j extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_content;
+class $ extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_content;
   }
   EVENT_PAYLOAD_LXR() {
     return this.getToken(i.EVENT_PAYLOAD_LXR, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterContent(this);
+    t instanceof o && t.enterContent(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitContent(this);
+    t instanceof o && t.exitContent(this);
   }
 }
-class Ot extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_construct;
+class mt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_construct;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterConstruct(this);
+    t instanceof o && t.enterConstruct(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitConstruct(this);
+    t instanceof o && t.exitConstruct(this);
   }
 }
-class K extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_type;
+class Y extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_type;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterType(this);
+    t instanceof o && t.enterType(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitType(this);
+    t instanceof o && t.exitType(this);
   }
 }
-class It extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_assignee;
+class Lt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_assignee;
   }
   atom() {
-    return this.getTypedRuleContext(C, 0);
+    return this.getTypedRuleContext(R, 0);
   }
   ID = function(t) {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.ID) : this.getToken(i.ID, t);
@@ -21776,69 +21776,69 @@ class It extends o.ParserRuleContext {
     return this.getToken(i.NEW, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAssignee(this);
+    t instanceof o && t.enterAssignee(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAssignee(this);
+    t instanceof o && t.exitAssignee(this);
   }
 }
-class Ht extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_methodName;
+class Nt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_methodName;
   }
   name() {
-    return this.getTypedRuleContext(R, 0);
+    return this.getTypedRuleContext(d, 0);
   }
   emoji() {
-    return this.getTypedRuleContext(I, 0);
+    return this.getTypedRuleContext(N, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterMethodName(this);
+    t instanceof o && t.enterMethodName(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitMethodName(this);
+    t instanceof o && t.exitMethodName(this);
   }
 }
-let z = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_parameters;
+let Q = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_parameters;
   }
   parameter = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(G) : this.getTypedRuleContext(G, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(k) : this.getTypedRuleContext(k, t);
   };
   COMMA = function(t) {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.COMMA) : this.getToken(i.COMMA, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterParameters(this);
+    t instanceof o && t.enterParameters(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParameters(this);
+    t instanceof o && t.exitParameters(this);
   }
 };
-class G extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_parameter;
+class k extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_parameter;
   }
   namedParameter() {
-    return this.getTypedRuleContext(wt, 0);
+    return this.getTypedRuleContext(gt, 0);
   }
   declaration() {
-    return this.getTypedRuleContext(Ut, 0);
+    return this.getTypedRuleContext(Ot, 0);
   }
   expr() {
     return this.getTypedRuleContext(l, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterParameter(this);
+    t instanceof o && t.enterParameter(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParameter(this);
+    t instanceof o && t.exitParameter(this);
   }
 }
-class wt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_namedParameter;
+class gt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_namedParameter;
   }
   ASSIGN() {
     return this.getToken(i.ASSIGN, 0);
@@ -21853,18 +21853,18 @@ class wt extends o.ParserRuleContext {
     return this.getTypedRuleContext(l, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterNamedParameter(this);
+    t instanceof o && t.enterNamedParameter(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitNamedParameter(this);
+    t instanceof o && t.exitNamedParameter(this);
   }
 }
-class Ut extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_declaration;
+class Ot extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_declaration;
   }
   type() {
-    return this.getTypedRuleContext(K, 0);
+    return this.getTypedRuleContext(Y, 0);
   }
   ID() {
     return this.getToken(i.ID, 0);
@@ -21873,129 +21873,129 @@ class Ut extends o.ParserRuleContext {
     return this.getToken(i.DIGIT_LEADING_NAME, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterDeclaration(this);
+    t instanceof o && t.enterDeclaration(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitDeclaration(this);
+    t instanceof o && t.exitDeclaration(this);
   }
 }
-class Mt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_tcf;
+class It extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_tcf;
   }
   tryBlock() {
-    return this.getTypedRuleContext(Bt, 0);
+    return this.getTypedRuleContext(Ht, 0);
   }
   catchBlock = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(v) : this.getTypedRuleContext(v, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(b) : this.getTypedRuleContext(b, t);
   };
   finallyBlock() {
-    return this.getTypedRuleContext(Pt, 0);
+    return this.getTypedRuleContext(Ut, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterTcf(this);
+    t instanceof o && t.enterTcf(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitTcf(this);
+    t instanceof o && t.exitTcf(this);
   }
 }
-class Bt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_tryBlock;
+class Ht extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_tryBlock;
   }
   TRY() {
     return this.getToken(i.TRY, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterTryBlock(this);
+    t instanceof o && t.enterTryBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitTryBlock(this);
+    t instanceof o && t.exitTryBlock(this);
   }
 }
-class v extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_catchBlock;
+class b extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_catchBlock;
   }
   CATCH() {
     return this.getToken(i.CATCH, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   invocation() {
-    return this.getTypedRuleContext(Y, 0);
+    return this.getTypedRuleContext(W, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCatchBlock(this);
+    t instanceof o && t.enterCatchBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCatchBlock(this);
+    t instanceof o && t.exitCatchBlock(this);
   }
 }
-class Pt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_finallyBlock;
+class Ut extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_finallyBlock;
   }
   FINALLY() {
     return this.getToken(i.FINALLY, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterFinallyBlock(this);
+    t instanceof o && t.enterFinallyBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitFinallyBlock(this);
+    t instanceof o && t.exitFinallyBlock(this);
   }
 }
-class Dt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_alt;
+class wt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_alt;
   }
   ifBlock() {
-    return this.getTypedRuleContext(kt, 0);
+    return this.getTypedRuleContext(Mt, 0);
   }
   elseIfBlock = function(t) {
-    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(S) : this.getTypedRuleContext(S, t);
+    return t === void 0 && (t = null), t === null ? this.getTypedRuleContexts(F) : this.getTypedRuleContext(F, t);
   };
   elseBlock() {
-    return this.getTypedRuleContext(bt, 0);
+    return this.getTypedRuleContext(Bt, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAlt(this);
+    t instanceof o && t.enterAlt(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAlt(this);
+    t instanceof o && t.exitAlt(this);
   }
 }
-let kt = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_ifBlock;
+let Mt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_ifBlock;
   }
   IF() {
     return this.getToken(i.IF, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterIfBlock(this);
+    t instanceof o && t.enterIfBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitIfBlock(this);
+    t instanceof o && t.exitIfBlock(this);
   }
 };
-class S extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_elseIfBlock;
+class F extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_elseIfBlock;
   }
   ELSE() {
     return this.getToken(i.ELSE, 0);
@@ -22004,38 +22004,38 @@ class S extends o.ParserRuleContext {
     return this.getToken(i.IF, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterElseIfBlock(this);
+    t instanceof o && t.enterElseIfBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitElseIfBlock(this);
+    t instanceof o && t.exitElseIfBlock(this);
   }
 }
-class bt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_elseBlock;
+class Bt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_elseBlock;
   }
   ELSE() {
     return this.getToken(i.ELSE, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterElseBlock(this);
+    t instanceof o && t.enterElseBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitElseBlock(this);
+    t instanceof o && t.exitElseBlock(this);
   }
 }
-class E extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_braceBlock;
+class f extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_braceBlock;
   }
   OBRACE() {
     return this.getToken(i.OBRACE, 0);
@@ -22044,98 +22044,98 @@ class E extends o.ParserRuleContext {
     return this.getToken(i.CBRACE, 0);
   }
   block() {
-    return this.getTypedRuleContext(W, 0);
+    return this.getTypedRuleContext(G, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterBraceBlock(this);
+    t instanceof o && t.enterBraceBlock(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitBraceBlock(this);
+    t instanceof o && t.exitBraceBlock(this);
   }
 }
-let Ft = class extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_loop;
+let Dt = class extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_loop;
   }
   WHILE() {
     return this.getToken(i.WHILE, 0);
   }
   parExpr() {
-    return this.getTypedRuleContext(N, 0);
+    return this.getTypedRuleContext(y, 0);
   }
   braceBlock() {
-    return this.getTypedRuleContext(E, 0);
+    return this.getTypedRuleContext(f, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterLoop(this);
+    t instanceof o && t.enterLoop(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitLoop(this);
+    t instanceof o && t.exitLoop(this);
   }
 };
-class l extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_expr;
+class l extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_expr;
   }
   copyFrom(t) {
     super.copyFrom(t);
   }
 }
-class Jt extends l {
+class Qt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
   assignment() {
-    return this.getTypedRuleContext(P, 0);
+    return this.getTypedRuleContext(U, 0);
   }
   expr() {
     return this.getTypedRuleContext(l, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAssignmentExpr(this);
+    t instanceof o && t.enterAssignmentExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAssignmentExpr(this);
+    t instanceof o && t.exitAssignmentExpr(this);
   }
 }
-i.AssignmentExprContext = Jt;
-class Zt extends l {
+i.AssignmentExprContext = Qt;
+class jt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
   func() {
-    return this.getTypedRuleContext($, 0);
+    return this.getTypedRuleContext(S, 0);
   }
   to() {
-    return this.getTypedRuleContext(H, 0);
+    return this.getTypedRuleContext(g, 0);
   }
   DOT() {
     return this.getToken(i.DOT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterFuncExpr(this);
+    t instanceof o && t.enterFuncExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitFuncExpr(this);
+    t instanceof o && t.exitFuncExpr(this);
   }
 }
-i.FuncExprContext = Zt;
-class qt extends l {
+i.FuncExprContext = jt;
+class Kt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
   atom() {
-    return this.getTypedRuleContext(C, 0);
+    return this.getTypedRuleContext(R, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAtomExpr(this);
+    t instanceof o && t.enterAtomExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAtomExpr(this);
+    t instanceof o && t.exitAtomExpr(this);
   }
 }
-i.AtomExprContext = qt;
-class te extends l {
+i.AtomExprContext = Kt;
+class zt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22146,14 +22146,14 @@ class te extends l {
     return this.getToken(i.OR, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterOrExpr(this);
+    t instanceof o && t.enterOrExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitOrExpr(this);
+    t instanceof o && t.exitOrExpr(this);
   }
 }
-i.OrExprContext = te;
-class ee extends l {
+i.OrExprContext = zt;
+class Xt extends l {
   constructor(t, e) {
     super(t), this.op = null, super.copyFrom(e);
   }
@@ -22167,14 +22167,14 @@ class ee extends l {
     return this.getToken(i.MINUS, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAdditiveExpr(this);
+    t instanceof o && t.enterAdditiveExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAdditiveExpr(this);
+    t instanceof o && t.exitAdditiveExpr(this);
   }
 }
-i.AdditiveExprContext = ee;
-class ie extends l {
+i.AdditiveExprContext = Xt;
+class Jt extends l {
   constructor(t, e) {
     super(t), this.op = null, super.copyFrom(e);
   }
@@ -22194,14 +22194,14 @@ class ie extends l {
     return this.getToken(i.GT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterRelationalExpr(this);
+    t instanceof o && t.enterRelationalExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitRelationalExpr(this);
+    t instanceof o && t.exitRelationalExpr(this);
   }
 }
-i.RelationalExprContext = ie;
-class re extends l {
+i.RelationalExprContext = Jt;
+class Zt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22212,14 +22212,14 @@ class re extends l {
     return this.getToken(i.PLUS, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterPlusExpr(this);
+    t instanceof o && t.enterPlusExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitPlusExpr(this);
+    t instanceof o && t.exitPlusExpr(this);
   }
 }
-i.PlusExprContext = re;
-class se extends l {
+i.PlusExprContext = Zt;
+class qt extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22230,14 +22230,14 @@ class se extends l {
     return this.getTypedRuleContext(l, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterNotExpr(this);
+    t instanceof o && t.enterNotExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitNotExpr(this);
+    t instanceof o && t.exitNotExpr(this);
   }
 }
-i.NotExprContext = se;
-class ne extends l {
+i.NotExprContext = qt;
+class t0 extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22248,29 +22248,29 @@ class ne extends l {
     return this.getTypedRuleContext(l, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterUnaryMinusExpr(this);
+    t instanceof o && t.enterUnaryMinusExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitUnaryMinusExpr(this);
+    t instanceof o && t.exitUnaryMinusExpr(this);
   }
 }
-i.UnaryMinusExprContext = ne;
-class oe extends l {
+i.UnaryMinusExprContext = t0;
+class e0 extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
   creation() {
-    return this.getTypedRuleContext(V, 0);
+    return this.getTypedRuleContext(v, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCreationExpr(this);
+    t instanceof o && t.enterCreationExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCreationExpr(this);
+    t instanceof o && t.exitCreationExpr(this);
   }
 }
-i.CreationExprContext = oe;
-class he extends l {
+i.CreationExprContext = e0;
+class i0 extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22284,14 +22284,14 @@ class he extends l {
     return this.getToken(i.CPAR, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterParenthesizedExpr(this);
+    t instanceof o && t.enterParenthesizedExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParenthesizedExpr(this);
+    t instanceof o && t.exitParenthesizedExpr(this);
   }
 }
-i.ParenthesizedExprContext = he;
-class ae extends l {
+i.ParenthesizedExprContext = i0;
+class s0 extends l {
   constructor(t, e) {
     super(t), this.op = null, super.copyFrom(e);
   }
@@ -22308,14 +22308,14 @@ class ae extends l {
     return this.getToken(i.MOD, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterMultiplicationExpr(this);
+    t instanceof o && t.enterMultiplicationExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitMultiplicationExpr(this);
+    t instanceof o && t.exitMultiplicationExpr(this);
   }
 }
-i.MultiplicationExprContext = ae;
-class ce extends l {
+i.MultiplicationExprContext = s0;
+class r0 extends l {
   constructor(t, e) {
     super(t), this.op = null, super.copyFrom(e);
   }
@@ -22329,14 +22329,14 @@ class ce extends l {
     return this.getToken(i.NEQ, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterEqualityExpr(this);
+    t instanceof o && t.enterEqualityExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitEqualityExpr(this);
+    t instanceof o && t.exitEqualityExpr(this);
   }
 }
-i.EqualityExprContext = ce;
-class le extends l {
+i.EqualityExprContext = r0;
+class n0 extends l {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22347,22 +22347,22 @@ class le extends l {
     return this.getToken(i.AND, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterAndExpr(this);
+    t instanceof o && t.enterAndExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitAndExpr(this);
+    t instanceof o && t.exitAndExpr(this);
   }
 }
-i.AndExprContext = le;
-class C extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_atom;
+i.AndExprContext = n0;
+class R extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_atom;
   }
   copyFrom(t) {
     super.copyFrom(t);
   }
 }
-class ue extends C {
+class h0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22373,14 +22373,14 @@ class ue extends C {
     return this.getToken(i.FALSE, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterBooleanAtom(this);
+    t instanceof o && t.enterBooleanAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitBooleanAtom(this);
+    t instanceof o && t.exitBooleanAtom(this);
   }
 }
-i.BooleanAtomContext = ue;
-class xe extends C {
+i.BooleanAtomContext = h0;
+class o0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22388,14 +22388,14 @@ class xe extends C {
     return this.getToken(i.ID, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterIdAtom(this);
+    t instanceof o && t.enterIdAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitIdAtom(this);
+    t instanceof o && t.exitIdAtom(this);
   }
 }
-i.IdAtomContext = xe;
-class pe extends C {
+i.IdAtomContext = o0;
+class a0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22403,14 +22403,14 @@ class pe extends C {
     return this.getToken(i.MONEY, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterMoneyAtom(this);
+    t instanceof o && t.enterMoneyAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitMoneyAtom(this);
+    t instanceof o && t.exitMoneyAtom(this);
   }
 }
-i.MoneyAtomContext = pe;
-class de extends C {
+i.MoneyAtomContext = a0;
+class c0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22421,14 +22421,14 @@ class de extends C {
     return this.getToken(i.USTRING, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterStringAtom(this);
+    t instanceof o && t.enterStringAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitStringAtom(this);
+    t instanceof o && t.exitStringAtom(this);
   }
 }
-i.StringAtomContext = de;
-class fe extends C {
+i.StringAtomContext = c0;
+class l0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22436,14 +22436,14 @@ class fe extends C {
     return this.getToken(i.NIL, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterNilAtom(this);
+    t instanceof o && t.enterNilAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitNilAtom(this);
+    t instanceof o && t.exitNilAtom(this);
   }
 }
-i.NilAtomContext = fe;
-class Re extends C {
+i.NilAtomContext = l0;
+class u0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22454,14 +22454,14 @@ class Re extends C {
     return this.getToken(i.FLOAT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterNumberAtom(this);
+    t instanceof o && t.enterNumberAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitNumberAtom(this);
+    t instanceof o && t.exitNumberAtom(this);
   }
 }
-i.NumberAtomContext = Re;
-class Ee extends C {
+i.NumberAtomContext = u0;
+class x0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22469,14 +22469,14 @@ class Ee extends C {
     return this.getToken(i.NUMBER_UNIT, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterNumberUnitAtom(this);
+    t instanceof o && t.enterNumberUnitAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitNumberUnitAtom(this);
+    t instanceof o && t.exitNumberUnitAtom(this);
   }
 }
-i.NumberUnitAtomContext = Ee;
-class Te extends C {
+i.NumberUnitAtomContext = x0;
+class p0 extends R {
   constructor(t, e) {
     super(t), super.copyFrom(e);
   }
@@ -22484,59 +22484,59 @@ class Te extends C {
     return this.getToken(i.DIGIT_LEADING_NAME, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterDigitLeadingNameAtom(this);
+    t instanceof o && t.enterDigitLeadingNameAtom(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitDigitLeadingNameAtom(this);
+    t instanceof o && t.exitDigitLeadingNameAtom(this);
   }
 }
-i.DigitLeadingNameAtomContext = Te;
-class N extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_parExpr;
+i.DigitLeadingNameAtomContext = p0;
+class y extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_parExpr;
   }
   OPAR() {
     return this.getToken(i.OPAR, 0);
   }
   condition() {
-    return this.getTypedRuleContext(Gt, 0);
+    return this.getTypedRuleContext(Pt, 0);
   }
   CPAR() {
     return this.getToken(i.CPAR, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterParExpr(this);
+    t instanceof o && t.enterParExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitParExpr(this);
+    t instanceof o && t.exitParExpr(this);
   }
 }
-class Gt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_condition;
+class Pt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_condition;
   }
   atom() {
-    return this.getTypedRuleContext(C, 0);
+    return this.getTypedRuleContext(R, 0);
   }
   expr() {
     return this.getTypedRuleContext(l, 0);
   }
   inExpr() {
-    return this.getTypedRuleContext(vt, 0);
+    return this.getTypedRuleContext(kt, 0);
   }
   textExpr() {
-    return this.getTypedRuleContext(St, 0);
+    return this.getTypedRuleContext(bt, 0);
   }
   enterRule(t) {
-    t instanceof h && t.enterCondition(this);
+    t instanceof o && t.enterCondition(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitCondition(this);
+    t instanceof o && t.exitCondition(this);
   }
 }
-class vt extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_inExpr;
+class kt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_inExpr;
   }
   IN() {
     return this.getToken(i.IN, 0);
@@ -22548,15 +22548,15 @@ class vt extends o.ParserRuleContext {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.DIGIT_LEADING_NAME) : this.getToken(i.DIGIT_LEADING_NAME, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterInExpr(this);
+    t instanceof o && t.enterInExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitInExpr(this);
+    t instanceof o && t.exitInExpr(this);
   }
 }
-class St extends o.ParserRuleContext {
-  constructor(t, e, r) {
-    e === void 0 && (e = null), r == null && (r = -1), super(e, r), this.parser = t, this.ruleIndex = i.RULE_textExpr;
+class bt extends h.ParserRuleContext {
+  constructor(t, e, s) {
+    e === void 0 && (e = null), s == null && (s = -1), super(e, s), this.parser = t, this.ruleIndex = i.RULE_textExpr;
   }
   ID = function(t) {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.ID) : this.getToken(i.ID, t);
@@ -22568,74 +22568,74 @@ class St extends o.ParserRuleContext {
     return t === void 0 && (t = null), t === null ? this.getTokens(i.NUMBER_UNIT) : this.getToken(i.NUMBER_UNIT, t);
   };
   enterRule(t) {
-    t instanceof h && t.enterTextExpr(this);
+    t instanceof o && t.enterTextExpr(this);
   }
   exitRule(t) {
-    t instanceof h && t.exitTextExpr(this);
+    t instanceof o && t.exitTextExpr(this);
   }
 }
-i.ProgContext = Xt;
-i.TitleContext = ot;
-i.HeadContext = ht;
-i.GroupContext = k;
-i.StarterExpContext = at;
-i.StarterContext = ct;
-i.ParticipantContext = O;
-i.StereotypeContext = lt;
-i.LabelContext = ut;
-i.ParticipantTypeContext = xt;
-i.NameContext = R;
-i.WidthContext = pt;
-i.EmojiContext = I;
-i.BlockContext = W;
-i.RetContext = dt;
-i.ReturnAsyncMessageContext = ft;
-i.DividerContext = Rt;
-i.DividerNoteContext = Et;
-i.StatContext = b;
-i.ParContext = Tt;
-i.OptContext = Ct;
-i.CriticalContext = _t;
-i.SectionContext = At;
-i.CreationContext = V;
-i.RefContext = yt;
-i.CreationBodyContext = mt;
-i.MessageContext = Lt;
-i.MessageBodyContext = Nt;
-i.FromToContext = gt;
-i.FuncContext = $;
-i.FromContext = B;
-i.ToContext = H;
-i.SignatureContext = F;
-i.InvocationContext = Y;
-i.AssignmentContext = P;
-i.AsyncMessageContext = Q;
-i.ContentContext = j;
-i.ConstructContext = Ot;
-i.TypeContext = K;
-i.AssigneeContext = It;
-i.MethodNameContext = Ht;
-i.ParametersContext = z;
-i.ParameterContext = G;
-i.NamedParameterContext = wt;
-i.DeclarationContext = Ut;
-i.TcfContext = Mt;
-i.TryBlockContext = Bt;
-i.CatchBlockContext = v;
-i.FinallyBlockContext = Pt;
-i.AltContext = Dt;
-i.IfBlockContext = kt;
-i.ElseIfBlockContext = S;
-i.ElseBlockContext = bt;
-i.BraceBlockContext = E;
-i.LoopContext = Ft;
+i.ProgContext = Yt;
+i.TitleContext = it;
+i.HeadContext = st;
+i.GroupContext = B;
+i.StarterExpContext = rt;
+i.StarterContext = nt;
+i.ParticipantContext = L;
+i.StereotypeContext = ht;
+i.LabelContext = ot;
+i.ParticipantTypeContext = at;
+i.NameContext = d;
+i.WidthContext = ct;
+i.EmojiContext = N;
+i.BlockContext = G;
+i.RetContext = lt;
+i.ReturnAsyncMessageContext = ut;
+i.DividerContext = xt;
+i.DividerNoteContext = pt;
+i.StatContext = D;
+i.ParContext = dt;
+i.OptContext = ft;
+i.CriticalContext = Rt;
+i.SectionContext = Et;
+i.CreationContext = v;
+i.RefContext = Tt;
+i.CreationBodyContext = _t;
+i.MessageContext = Ct;
+i.MessageBodyContext = At;
+i.FromToContext = yt;
+i.FuncContext = S;
+i.FromContext = H;
+i.ToContext = g;
+i.SignatureContext = P;
+i.InvocationContext = W;
+i.AssignmentContext = U;
+i.AsyncMessageContext = V;
+i.ContentContext = $;
+i.ConstructContext = mt;
+i.TypeContext = Y;
+i.AssigneeContext = Lt;
+i.MethodNameContext = Nt;
+i.ParametersContext = Q;
+i.ParameterContext = k;
+i.NamedParameterContext = gt;
+i.DeclarationContext = Ot;
+i.TcfContext = It;
+i.TryBlockContext = Ht;
+i.CatchBlockContext = b;
+i.FinallyBlockContext = Ut;
+i.AltContext = wt;
+i.IfBlockContext = Mt;
+i.ElseIfBlockContext = F;
+i.ElseBlockContext = Bt;
+i.BraceBlockContext = f;
+i.LoopContext = Dt;
 i.ExprContext = l;
-i.AtomContext = C;
-i.ParExprContext = N;
-i.ConditionContext = Gt;
-i.InExprContext = vt;
-i.TextExprContext = St;
-class Se {
+i.AtomContext = R;
+i.ParExprContext = y;
+i.ConditionContext = Pt;
+i.InExprContext = kt;
+i.TextExprContext = bt;
+class b0 {
   name;
   // Fields the renderer-facing ParticipantView (ir/contract.ts) exposes are
   // public; they were already fully exposed via ToValue(), so the previous
@@ -22660,18 +22660,18 @@ class Se {
   mergeOptions(t) {
     const {
       stereotype: e,
-      width: r,
+      width: s,
       groupId: n,
       label: c,
-      explicit: x,
-      isStarter: p,
-      type: m,
-      color: L,
-      comment: A,
-      assignee: y,
-      emoji: M
+      explicit: u,
+      isStarter: x,
+      type: C,
+      color: A,
+      comment: T,
+      assignee: _,
+      emoji: I
     } = t;
-    this.stereotype ||= e, this.width ||= r, this.groupId ||= n, this.explicit ||= x, this.isStarter ||= p, this.label ||= c, this.type ||= m, this.color ||= L, this.comment ||= A, this.assignee ||= y, this.emoji ||= M;
+    this.stereotype ||= e, this.width ||= s, this.groupId ||= n, this.explicit ||= u, this.isStarter ||= x, this.label ||= c, this.type ||= C, this.color ||= A, this.comment ||= T, this.assignee ||= _, this.emoji ||= I;
   }
   AddPosition(t) {
     this.positions.add(t);
@@ -22695,15 +22695,15 @@ class Se {
     };
   }
 }
-class Qt {
+class St {
   participants = /* @__PURE__ */ new Map();
   Add(t, e = {}) {
     if (!t)
       throw new Error("Participant name is required");
-    let r = this.Get(t);
-    r ? r?.mergeOptions(e) : (r = new Se(t, e), this.participants.set(t, r));
+    let s = this.Get(t);
+    s ? s?.mergeOptions(e) : (s = new b0(t, e), this.participants.set(t, s));
     const { position: n, assigneePosition: c } = e;
-    n && r.AddPosition(n), c && r.assigneePositions.add(c);
+    n && s.AddPosition(n), c && s.assigneePositions.add(c);
   }
   // Returns an array of participants that are deduced from messages
   // It does not include the Starter.
@@ -22739,491 +22739,417 @@ class Qt {
     return this.participants.get(t)?.assigneePositions;
   }
 }
-let f, g = !1, Wt;
-const _ = new h(), We = function(s) {
-  if (g) return;
-  const t = s?.participantType()?.getFormattedText().replace("@", ""), e = s?.name()?.getFormattedText() || "Missing `Participant`", r = s.stereotype()?.name()?.getFormattedText(), n = s.emoji?.()?.name?.()?.getFormattedText(), c = s.width && s.width() && Number.parseInt(s.width().getText()) || void 0, x = s.label && s.label(), p = x?.name()?.getFormattedText(), m = !0, L = s.COLOR()?.getText(), A = s.getComment(), y = s.name();
-  let M, q;
-  if (x) {
-    const tt = x.name();
-    tt && (M = tt.start.start, q = tt.stop.stop + 1);
-  } else y && (M = y.start.start, q = y.stop.stop + 1);
-  f.Add(e, {
+let p, m = !1, Ft;
+const E = new o(), F0 = function(r) {
+  if (m) return;
+  const t = r?.participantType()?.getFormattedText().replace("@", ""), e = r?.name()?.getFormattedText() || "Missing `Participant`", s = r.stereotype()?.name()?.getFormattedText(), n = r.emoji?.()?.name?.()?.getFormattedText(), c = r.width && r.width() && Number.parseInt(r.width().getText()) || void 0, u = r.label && r.label(), x = u?.name()?.getFormattedText(), C = !0, A = r.COLOR()?.getText(), T = r.getComment(), _ = r.name();
+  let I, z;
+  if (u) {
+    const X = u.name();
+    X && (I = X.start.start, z = X.stop.stop + 1);
+  } else _ && (I = _.start.start, z = _.stop.stop + 1);
+  p.Add(e, {
     isStarter: !1,
     type: t,
-    stereotype: r,
+    stereotype: s,
     emoji: n,
     width: c,
-    groupId: Wt,
-    label: p,
-    explicit: m,
-    color: L,
-    comment: A,
-    position: [M, q]
+    groupId: Ft,
+    label: x,
+    explicit: C,
+    color: A,
+    comment: T,
+    position: [I, z]
   });
 };
-_.enterParticipant = We;
-const Ce = function(s) {
-  if (g) return;
-  let t = s.name?.()?.getFormattedText() || s.getFormattedText();
-  const e = s.emoji?.()?.name?.()?.getFormattedText(), r = f.Get(t);
-  if (r?.label)
-    f.Add(t, { isStarter: !1, emoji: e });
-  else if (r?.assignee) {
-    const c = [s.start.start + r.assignee.length + 2, s.stop.stop], x = [
-      s.start.start + 1,
-      s.start.start + r.assignee.length + 1
+E.enterParticipant = F0;
+const d0 = function(r) {
+  if (m) return;
+  let t = r.name?.()?.getFormattedText() || r.getFormattedText();
+  const e = r.emoji?.()?.name?.()?.getFormattedText(), s = p.Get(t);
+  if (s?.label)
+    p.Add(t, { isStarter: !1, emoji: e });
+  else if (s?.assignee) {
+    const c = [r.start.start + s.assignee.length + 2, r.stop.stop], u = [
+      r.start.start + 1,
+      r.start.start + s.assignee.length + 1
     ];
-    f.Add(t, {
+    p.Add(t, {
       isStarter: !1,
       emoji: e,
       position: c,
-      assigneePosition: x
+      assigneePosition: u
     });
   } else
-    f.Add(t, {
+    p.Add(t, {
       isStarter: !1,
       emoji: e,
-      position: [s.start.start, s.stop.stop + 1]
+      position: [r.start.start, r.stop.stop + 1]
     });
 };
-_.enterFrom = Ce;
-_.enterTo = Ce;
-_.enterStarter = function(s) {
-  let t = s.getFormattedText();
-  f.Add(t, {
+E.enterFrom = d0;
+E.enterTo = d0;
+E.enterStarter = function(r) {
+  let t = r.getFormattedText();
+  p.Add(t, {
     isStarter: !0,
-    position: [s.start.start, s.stop.stop + 1]
+    position: [r.start.start, r.stop.stop + 1]
   });
 };
-_.enterCreation = function(s) {
-  if (g) return;
-  const t = s.Owner(), e = s?.creationBody()?.construct(), r = f.Get(t);
-  if (e && !r?.label) {
-    const n = s.Assignee(), c = s.AssigneePosition();
-    f.Add(t, {
+E.enterCreation = function(r) {
+  if (m) return;
+  const t = r.Owner(), e = r?.creationBody()?.construct(), s = p.Get(t);
+  if (e && !s?.label) {
+    const n = r.Assignee(), c = r.AssigneePosition();
+    p.Add(t, {
       isStarter: !1,
       position: [e.start.start, e.stop.stop + 1],
       assignee: n,
       assigneePosition: c
     });
   } else
-    f.Add(t, {
+    p.Add(t, {
       isStarter: !1
     });
 };
-_.enterRef = function(s) {
-  s.Participants().forEach((t) => {
-    f.Add(t.getText(), {
+E.enterRef = function(r) {
+  r.Participants().forEach((t) => {
+    p.Add(t.getText(), {
       isStarter: !1,
       position: [t.start.start, t.stop.stop + 1]
     });
   });
 };
-_.enterParameters = function() {
-  g = !0;
+E.enterParameters = function() {
+  m = !0;
 };
-_.exitParameters = function() {
-  g = !1;
+E.exitParameters = function() {
+  m = !1;
 };
-_.enterCondition = function() {
-  g = !0;
+E.enterCondition = function() {
+  m = !0;
 };
-_.exitCondition = function() {
-  g = !1;
+E.exitCondition = function() {
+  m = !1;
 };
-_.enterGroup = function(s) {
-  Wt = s.name()?.getFormattedText();
+E.enterGroup = function(r) {
+  Ft = r.name()?.getFormattedText();
 };
-_.exitGroup = function() {
-  Wt = void 0;
+E.exitGroup = function() {
+  Ft = void 0;
 };
-_.enterRet = function(s) {
-  if (s.asyncMessage())
+E.enterRet = function(r) {
+  if (r.asyncMessage())
     return;
-  const t = s.From();
-  t && f.Add(t);
-  const e = s.ReturnTo();
-  e && f.Add(e);
-};
-const Ve = o.tree.ParseTreeWalker.DEFAULT, jt = /* @__PURE__ */ new WeakMap();
-_.getParticipants = function(s) {
-  if (!s) return new Qt();
-  const t = jt.get(s);
-  return t || (f = new Qt(), Ve.walk(this, s), jt.set(s, f), f);
-};
-const $e = o.tree.ParseTreeWalker.DEFAULT;
-let T = new h(), u = 0, d = 0;
-T.enterTcf = function() {
-  u++;
-};
-T.enterOpt = function() {
-  u++;
-};
-T.enterPar = function() {
-  u++;
+  const t = r.From();
+  t && p.Add(t);
+  const e = r.ReturnTo();
+  e && p.Add(e);
 };
-T.enterAlt = function() {
-  u++;
+const G0 = h.tree.ParseTreeWalker.DEFAULT, Wt = /* @__PURE__ */ new WeakMap();
+E.getParticipants = function(r) {
+  if (!r) return new St();
+  const t = Wt.get(r);
+  return t || (p = new St(), G0.walk(this, r), Wt.set(r, p), p);
 };
-T.enterLoop = function() {
-  u++;
-};
-T.enterSection = function() {
-  u++;
-};
-T.enterCritical = function() {
-  u++;
-};
-T.exitTcf = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitOpt = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitPar = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitAlt = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitLoop = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitSection = function() {
-  d = Math.max(d, u), u--;
-};
-T.exitCritical = function() {
-  d = Math.max(d, u), u--;
-};
-T.depth = function(s) {
-  return function(t) {
-    return u = 0, d = 0, t.children.map(function(e) {
-      $e.walk(s, e);
-    }), d;
-  };
-};
-const Ye = i, Qe = Ye.TitleContext;
-Qe.prototype.content = function() {
+const v0 = i, S0 = v0.TitleContext;
+S0.prototype.content = function() {
   return this.children.length < 2 ? "" : this.children[1].getText().trim();
 };
-const _e = i, st = _e.CreationContext;
-st.prototype.Body = st.prototype.creationBody;
-st.prototype.isCurrent = function(s) {
-  return Ae.bind(this)(s);
+const f0 = i, tt = f0.CreationContext;
+tt.prototype.Body = tt.prototype.creationBody;
+tt.prototype.isCurrent = function(r) {
+  return R0.bind(this)(r);
 };
-const nt = _e.MessageContext;
-nt.prototype.Body = nt.prototype.messageBody;
-nt.prototype.isCurrent = function(s) {
-  return Ae.bind(this)(s);
+const et = f0.MessageContext;
+et.prototype.Body = et.prototype.messageBody;
+et.prototype.isCurrent = function(r) {
+  return R0.bind(this)(r);
 };
-function Ae(s) {
+function R0(r) {
   try {
-    if (s == null) return !1;
+    if (r == null) return !1;
     const t = this.start.start, e = this.Body().stop.stop + 1;
-    return s >= t && s <= e;
+    return r >= t && r <= e;
   } catch {
     return !1;
   }
 }
-const D = i, w = D.CreationContext, Vt = D.MessageContext, ye = D.AsyncMessageContext, me = D.ReturnAsyncMessageContext, Le = D.RetContext;
-w.prototype.Assignee = function() {
+const w = i, M = w.CreationContext, Gt = w.MessageContext, E0 = w.AsyncMessageContext, T0 = w.ReturnAsyncMessageContext, _0 = w.RetContext;
+M.prototype.Assignee = function() {
   return this.creationBody()?.assignment()?.assignee()?.getFormattedText();
 };
-w.prototype.AssigneePosition = function() {
-  const s = this.creationBody()?.assignment()?.assignee();
-  if (s)
-    return [s.start.start, s.stop.stop + 1];
+M.prototype.AssigneePosition = function() {
+  const r = this.creationBody()?.assignment()?.assignee();
+  if (r)
+    return [r.start.start, r.stop.stop + 1];
 };
-w.prototype.Constructor = function() {
+M.prototype.Constructor = function() {
   return this.creationBody()?.construct()?.getFormattedText();
 };
-w.prototype.To = function() {
-  return this.Constructor();
-};
-w.prototype.Owner = function() {
+M.prototype.Owner = function() {
   if (!this.Constructor())
     return "Missing Constructor";
-  const s = this.Assignee(), t = this.Constructor();
-  return s ? `${s}:${t}` : t;
-};
-Vt.prototype.To = function() {
-  const s = this.messageBody()?.fromTo()?.to();
-  return s?.name?.()?.getFormattedText() || s?.getFormattedText();
+  const r = this.Assignee(), t = this.Constructor();
+  return r ? `${r}:${t}` : t;
 };
-Vt.prototype.Owner = function() {
-  return this.To() || X(this.parentCtx);
+Gt.prototype.To = function() {
+  const r = this.messageBody()?.fromTo()?.to();
+  return r?.name?.()?.getFormattedText() || r?.getFormattedText();
 };
-function X(s) {
-  for (; s; ) {
-    if (s instanceof w || s instanceof Vt)
-      return s.Owner();
-    s = s.parentCtx;
+function W0(r) {
+  for (; r; ) {
+    if (r instanceof M || r instanceof Gt)
+      return r.Owner();
+    r = r.parentCtx;
   }
 }
-ye.prototype.To = function() {
-  const s = this.to();
-  return s?.name?.()?.getFormattedText() || s?.getFormattedText();
-};
-ye.prototype.Owner = function() {
-  return this.To() || X(this.parentCtx);
-};
-me.prototype.To = function() {
-  const s = this.to();
-  return s?.name?.()?.getFormattedText() || s?.getFormattedText();
-};
-me.prototype.Owner = function() {
-  return this.To() || X(this.parentCtx);
-};
-Le.prototype.To = function() {
+function V0() {
+  return this.To() || W0(this.parentCtx);
+}
+[
+  Gt,
+  E0,
+  T0,
+  _0
+].forEach((r) => {
+  r.prototype.Owner = V0;
+});
+function C0() {
+  const r = this.to();
+  return r?.name?.()?.getFormattedText() || r?.getFormattedText();
+}
+E0.prototype.To = C0;
+T0.prototype.To = C0;
+_0.prototype.To = function() {
   return this.ReturnTo();
 };
-Le.prototype.Owner = function() {
-  return this.To() || X(this.parentCtx);
-};
-const je = i.ProgContext;
-je.prototype.Starter = function() {
+const $0 = i.ProgContext;
+$0.prototype.Starter = function() {
   return this.head()?.starterExp()?.starter()?.getFormattedText();
 };
-const J = i, Ne = J.RetContext, Kt = J.ProgContext, zt = J.MessageContext, Ke = J.CreationContext;
-Ne.prototype.Signature = function() {
+const j = i, A0 = j.RetContext, Vt = j.ProgContext, $t = j.MessageContext, Y0 = j.CreationContext;
+A0.prototype.Signature = function() {
   return this.asyncMessage()?.content()?.getFormattedText() || this.returnAsyncMessage()?.content()?.getFormattedText() || this.expr()?.getFormattedText();
 };
-Ne.prototype.ReturnTo = function() {
-  const s = this.asyncMessage()?.to() || this.returnAsyncMessage()?.to(), t = s?.name?.()?.getFormattedText() || s?.getFormattedText();
+A0.prototype.ReturnTo = function() {
+  const r = this.asyncMessage()?.to() || this.returnAsyncMessage()?.to(), t = r?.name?.()?.getFormattedText() || r?.getFormattedText();
   if (t)
     return t;
   const n = this.parentCtx.parentCtx.parentCtx;
-  if (n instanceof Kt)
+  if (n instanceof Vt)
     return n.Starter();
   {
     let c = n;
-    for (; c && !(c instanceof zt) && !(c instanceof Ke); ) {
-      if (c instanceof Kt)
+    for (; c && !(c instanceof $t) && !(c instanceof Y0); ) {
+      if (c instanceof Vt)
         return c.Starter();
       c = c.parentCtx;
     }
-    return c instanceof zt && (c.messageBody()?.fromTo()?.from()?.name?.()?.getFormattedText() || c.messageBody()?.fromTo()?.from()?.getFormattedText()) || c.ClosestAncestorStat().Origin();
+    return c instanceof $t && (c.messageBody()?.fromTo()?.from()?.name?.()?.getFormattedText() || c.messageBody()?.fromTo()?.from()?.getFormattedText()) || c.ClosestAncestorStat().Origin();
   }
 };
-const ze = i, ge = ze.RefContext;
-function Xe(s) {
-  return !s || !s.start || !s.stop ? !0 : s.stop.tokenIndex < s.start.tokenIndex;
+const Q0 = i, y0 = Q0.RefContext;
+function j0(r) {
+  return !r || !r.start || !r.stop ? !0 : r.stop.tokenIndex < r.start.tokenIndex;
 }
-ge.prototype.Content = function() {
-  const s = this.name()[0];
-  return Xe(s) ? void 0 : s;
+y0.prototype.Content = function() {
+  const r = this.name()[0];
+  return j0(r) ? void 0 : r;
 };
-ge.prototype.Participants = function() {
+y0.prototype.Participants = function() {
   return this.name().slice(1) ?? [];
 };
-const Je = o.ParserRuleContext, Oe = i.StatContext, $t = i.ProgContext, Ze = i.MessageContext, qe = i.CreationContext;
-Je.prototype.Origin = function() {
-  let s = this.parentCtx;
-  for (; s && !(s instanceof Oe || s instanceof $t); )
-    s = this.parentCtx;
-  return s.Origin();
+const K0 = h.ParserRuleContext, z0 = i.StatContext, m0 = i.ProgContext, X0 = i.MessageContext, J0 = i.CreationContext;
+K0.prototype.Origin = function() {
+  return this.ClosestAncestorStat()?.Origin();
 };
-Oe.prototype.Origin = function() {
-  let s = this.parentCtx;
-  for (; s; ) {
-    if (s instanceof $t)
-      return s.Starter();
-    if (s instanceof Ze || s instanceof qe) {
-      const t = s.Owner();
+z0.prototype.Origin = function() {
+  let r = this.parentCtx;
+  for (; r; ) {
+    if (r instanceof m0)
+      return r.Starter();
+    if (r instanceof X0 || r instanceof J0) {
+      const t = r.Owner();
       if (t)
         return t;
     }
-    s = s.parentCtx;
+    r = r.parentCtx;
   }
 };
-$t.prototype.Origin = function() {
+m0.prototype.Origin = function() {
   return this.Starter();
 };
-const t0 = i, e0 = t0.DividerContext;
-e0.prototype.Note = function() {
-  const s = this.dividerNote()?.getFormattedText().trim();
-  if (!s.startsWith("=="))
+const Z0 = i, q0 = Z0.DividerContext;
+q0.prototype.Note = function() {
+  const r = this.dividerNote()?.getFormattedText().trim();
+  if (!r.startsWith("=="))
     throw new Error("Divider note must start with ==");
-  return s?.replace(/^=+|=+$/g, "");
+  return r?.replace(/^=+|=+$/g, "");
 };
-function i0(s) {
-  if (s.namedParameter?.()) {
-    const e = s.namedParameter();
+function te(r) {
+  if (r.namedParameter?.()) {
+    const e = r.namedParameter();
     if (e) {
-      const r = e.expr(), n = r ? r.getFormattedText() : "";
+      const s = e.expr(), n = s ? s.getFormattedText() : "";
       return `${e.ID().getText()}=${n}`;
     }
   }
-  if (s.declaration?.()) {
-    const e = s.declaration();
+  if (r.declaration?.()) {
+    const e = r.declaration();
     if (e)
       return `${e.type().getText()} ${e.ID().getText()}`;
   }
-  const t = s.expr?.();
-  return t ? t.getFormattedText() : s.getFormattedText();
+  const t = r.expr?.();
+  return t ? t.getFormattedText() : r.getFormattedText();
 }
-function Ie(s) {
-  return s.map(i0).join(",");
+function L0(r) {
+  return r.map(te).join(",");
 }
-const r0 = i.MessageContext, s0 = i.ParametersContext, n0 = i.AsyncMessageContext, Yt = i.CreationContext, o0 = i.RetContext, h0 = i.ReturnAsyncMessageContext;
-r0.prototype.SignatureText = function() {
-  return this.messageBody()?.func()?.signature()?.map((s) => s?.getFormattedText()).join(".") ?? "";
+const ee = i.MessageContext, ie = i.ParametersContext, se = i.AsyncMessageContext, N0 = i.CreationContext, re = i.RetContext, ne = i.ReturnAsyncMessageContext;
+ee.prototype.SignatureText = function() {
+  return this.messageBody()?.func()?.signature()?.map((r) => r?.getFormattedText()).join(".") ?? "";
 };
-n0.prototype.SignatureText = function() {
+se.prototype.SignatureText = function() {
   return this.content()?.getFormattedText() ?? "";
 };
-Yt.prototype.ParametersText = function() {
-  const s = this.creationBody().parameters();
-  return s?.parameter()?.length > 0 ? Ie(s.parameter()) : "";
+N0.prototype.ParametersText = function() {
+  const r = this.creationBody().parameters();
+  return r?.parameter()?.length > 0 ? L0(r.parameter()) : "";
 };
-Yt.prototype.SignatureText = function() {
+N0.prototype.SignatureText = function() {
   return `«${this.ParametersText() || "create"}»`;
 };
-Yt.prototype.isParamValid = function() {
-  return (this.creationBody().parameters()?.parameter()?.length ?? 0) > 0;
-};
-o0.prototype.SignatureText = function() {
+re.prototype.SignatureText = function() {
   return this.asyncMessage()?.content()?.getFormattedText() ?? this.returnAsyncMessage()?.content()?.getFormattedText() ?? this.expr()?.getFormattedText() ?? "";
 };
-h0.prototype.SignatureText = function() {
+ne.prototype.SignatureText = function() {
   return this.content()?.getFormattedText() ?? "";
 };
-s0.prototype.getFormattedText = function() {
-  const s = this.parameter();
-  return !s || s.length === 0 ? "" : Ie(s);
+ie.prototype.getFormattedText = function() {
+  const r = this.parameter();
+  return !r || r.length === 0 ? "" : L0(r);
 };
-const He = i, a0 = He.MessageContext, c0 = He.CreationContext;
-class l0 {
+const g0 = i, he = g0.MessageContext, oe = g0.CreationContext;
+class ae {
   assignee;
   type;
   labelPosition;
   assigneePosition;
   typePosition;
-  constructor(t, e, r, n) {
+  constructor(t, e, s, n) {
     if (e && !t)
       throw new Error("assignee must be defined if type is defined");
-    this.assignee = t || "", this.type = e || "", this.labelPosition = r, this.assigneePosition = r, this.typePosition = n;
+    this.assignee = t || "", this.type = e || "", this.labelPosition = s, this.assigneePosition = s, this.typePosition = n;
   }
   getText() {
     return [this.assignee, this.type].filter(Boolean).join(":");
   }
 }
-function we(s) {
-  if (!s)
+function O0(r) {
+  if (!r)
     return;
-  const t = s?.assignee()?.getFormattedText(), e = s?.type()?.getFormattedText(), r = s?.assignee(), n = r ? [r.start.start, r.stop.stop] : [-1, -1], c = s?.type(), x = c ? [c.start.start, c.stop.stop] : [-1, -1];
+  const t = r?.assignee()?.getFormattedText(), e = r?.type()?.getFormattedText(), s = r?.assignee(), n = s ? [s.start.start, s.stop.stop] : [-1, -1], c = r?.type(), u = c ? [c.start.start, c.stop.stop] : [-1, -1];
   if (t)
-    return new l0(t, e, n, x);
+    return new ae(t, e, n, u);
 }
-a0.prototype.Assignment = function() {
-  return we(this.messageBody().assignment());
+he.prototype.Assignment = function() {
+  return O0(this.messageBody().assignment());
 };
-c0.prototype.Assignment = function() {
-  return we(this.creationBody()?.assignment());
+oe.prototype.Assignment = function() {
+  return O0(this.creationBody()?.assignment());
 };
-const Z = i, u0 = Z.MessageContext, x0 = Z.CreationContext, p0 = Z.IfBlockContext, d0 = Z.LoopContext;
-u0.prototype.Statements = function() {
+const K = i, ce = K.MessageContext, le = K.CreationContext, ue = K.IfBlockContext, xe = K.LoopContext;
+ce.prototype.Statements = function() {
   return this.braceBlock()?.block()?.stat() || [];
 };
-x0.prototype.Statements = function() {
+le.prototype.Statements = function() {
   return this.braceBlock()?.block()?.stat() || [];
 };
-p0.prototype.Statements = function() {
+ue.prototype.Statements = function() {
   return this.braceBlock()?.block()?.stat() || [];
 };
-d0.prototype.Statements = function() {
+xe.prototype.Statements = function() {
   return this.braceBlock()?.block()?.stat() || [];
 };
-const U = i, f0 = U.StatContext, R0 = U.CreationContext, Ue = U.MessageContext, Me = U.AsyncMessageContext, Be = U.ReturnAsyncMessageContext, E0 = U.RetContext;
-R0.prototype.From = function() {
-  if (this.parentCtx instanceof f0)
+const O = i, pe = O.StatContext, de = O.CreationContext, I0 = O.MessageContext, H0 = O.AsyncMessageContext, U0 = O.ReturnAsyncMessageContext, fe = O.RetContext;
+de.prototype.From = function() {
+  if (this.parentCtx instanceof pe)
     return this.ClosestAncestorStat()?.Origin();
 };
-Ue.prototype.ProvidedFrom = function() {
-  const s = this.messageBody()?.fromTo?.()?.from?.();
-  return s?.name?.()?.getFormattedText?.() || s?.getFormattedText?.();
-};
-Ue.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
-};
-Me.prototype.ProvidedFrom = function() {
-  const s = this.from();
-  return s?.name?.()?.getFormattedText?.() || s?.getFormattedText?.();
-};
-Me.prototype.From = function() {
-  return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
-};
-Be.prototype.ProvidedFrom = function() {
-  const s = this.from();
-  return s?.name?.()?.getFormattedText?.() || s?.getFormattedText?.();
-};
-Be.prototype.From = function() {
+function vt() {
   return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
+}
+I0.prototype.ProvidedFrom = function() {
+  const r = this.messageBody()?.fromTo?.()?.from?.();
+  return r?.name?.()?.getFormattedText?.() || r?.getFormattedText?.();
 };
-E0.prototype.From = function() {
+I0.prototype.From = vt;
+function w0() {
+  const r = this.from();
+  return r?.name?.()?.getFormattedText?.() || r?.getFormattedText?.();
+}
+H0.prototype.ProvidedFrom = w0;
+H0.prototype.From = vt;
+U0.prototype.ProvidedFrom = w0;
+U0.prototype.From = vt;
+fe.prototype.From = function() {
   return this.asyncMessage()?.From?.() || this.returnAsyncMessage()?.From?.() || this.ClosestAncestorStat()?.Origin();
 };
-const Pe = i, et = Pe.StatContext, De = o.ParserRuleContext;
-De.prototype.ClosestAncestorStat = function() {
-  if (this instanceof et)
+const Re = i, J = Re.StatContext, Ee = h.ParserRuleContext;
+Ee.prototype.ClosestAncestorStat = function() {
+  if (this instanceof J)
     return this;
-  let s = this.parentCtx;
-  for (; s && !(s instanceof et); )
-    s = s.parentCtx;
-  if (s instanceof et)
-    return s;
-};
-De.prototype.ClosestAncestorBlock = function() {
-  const s = this.ClosestAncestorStat()?.parentCtx;
-  if (s instanceof Pe.BlockContext)
-    return s;
-  console.warn("Cannot find closest ancestor block for context:", this);
+  let r = this.parentCtx;
+  for (; r && !(r instanceof J); )
+    r = r.parentCtx;
+  if (r instanceof J)
+    return r;
 };
-o.ParserRuleContext.prototype.getAncestors = function(s) {
+h.ParserRuleContext.prototype.getAncestors = function(r) {
   const t = [];
-  (!s || s(this)) && t.push(this);
+  (!r || r(this)) && t.push(this);
   let e = this.parentCtx;
   for (; e; )
-    (!s || s(e)) && t.push(e), e = e.parentCtx;
+    (!r || r(e)) && t.push(e), e = e.parentCtx;
   return t;
 };
-const T0 = (s) => s.replace(/[\n\r]/g, " ").replace(/\s+/g, " ").replace(/\s*([,;.])\s*/g, "$1").replace(/\s*(\()\s*|\s*(\))/g, "$1$2").replace(/\s+$/g, "").replace(/^"(.*)"$/, "$1");
-class D0 extends o.error.ErrorListener {
-  syntaxError(t, e, r, n, c) {
+const Te = (r) => r.replace(/[\n\r]/g, " ").replace(/\s+/g, " ").replace(/\s*([,;.])\s*/g, "$1").replace(/\s*(\()\s*|\s*(\))/g, "$1$2").replace(/\s+$/g, "").replace(/^"(.*)"$/, "$1");
+class Pe extends h.error.ErrorListener {
+  syntaxError(t, e, s, n, c) {
   }
 }
-class C0 extends o.error.ErrorListener {
+class _e extends h.error.ErrorListener {
   constructor() {
     super(), this.errorDetails = [];
   }
-  syntaxError(t, e, r, n, c) {
-    this.errorDetails.push({ line: r, column: n, msg: c });
+  syntaxError(t, e, s, n, c) {
+    this.errorDetails.push({ line: s, column: n, msg: c });
   }
 }
-o.ParserRuleContext.prototype.getFormattedText = function() {
-  const s = this.parser.getTokenStream().getText(this.getSourceInterval());
-  return T0(s);
+h.ParserRuleContext.prototype.getFormattedText = function() {
+  const r = this.parser.getTokenStream().getText(this.getSourceInterval());
+  return Te(r);
 };
-o.ParserRuleContext.prototype.getComment = function() {
-  let s = this.start.tokenIndex, t = a.channelNames.indexOf("COMMENT_CHANNEL");
-  this.constructor.name === "BraceBlockContext" && (s = this.stop.tokenIndex);
-  let e = this.parser.getTokenStream().getHiddenTokensToLeft(s, t);
-  return e && e.map((r) => r.text.substring(2)).join(`
+h.ParserRuleContext.prototype.getComment = function() {
+  let r = this.start.tokenIndex, t = a.channelNames.indexOf("COMMENT_CHANNEL");
+  this.constructor.name === "BraceBlockContext" && (r = this.stop.tokenIndex);
+  let e = this.parser.getTokenStream().getHiddenTokensToLeft(r, t);
+  return e && e.map((s) => s.text.substring(2)).join(`
 `);
 };
-function _0(s) {
-  const t = new C0(), e = new o.InputStream(s), r = new a(e);
-  r.removeErrorListeners(), r.addErrorListener(t);
-  const n = new o.CommonTokenStream(r), c = new i(n);
+function Ce(r) {
+  const t = new _e(), e = new h.InputStream(r), s = new a(e);
+  s.removeErrorListeners(), s.addErrorListener(t);
+  const n = new h.CommonTokenStream(s), c = new i(n);
   return c.removeErrorListeners(), c.addErrorListener(t), {
     rootContext: c.prog(),
     pass: t.errorDetails.length === 0,
     errorDetails: t.errorDetails
   };
 }
-function k0(s) {
-  const { pass: t, errorDetails: e } = _0(s);
+function ke(r) {
+  const { pass: t, errorDetails: e } = Ce(r);
   return { pass: t, errorDetails: e };
 }
 i.ProgContext;
@@ -23231,7 +23157,7 @@ i.GroupContext;
 i.ParticipantContext;
 i.ProgContext, i.GroupContext, i.ParticipantContext;
 export {
-  _0 as parse,
-  k0 as validate
+  Ce as parse,
+  ke as validate
 };
 //# sourceMappingURL=index.mjs.map