@zenuml/core 4.10.2 → 4.10.3

package/dist/cli/zenuml.mjs

@@ -2081,7 +2081,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	prog() {
-	    let localctx = new ProgContext$3(this, this._ctx, this.state);
+	    let localctx = new ProgContext$2(this, this._ctx, this.state);
 	    this.enterRule(localctx, 0, sequenceParser.RULE_prog);
 	    var _la = 0; // Token type
 	    try {
@@ -2161,7 +2161,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	title() {
-	    let localctx = new TitleContext$1(this, this._ctx, this.state);
+	    let localctx = new TitleContext(this, this._ctx, this.state);
 	    this.enterRule(localctx, 2, sequenceParser.RULE_title);
 	    var _la = 0; // Token type
 	    try {
@@ -2804,7 +2804,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	ret() {
-	    let localctx = new RetContext$3(this, this._ctx, this.state);
+	    let localctx = new RetContext(this, this._ctx, this.state);
 	    this.enterRule(localctx, 28, sequenceParser.RULE_ret);
 	    var _la = 0; // Token type
 	    try {
@@ -2885,7 +2885,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	returnAsyncMessage() {
-	    let localctx = new ReturnAsyncMessageContext$3(this, this._ctx, this.state);
+	    let localctx = new ReturnAsyncMessageContext$1(this, this._ctx, this.state);
 	    this.enterRule(localctx, 30, sequenceParser.RULE_returnAsyncMessage);
 	    var _la = 0; // Token type
 	    try {
@@ -2993,7 +2993,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	stat() {
-	    let localctx = new StatContext$3(this, this._ctx, this.state);
+	    let localctx = new StatContext$2(this, this._ctx, this.state);
 	    this.enterRule(localctx, 36, sequenceParser.RULE_stat);
 	    var _la = 0; // Token type
 	    try {
@@ -3313,7 +3313,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	creation() {
-	    let localctx = new CreationContext$8(this, this._ctx, this.state);
+	    let localctx = new CreationContext$5(this, this._ctx, this.state);
 	    this.enterRule(localctx, 46, sequenceParser.RULE_creation);
 	    try {
 	        this.enterOuterAlt(localctx, 1);
@@ -3481,7 +3481,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	message() {
-	    let localctx = new MessageContext$8(this, this._ctx, this.state);
+	    let localctx = new MessageContext$5(this, this._ctx, this.state);
 	    this.enterRule(localctx, 52, sequenceParser.RULE_message);
 	    try {
 	        this.enterOuterAlt(localctx, 1);
@@ -3822,7 +3822,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	asyncMessage() {
-	    let localctx = new AsyncMessageContext$3(this, this._ctx, this.state);
+	    let localctx = new AsyncMessageContext$1(this, this._ctx, this.state);
 	    this.enterRule(localctx, 70, sequenceParser.RULE_asyncMessage);
 	    var _la = 0; // Token type
 	    try {
@@ -4080,7 +4080,7 @@ class sequenceParser extends antlr4.Parser {
 
 
 	parameters() {
-	    let localctx = new ParametersContext$1(this, this._ctx, this.state);
+	    let localctx = new ParametersContext(this, this._ctx, this.state);
 	    this.enterRule(localctx, 82, sequenceParser.RULE_parameters);
 	    var _la = 0; // Token type
 	    try {
@@ -5268,7 +5268,7 @@ sequenceParser.RULE_condition = 58;
 sequenceParser.RULE_inExpr = 59;
 sequenceParser.RULE_textExpr = 60;
 
-let ProgContext$3 = class ProgContext extends antlr4.ParserRuleContext {
+let ProgContext$2 = class ProgContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -5287,7 +5287,7 @@ let ProgContext$3 = class ProgContext extends antlr4.ParserRuleContext {
 	};
 
 	title() {
-	    return this.getTypedRuleContext(TitleContext$1,0);
+	    return this.getTypedRuleContext(TitleContext,0);
 	};
 
 	head() {
@@ -5315,7 +5315,7 @@ let ProgContext$3 = class ProgContext extends antlr4.ParserRuleContext {
 
 
 
-let TitleContext$1 = class TitleContext extends antlr4.ParserRuleContext {
+class TitleContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -5354,7 +5354,7 @@ let TitleContext$1 = class TitleContext extends antlr4.ParserRuleContext {
 	}
 
 
-};
+}
 
 
 
@@ -5891,9 +5891,9 @@ class BlockContext extends antlr4.ParserRuleContext {
 	        i = null;
 	    }
 	    if(i===null) {
-	        return this.getTypedRuleContexts(StatContext$3);
+	        return this.getTypedRuleContexts(StatContext$2);
 	    } else {
-	        return this.getTypedRuleContext(StatContext$3,i);
+	        return this.getTypedRuleContext(StatContext$2,i);
 	    }
 	};
 
@@ -5914,7 +5914,7 @@ class BlockContext extends antlr4.ParserRuleContext {
 
 
 
-let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
+class RetContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -5945,7 +5945,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 	};
 
 	asyncMessage() {
-	    return this.getTypedRuleContext(AsyncMessageContext$3,0);
+	    return this.getTypedRuleContext(AsyncMessageContext$1,0);
 	};
 
 	EVENT_END() {
@@ -5953,7 +5953,7 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 	};
 
 	returnAsyncMessage() {
-	    return this.getTypedRuleContext(ReturnAsyncMessageContext$3,0);
+	    return this.getTypedRuleContext(ReturnAsyncMessageContext$1,0);
 	};
 
 	enterRule(listener) {
@@ -5969,11 +5969,11 @@ let RetContext$3 = class RetContext extends antlr4.ParserRuleContext {
 	}
 
 
-};
+}
 
 
 
-let ReturnAsyncMessageContext$3 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
+let ReturnAsyncMessageContext$1 = class ReturnAsyncMessageContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -6094,7 +6094,7 @@ class DividerNoteContext extends antlr4.ParserRuleContext {
 
 
 
-let StatContext$3 = class StatContext extends antlr4.ParserRuleContext {
+let StatContext$2 = class StatContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -6137,15 +6137,15 @@ let StatContext$3 = class StatContext extends antlr4.ParserRuleContext {
 	};
 
 	creation() {
-	    return this.getTypedRuleContext(CreationContext$8,0);
+	    return this.getTypedRuleContext(CreationContext$5,0);
 	};
 
 	message() {
-	    return this.getTypedRuleContext(MessageContext$8,0);
+	    return this.getTypedRuleContext(MessageContext$5,0);
 	};
 
 	asyncMessage() {
-	    return this.getTypedRuleContext(AsyncMessageContext$3,0);
+	    return this.getTypedRuleContext(AsyncMessageContext$1,0);
 	};
 
 	EVENT_END() {
@@ -6153,7 +6153,7 @@ let StatContext$3 = class StatContext extends antlr4.ParserRuleContext {
 	};
 
 	ret() {
-	    return this.getTypedRuleContext(RetContext$3,0);
+	    return this.getTypedRuleContext(RetContext,0);
 	};
 
 	divider() {
@@ -6361,7 +6361,7 @@ class SectionContext extends antlr4.ParserRuleContext {
 
 
 
-let CreationContext$8 = class CreationContext extends antlr4.ParserRuleContext {
+let CreationContext$5 = class CreationContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -6509,7 +6509,7 @@ class CreationBodyContext extends antlr4.ParserRuleContext {
 	};
 
 	parameters() {
-	    return this.getTypedRuleContext(ParametersContext$1,0);
+	    return this.getTypedRuleContext(ParametersContext,0);
 	};
 
 	enterRule(listener) {
@@ -6529,7 +6529,7 @@ class CreationBodyContext extends antlr4.ParserRuleContext {
 
 
 
-let MessageContext$8 = class MessageContext extends antlr4.ParserRuleContext {
+let MessageContext$5 = class MessageContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -6856,7 +6856,7 @@ class InvocationContext extends antlr4.ParserRuleContext {
 	};
 
 	parameters() {
-	    return this.getTypedRuleContext(ParametersContext$1,0);
+	    return this.getTypedRuleContext(ParametersContext,0);
 	};
 
 	enterRule(listener) {
@@ -6919,7 +6919,7 @@ class AssignmentContext extends antlr4.ParserRuleContext {
 
 
 
-let AsyncMessageContext$3 = class AsyncMessageContext extends antlr4.ParserRuleContext {
+let AsyncMessageContext$1 = class AsyncMessageContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -7201,7 +7201,7 @@ class MethodNameContext extends antlr4.ParserRuleContext {
 
 
 
-let ParametersContext$1 = class ParametersContext extends antlr4.ParserRuleContext {
+class ParametersContext extends antlr4.ParserRuleContext {
 
     constructor(parser, parent, invokingState) {
         if(parent===undefined) {
@@ -7251,7 +7251,7 @@ let ParametersContext$1 = class ParametersContext extends antlr4.ParserRuleConte
 	}
 
 
-};
+}
 
 
 
@@ -8189,7 +8189,7 @@ class CreationExprContext extends ExprContext {
     }
 
 	creation() {
-	    return this.getTypedRuleContext(CreationContext$8,0);
+	    return this.getTypedRuleContext(CreationContext$5,0);
 	};
 
 	enterRule(listener) {
@@ -8880,8 +8880,8 @@ class TextExprContext extends antlr4.ParserRuleContext {
 
 
 
-sequenceParser.ProgContext = ProgContext$3; 
-sequenceParser.TitleContext = TitleContext$1; 
+sequenceParser.ProgContext = ProgContext$2; 
+sequenceParser.TitleContext = TitleContext; 
 sequenceParser.HeadContext = HeadContext; 
 sequenceParser.GroupContext = GroupContext$1; 
 sequenceParser.StarterExpContext = StarterExpContext; 
@@ -8894,19 +8894,19 @@ sequenceParser.NameContext = NameContext;
 sequenceParser.WidthContext = WidthContext; 
 sequenceParser.EmojiContext = EmojiContext; 
 sequenceParser.BlockContext = BlockContext; 
-sequenceParser.RetContext = RetContext$3; 
-sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$3; 
+sequenceParser.RetContext = RetContext; 
+sequenceParser.ReturnAsyncMessageContext = ReturnAsyncMessageContext$1; 
 sequenceParser.DividerContext = DividerContext$1; 
 sequenceParser.DividerNoteContext = DividerNoteContext; 
-sequenceParser.StatContext = StatContext$3; 
+sequenceParser.StatContext = StatContext$2; 
 sequenceParser.ParContext = ParContext; 
 sequenceParser.OptContext = OptContext; 
 sequenceParser.CriticalContext = CriticalContext; 
 sequenceParser.SectionContext = SectionContext; 
-sequenceParser.CreationContext = CreationContext$8; 
+sequenceParser.CreationContext = CreationContext$5; 
 sequenceParser.RefContext = RefContext$1; 
 sequenceParser.CreationBodyContext = CreationBodyContext; 
-sequenceParser.MessageContext = MessageContext$8; 
+sequenceParser.MessageContext = MessageContext$5; 
 sequenceParser.MessageBodyContext = MessageBodyContext; 
 sequenceParser.FromToContext = FromToContext; 
 sequenceParser.FuncContext = FuncContext; 
@@ -8915,13 +8915,13 @@ sequenceParser.ToContext = ToContext;
 sequenceParser.SignatureContext = SignatureContext; 
 sequenceParser.InvocationContext = InvocationContext; 
 sequenceParser.AssignmentContext = AssignmentContext; 
-sequenceParser.AsyncMessageContext = AsyncMessageContext$3; 
+sequenceParser.AsyncMessageContext = AsyncMessageContext$1; 
 sequenceParser.ContentContext = ContentContext; 
 sequenceParser.ConstructContext = ConstructContext; 
 sequenceParser.TypeContext = TypeContext; 
 sequenceParser.AssigneeContext = AssigneeContext; 
 sequenceParser.MethodNameContext = MethodNameContext; 
-sequenceParser.ParametersContext = ParametersContext$1; 
+sequenceParser.ParametersContext = ParametersContext; 
 sequenceParser.ParameterContext = ParameterContext; 
 sequenceParser.NamedParameterContext = NamedParameterContext; 
 sequenceParser.DeclarationContext = DeclarationContext; 
@@ -9237,27 +9237,37 @@ ToCollector.getParticipants = function(context) {
   return participants;
 };
 
+function augment(ctxClass, methods) {
+  const prototype = ctxClass.prototype;
+  for (const key of Object.keys(methods)) {
+    prototype[key] = methods[key];
+  }
+}
+
 const seqParser$9 = sequenceParser;
-const TitleContext = seqParser$9.TitleContext;
-TitleContext.prototype.content = function() {
-  if (this.children.length < 2) {
-    return "";
-  } else {
-    return this.children[1].getText().trim();
+augment(seqParser$9.TitleContext, {
+  content() {
+    if (this.children.length < 2) {
+      return "";
+    } else {
+      return this.children[1].getText().trim();
+    }
   }
-};
+});
 
 const seqParser$8 = sequenceParser;
-const CreationContext$7 = seqParser$8.CreationContext;
-CreationContext$7.prototype.Body = CreationContext$7.prototype.creationBody;
-CreationContext$7.prototype.isCurrent = function(cursor) {
-  return isCurrent.bind(this)(cursor);
-};
-const MessageContext$7 = seqParser$8.MessageContext;
-MessageContext$7.prototype.Body = MessageContext$7.prototype.messageBody;
-MessageContext$7.prototype.isCurrent = function(cursor) {
-  return isCurrent.bind(this)(cursor);
-};
+augment(seqParser$8.CreationContext, {
+  Body: seqParser$8.CreationContext.prototype.creationBody,
+  isCurrent(cursor) {
+    return isCurrent.bind(this)(cursor);
+  }
+});
+augment(seqParser$8.MessageContext, {
+  Body: seqParser$8.MessageContext.prototype.messageBody,
+  isCurrent(cursor) {
+    return isCurrent.bind(this)(cursor);
+  }
+});
 function isCurrent(cursor) {
   try {
     if (cursor === null || cursor === void 0) return false;
@@ -9270,39 +9280,43 @@ function isCurrent(cursor) {
 }
 
 const seqParser$7 = sequenceParser;
-const CreationContext$6 = seqParser$7.CreationContext;
-const MessageContext$6 = seqParser$7.MessageContext;
-const AsyncMessageContext$2 = seqParser$7.AsyncMessageContext;
-const ReturnAsyncMessageContext$2 = seqParser$7.ReturnAsyncMessageContext;
+const CreationContext$4 = seqParser$7.CreationContext;
+const MessageContext$4 = seqParser$7.MessageContext;
+const AsyncMessageContext = seqParser$7.AsyncMessageContext;
+const ReturnAsyncMessageContext = seqParser$7.ReturnAsyncMessageContext;
 const RetMessageContext = seqParser$7.RetContext;
-CreationContext$6.prototype.Assignee = function() {
-  return this.creationBody()?.assignment()?.assignee()?.getFormattedText();
-};
-CreationContext$6.prototype.AssigneePosition = function() {
-  const assignee = this.creationBody()?.assignment()?.assignee();
-  if (!assignee) {
-    return void 0;
+augment(CreationContext$4, {
+  Assignee() {
+    return this.creationBody()?.assignment()?.assignee()?.getFormattedText();
+  },
+  AssigneePosition() {
+    const assignee = this.creationBody()?.assignment()?.assignee();
+    if (!assignee) {
+      return void 0;
+    }
+    return [assignee.start.start, assignee.stop.stop + 1];
+  },
+  Constructor() {
+    return this.creationBody()?.construct()?.getFormattedText();
+  },
+  Owner() {
+    if (!this.Constructor()) {
+      return "Missing Constructor";
+    }
+    const assignee = this.Assignee();
+    const type = this.Constructor();
+    return assignee ? `${assignee}:${type}` : type;
   }
-  return [assignee.start.start, assignee.stop.stop + 1];
-};
-CreationContext$6.prototype.Constructor = function() {
-  return this.creationBody()?.construct()?.getFormattedText();
-};
-CreationContext$6.prototype.Owner = function() {
-  if (!this.Constructor()) {
-    return "Missing Constructor";
+});
+augment(MessageContext$4, {
+  To() {
+    const toCtx = this.messageBody()?.fromTo()?.to();
+    return toCtx?.name?.()?.getFormattedText() || toCtx?.getFormattedText();
   }
-  const assignee = this.Assignee();
-  const type = this.Constructor();
-  return assignee ? `${assignee}:${type}` : type;
-};
-MessageContext$6.prototype.To = function() {
-  const toCtx = this.messageBody()?.fromTo()?.to();
-  return toCtx?.name?.()?.getFormattedText() || toCtx?.getFormattedText();
-};
+});
 function getOwnerFromAncestor(ctx) {
   while (ctx) {
-    if (ctx instanceof CreationContext$6 || ctx instanceof MessageContext$6) {
+    if (ctx instanceof CreationContext$4 || ctx instanceof MessageContext$4) {
       return ctx.Owner();
     }
     ctx = ctx.parentCtx;
@@ -9312,63 +9326,75 @@ function getOwnerFromAncestor(ctx) {
 function ownerFromToOrAncestor() {
   return this.To() || getOwnerFromAncestor(this.parentCtx);
 }
-[
-  MessageContext$6,
-  AsyncMessageContext$2,
-  ReturnAsyncMessageContext$2,
-  RetMessageContext
-].forEach((ContextClass) => {
-  ContextClass.prototype.Owner = ownerFromToOrAncestor;
+augment(MessageContext$4, {
+  Owner: ownerFromToOrAncestor
+});
+augment(AsyncMessageContext, {
+  Owner: ownerFromToOrAncestor
+});
+augment(ReturnAsyncMessageContext, {
+  Owner: ownerFromToOrAncestor
+});
+augment(RetMessageContext, {
+  Owner: ownerFromToOrAncestor
 });
 function toFromDirectTo() {
   const toCtx = this.to();
   return toCtx?.name?.()?.getFormattedText() || toCtx?.getFormattedText();
 }
-AsyncMessageContext$2.prototype.To = toFromDirectTo;
-ReturnAsyncMessageContext$2.prototype.To = toFromDirectTo;
-RetMessageContext.prototype.To = function() {
-  return this.ReturnTo();
-};
+augment(AsyncMessageContext, {
+  To: toFromDirectTo
+});
+augment(ReturnAsyncMessageContext, {
+  To: toFromDirectTo
+});
+augment(RetMessageContext, {
+  To() {
+    return this.ReturnTo();
+  }
+});
 
-const ProgContext$2 = sequenceParser.ProgContext;
-ProgContext$2.prototype.Starter = function() {
-  return this.head()?.starterExp()?.starter()?.getFormattedText?.();
-};
+augment(sequenceParser.ProgContext, {
+  Starter() {
+    return this.head()?.starterExp()?.starter()?.getFormattedText?.();
+  }
+});
 
 const seqParser$6 = sequenceParser;
-const RetContext$2 = seqParser$6.RetContext;
 const ProgContext$1 = seqParser$6.ProgContext;
-const MessageContext$5 = seqParser$6.MessageContext;
-const CreationContext$5 = seqParser$6.CreationContext;
-RetContext$2.prototype.Signature = function() {
-  return this.asyncMessage()?.content()?.getFormattedText() || this.returnAsyncMessage()?.content()?.getFormattedText() || this.expr()?.getFormattedText();
-};
-RetContext$2.prototype.ReturnTo = function() {
-  const asyncToCtx = this.asyncMessage()?.to() || this.returnAsyncMessage()?.to();
-  const asyncTo = asyncToCtx?.name?.()?.getFormattedText() || asyncToCtx?.getFormattedText();
-  if (asyncTo) {
-    return asyncTo;
-  }
-  const stat = this.parentCtx;
-  const block = stat.parentCtx;
-  const blockParent = block.parentCtx;
-  if (blockParent instanceof ProgContext$1) {
-    return blockParent.Starter();
-  } else {
-    let ctx = blockParent;
-    while (ctx && !(ctx instanceof MessageContext$5) && !(ctx instanceof CreationContext$5)) {
-      if (ctx instanceof ProgContext$1) {
-        return ctx.Starter();
+const MessageContext$3 = seqParser$6.MessageContext;
+const CreationContext$3 = seqParser$6.CreationContext;
+augment(seqParser$6.RetContext, {
+  Signature() {
+    return this.asyncMessage()?.content()?.getFormattedText() || this.returnAsyncMessage()?.content()?.getFormattedText() || this.expr()?.getFormattedText();
+  },
+  ReturnTo() {
+    const asyncToCtx = this.asyncMessage()?.to() || this.returnAsyncMessage()?.to();
+    const asyncTo = asyncToCtx?.name?.()?.getFormattedText() || asyncToCtx?.getFormattedText();
+    if (asyncTo) {
+      return asyncTo;
+    }
+    const stat = this.parentCtx;
+    const block = stat.parentCtx;
+    const blockParent = block.parentCtx;
+    if (blockParent instanceof ProgContext$1) {
+      return blockParent.Starter();
+    } else {
+      let ctx = blockParent;
+      while (ctx && !(ctx instanceof MessageContext$3) && !(ctx instanceof CreationContext$3)) {
+        if (ctx instanceof ProgContext$1) {
+          return ctx.Starter();
+        }
+        ctx = ctx.parentCtx;
       }
-      ctx = ctx.parentCtx;
-    }
-    if (ctx instanceof MessageContext$5) {
-      const messageCtx = ctx;
-      return messageCtx.messageBody()?.fromTo()?.from()?.name?.()?.getFormattedText() || messageCtx.messageBody()?.fromTo()?.from()?.getFormattedText() || messageCtx.ClosestAncestorStat().Origin();
+      if (ctx instanceof MessageContext$3) {
+        const messageCtx = ctx;
+        return messageCtx.messageBody()?.fromTo()?.from()?.name?.()?.getFormattedText() || messageCtx.messageBody()?.fromTo()?.from()?.getFormattedText() || messageCtx.ClosestAncestorStat().Origin();
+      }
+      return ctx.ClosestAncestorStat().Origin();
     }
-    return ctx.ClosestAncestorStat().Origin();
   }
-};
+});
 
 const seqParser$5 = sequenceParser;
 const RefContext = seqParser$5.RefContext;
@@ -9376,51 +9402,59 @@ function isSynthesizedName(name) {
   if (!name || !name.start || !name.stop) return true;
   return name.stop.tokenIndex < name.start.tokenIndex;
 }
-RefContext.prototype.Content = function() {
-  const first = this.name()[0];
-  return isSynthesizedName(first) ? void 0 : first;
-};
-RefContext.prototype.Participants = function() {
-  return this.name().slice(1) ?? [];
-};
+augment(RefContext, {
+  Content() {
+    const first = this.name()[0];
+    return isSynthesizedName(first) ? void 0 : first;
+  },
+  Participants() {
+    return this.name().slice(1) ?? [];
+  }
+});
 
-const ParserRuleContext$2 = antlr4.ParserRuleContext;
-const StatContext$2 = sequenceParser.StatContext;
 const ProgContext = sequenceParser.ProgContext;
-const MessageContext$4 = sequenceParser.MessageContext;
-const CreationContext$4 = sequenceParser.CreationContext;
-ParserRuleContext$2.prototype.Origin = function() {
-  return this.ClosestAncestorStat()?.Origin();
-};
-StatContext$2.prototype.Origin = function() {
-  let ctx = this.parentCtx;
-  while (ctx) {
-    if (ctx instanceof ProgContext) {
-      return ctx.Starter();
-    }
-    if (ctx instanceof MessageContext$4 || ctx instanceof CreationContext$4) {
-      const receiver = ctx.Owner();
-      if (receiver) {
-        return receiver;
+const MessageContext$2 = sequenceParser.MessageContext;
+const CreationContext$2 = sequenceParser.CreationContext;
+augment(antlr4.ParserRuleContext, {
+  Origin() {
+    return this.ClosestAncestorStat()?.Origin();
+  }
+});
+augment(sequenceParser.StatContext, {
+  Origin() {
+    let ctx = this.parentCtx;
+    while (ctx) {
+      if (ctx instanceof ProgContext) {
+        return ctx.Starter();
       }
+      if (ctx instanceof MessageContext$2 || ctx instanceof CreationContext$2) {
+        const receiver = ctx.Owner();
+        if (receiver) {
+          return receiver;
+        }
+      }
+      ctx = ctx.parentCtx;
     }
-    ctx = ctx.parentCtx;
+    return void 0;
   }
-  return void 0;
-};
-ProgContext.prototype.Origin = function() {
-  return this.Starter();
-};
+});
+augment(ProgContext, {
+  Origin() {
+    return this.Starter();
+  }
+});
 
 const seqParser$4 = sequenceParser;
 const DividerContext = seqParser$4.DividerContext;
-DividerContext.prototype.Note = function() {
-  const formattedText = this.dividerNote()?.getFormattedText().trim();
-  if (!formattedText.startsWith("==")) {
-    throw new Error("Divider note must start with ==");
+augment(DividerContext, {
+  Note() {
+    const formattedText = this.dividerNote()?.getFormattedText().trim();
+    if (!formattedText.startsWith("==")) {
+      throw new Error("Divider note must start with ==");
+    }
+    return formattedText?.replace(/^=+|=+$/g, "");
   }
-  return formattedText?.replace(/^=+|=+$/g, "");
-};
+});
 
 function formatParameter(param) {
   if (param.namedParameter?.()) {
@@ -9446,43 +9480,52 @@ function formatParameter(param) {
 function formatParameters(params) {
   return params.map(formatParameter).join(",");
 }
-const MessageContext$3 = sequenceParser.MessageContext;
-const ParametersContext = sequenceParser.ParametersContext;
-const AsyncMessageContext$1 = sequenceParser.AsyncMessageContext;
-const CreationContext$3 = sequenceParser.CreationContext;
-const RetContext$1 = sequenceParser.RetContext;
-const ReturnAsyncMessageContext$1 = sequenceParser.ReturnAsyncMessageContext;
-MessageContext$3.prototype.SignatureText = function() {
-  return this.messageBody()?.func()?.signature()?.map((s) => s?.getFormattedText()).join(".") ?? "";
-};
-AsyncMessageContext$1.prototype.SignatureText = function() {
-  return this.content()?.getFormattedText() ?? "";
-};
-CreationContext$3.prototype.ParametersText = function() {
-  const params = this.creationBody().parameters();
-  return params?.parameter()?.length > 0 ? formatParameters(params.parameter()) : "";
-};
-CreationContext$3.prototype.SignatureText = function() {
-  const text = this.ParametersText() || "create";
-  return `«${text}»`;
-};
-RetContext$1.prototype.SignatureText = function() {
-  return this.asyncMessage()?.content()?.getFormattedText() ?? this.returnAsyncMessage()?.content()?.getFormattedText() ?? this.expr()?.getFormattedText() ?? "";
-};
-ReturnAsyncMessageContext$1.prototype.SignatureText = function() {
-  return this.content()?.getFormattedText() ?? "";
-};
-ParametersContext.prototype.getFormattedText = function() {
-  const params = this.parameter();
-  if (!params || params.length === 0) {
-    return "";
+augment(sequenceParser.MessageContext, {
+  SignatureText() {
+    return this.messageBody()?.func()?.signature()?.map((s) => s?.getFormattedText()).join(".") ?? "";
   }
-  return formatParameters(params);
-};
+});
+augment(sequenceParser.AsyncMessageContext, {
+  SignatureText() {
+    return this.content()?.getFormattedText() ?? "";
+  }
+});
+augment(sequenceParser.CreationContext, {
+  ParametersText() {
+    const params = this.creationBody().parameters();
+    return params?.parameter()?.length > 0 ? formatParameters(params.parameter()) : "";
+  },
+  SignatureText() {
+    const text = this.ParametersText() || "create";
+    return `«${text}»`;
+  }
+});
+augment(sequenceParser.RetContext, {
+  SignatureText() {
+    return this.asyncMessage()?.content()?.getFormattedText() ?? this.returnAsyncMessage()?.content()?.getFormattedText() ?? this.expr()?.getFormattedText() ?? "";
+  }
+});
+augment(
+  sequenceParser.ReturnAsyncMessageContext,
+  {
+    SignatureText() {
+      return this.content()?.getFormattedText() ?? "";
+    }
+  }
+);
+augment(sequenceParser.ParametersContext, {
+  getFormattedText() {
+    const params = this.parameter();
+    if (!params || params.length === 0) {
+      return "";
+    }
+    return formatParameters(params);
+  }
+});
 
 const seqParser$3 = sequenceParser;
-const MessageContext$2 = seqParser$3.MessageContext;
-const CreationContext$2 = seqParser$3.CreationContext;
+const MessageContext$1 = seqParser$3.MessageContext;
+const CreationContext$1 = seqParser$3.CreationContext;
 class Assignment {
   assignee;
   type;
@@ -9518,95 +9561,118 @@ function extractAssignmentFromContext(assignmentContext) {
   }
   return void 0;
 }
-MessageContext$2.prototype.Assignment = function() {
-  return extractAssignmentFromContext(this.messageBody().assignment());
-};
-CreationContext$2.prototype.Assignment = function() {
-  return extractAssignmentFromContext(this.creationBody()?.assignment());
-};
+augment(MessageContext$1, {
+  Assignment() {
+    return extractAssignmentFromContext(this.messageBody().assignment());
+  }
+});
+augment(CreationContext$1, {
+  Assignment() {
+    return extractAssignmentFromContext(this.creationBody()?.assignment());
+  }
+});
 
 const seqParser$2 = sequenceParser;
-const MessageContext$1 = seqParser$2.MessageContext;
-const CreationContext$1 = seqParser$2.CreationContext;
+const MessageContext = seqParser$2.MessageContext;
+const CreationContext = seqParser$2.CreationContext;
 const IfBlockContext = seqParser$2.IfBlockContext;
 const LoopContext = seqParser$2.LoopContext;
-MessageContext$1.prototype.Statements = function() {
-  return this.braceBlock()?.block()?.stat() || [];
-};
-CreationContext$1.prototype.Statements = function() {
-  return this.braceBlock()?.block()?.stat() || [];
-};
-IfBlockContext.prototype.Statements = function() {
-  return this.braceBlock()?.block()?.stat() || [];
-};
-LoopContext.prototype.Statements = function() {
-  return this.braceBlock()?.block()?.stat() || [];
-};
+augment(MessageContext, {
+  Statements() {
+    return this.braceBlock()?.block()?.stat() || [];
+  }
+});
+augment(CreationContext, {
+  Statements() {
+    return this.braceBlock()?.block()?.stat() || [];
+  }
+});
+augment(IfBlockContext, {
+  Statements() {
+    return this.braceBlock()?.block()?.stat() || [];
+  }
+});
+augment(LoopContext, {
+  Statements() {
+    return this.braceBlock()?.block()?.stat() || [];
+  }
+});
 
 const seqParser$1 = sequenceParser;
 const StatContext$1 = seqParser$1.StatContext;
-const CreationContext = seqParser$1.CreationContext;
-const MessageContext = seqParser$1.MessageContext;
-const AsyncMessageContext = seqParser$1.AsyncMessageContext;
-const ReturnAsyncMessageContext = seqParser$1.ReturnAsyncMessageContext;
-const RetContext = seqParser$1.RetContext;
-CreationContext.prototype.From = function() {
-  if (this.parentCtx instanceof StatContext$1) {
-    return this.ClosestAncestorStat()?.Origin();
+augment(seqParser$1.CreationContext, {
+  From() {
+    if (this.parentCtx instanceof StatContext$1) {
+      return this.ClosestAncestorStat()?.Origin();
+    }
+    return void 0;
   }
-  return void 0;
-};
+});
 function fromProvidedOrOrigin() {
   return this.ProvidedFrom() || this.ClosestAncestorStat()?.Origin();
 }
-MessageContext.prototype.ProvidedFrom = function() {
-  const fromCtx = this.messageBody()?.fromTo?.()?.from?.();
-  return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
-};
-MessageContext.prototype.From = fromProvidedOrOrigin;
+augment(seqParser$1.MessageContext, {
+  ProvidedFrom() {
+    const fromCtx = this.messageBody()?.fromTo?.()?.from?.();
+    return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
+  },
+  From: fromProvidedOrOrigin
+});
 function providedFromDirectFrom() {
   const fromCtx = this.from();
   return fromCtx?.name?.()?.getFormattedText?.() || fromCtx?.getFormattedText?.();
 }
-AsyncMessageContext.prototype.ProvidedFrom = providedFromDirectFrom;
-AsyncMessageContext.prototype.From = fromProvidedOrOrigin;
-ReturnAsyncMessageContext.prototype.ProvidedFrom = providedFromDirectFrom;
-ReturnAsyncMessageContext.prototype.From = fromProvidedOrOrigin;
-RetContext.prototype.From = function() {
-  return this.asyncMessage()?.From?.() || this.returnAsyncMessage()?.From?.() || this.ClosestAncestorStat()?.Origin();
-};
+augment(seqParser$1.AsyncMessageContext, {
+  ProvidedFrom: providedFromDirectFrom,
+  From: fromProvidedOrOrigin
+});
+augment(
+  seqParser$1.ReturnAsyncMessageContext,
+  {
+    ProvidedFrom: providedFromDirectFrom,
+    From: fromProvidedOrOrigin
+  }
+);
+augment(seqParser$1.RetContext, {
+  From() {
+    return this.asyncMessage()?.From?.() || this.returnAsyncMessage()?.From?.() || this.ClosestAncestorStat()?.Origin();
+  }
+});
 
 const seqParser = sequenceParser;
 const StatContext = seqParser.StatContext;
-const ParserRuleContext$1 = antlr4.ParserRuleContext;
-ParserRuleContext$1.prototype.ClosestAncestorStat = function() {
-  if (this instanceof StatContext) {
-    return this;
-  }
-  let current = this.parentCtx;
-  while (current && !(current instanceof StatContext)) {
-    current = current.parentCtx;
-  }
-  if (current instanceof StatContext) {
-    return current;
+augment(antlr4.ParserRuleContext, {
+  ClosestAncestorStat() {
+    if (this instanceof StatContext) {
+      return this;
+    }
+    let current = this.parentCtx;
+    while (current && !(current instanceof StatContext)) {
+      current = current.parentCtx;
+    }
+    if (current instanceof StatContext) {
+      return current;
+    }
+    return void 0;
   }
-  return void 0;
-};
+});
 
-antlr4.ParserRuleContext.prototype.getAncestors = function(predicate) {
-  const ancestors = [];
-  if (!predicate || predicate(this)) {
-    ancestors.push(this);
-  }
-  let current = this.parentCtx;
-  while (current) {
-    if (!predicate || predicate(current)) {
-      ancestors.push(current);
+augment(antlr4.ParserRuleContext, {
+  getAncestors(predicate) {
+    const ancestors = [];
+    if (!predicate || predicate(this)) {
+      ancestors.push(this);
     }
-    current = current.parentCtx;
+    let current = this.parentCtx;
+    while (current) {
+      if (!predicate || predicate(current)) {
+        ancestors.push(current);
+      }
+      current = current.parentCtx;
+    }
+    return ancestors;
   }
-  return ancestors;
-};
+});
 
 const formatText = (text) => text.replace(/[\n\r]/g, " ").replace(/\s+/g, " ").replace(/\s*([,;.])\s*/g, "$1").replace(/\s*(\()\s*|\s*(\))/g, "$1$2").replace(/\s+$/g, "").replace(/^"(.*)"$/, "$1");
 
@@ -9666,20 +9732,23 @@ function rootContext(code) {
   parser.addErrorListener(new SeqErrorListener());
   return parser.prog();
 }
-const ParserRuleContext = antlr4.ParserRuleContext;
-ParserRuleContext.prototype.getFormattedText = function() {
-  const code = this.parser.getTokenStream().getText(this.getSourceInterval());
-  return formatText(code);
-};
-ParserRuleContext.prototype.getComment = function() {
-  let tokenIndex = this.start.tokenIndex;
-  const channel = sequenceLexer.channelNames.indexOf("COMMENT_CHANNEL");
-  if (this.constructor.name === "BraceBlockContext") {
-    tokenIndex = this.stop.tokenIndex;
-  }
-  const hiddenTokensToLeft = this.parser.getTokenStream().getHiddenTokensToLeft(tokenIndex, channel);
-  return hiddenTokensToLeft && hiddenTokensToLeft.map((t) => t.text.substring(2)).join("\n");
-};
+augment(antlr4.ParserRuleContext, {
+  getFormattedText() {
+    const code = this.parser.getTokenStream().getText(this.getSourceInterval());
+    return formatText(code);
+  },
+  // Comment is where users have the most flexibility. The parser should make minimal assumptions about
+  // the content and the style including change of line, indentation, etc.
+  getComment() {
+    let tokenIndex = this.start.tokenIndex;
+    const channel = sequenceLexer.channelNames.indexOf("COMMENT_CHANNEL");
+    if (this.constructor.name === "BraceBlockContext") {
+      tokenIndex = this.stop.tokenIndex;
+    }
+    const hiddenTokensToLeft = this.parser.getTokenStream().getHiddenTokensToLeft(tokenIndex, channel);
+    return hiddenTokensToLeft && hiddenTokensToLeft.map((t) => t.text.substring(2)).join("\n");
+  }
+});
 function parse(code) {
   const listener = new CollectingErrorListener();
   const chars = new antlr4.InputStream(code);
@@ -11180,7 +11249,8 @@ const SINGLE_BLOCK_FRAGMENT_KINDS = [
 ];
 
 const blockOf = (ctx) => ctx?.braceBlock?.()?.block?.();
-const conditionText = (ctx) => ctx?.parExpr?.()?.condition?.()?.getFormattedText?.() || "";
+const conditionOf = (ctx) => ctx?.parExpr?.()?.condition?.();
+const conditionText = (ctx) => conditionOf(ctx)?.getFormattedText?.() || "";
 function fragmentOf(stat) {
   for (const kind of SINGLE_BLOCK_FRAGMENT_KINDS) {
     const frag = stat[kind]?.();
@@ -11192,6 +11262,7 @@ function fragmentOf(stat) {
           {
             guardKeyword: kind === "loop" ? frag.WHILE?.()?.getText?.() : void 0,
             condition: conditionText(frag),
+            conditionContext: conditionOf(frag),
             isLeading: true,
             block: blockOf(frag)
           }
@@ -11207,6 +11278,7 @@ function fragmentOf(stat) {
       sections.push({
         guardKeyword: "if",
         condition: conditionText(ifBlock),
+        conditionContext: conditionOf(ifBlock),
         isLeading: true,
         block: blockOf(ifBlock)
       });
@@ -11215,6 +11287,7 @@ function fragmentOf(stat) {
       sections.push({
         guardKeyword: "else if",
         condition: conditionText(elseIf),
+        conditionContext: conditionOf(elseIf),
         isLeading: false,
         block: blockOf(elseIf)
       });