https://www.vzome.com/modules/vzome-zomic.js

15// node_modules/antlr4/dist/antlr4.web.mjs
16var t = { 92: () => {
17} };
18var e = {};
19function n(s2) {
20  var i2 = e[s2];
21  if (void 0 !== i2) return i2.exports;
22  var r2 = e[s2] = { exports: {} };
23  return t[s2](r2, r2.exports, n), r2.exports;
24}
25n.d = (t2, e2) => {
26  for (var s2 in e2) n.o(e2, s2) && !n.o(t2, s2) && Object.defineProperty(t2, s2, { enumerable: true, get: e2[s2] });
27}, n.o = (t2, e2) => Object.prototype.hasOwnProperty.call(t2, e2);
28var s = {};
29(() => {
30  n.d(s, { dx: () => $, q2: () => Lt, FO: () => Ce, xf: () => Ie, Gy: () => ve, s4: () => Pt, c7: () => be, _7: () => le, tx: () => Ae, gp: () => me, cK: () => Ot, zs: () => Te, AV: () => Ie, Xp: () => m2, VS: () => E2, ul: () => W, hW: () => Ut, x1: () => Xt, z5: () => ee, oN: () => de, TB: () => pe, u1: () => ge, _b: () => Fe, $F: () => se, _T: () => Be, db: () => ie, Zx: () => te, _x: () => Ft, r8: () => M2, JI: () => w2, TP: () => P2, WU: () => t2, Nj: () => c2, ZP: () => We });
31  class t2 {
32    constructor() {
33      this.source = null, this.type = null, this.channel = null, this.start = null, this.stop = null, this.tokenIndex = null, this.line = null, this.column = null, this._text = null;
34    }
35    getTokenSource() {
36      return this.source[0];
37    }
38    getInputStream() {
39      return this.source[1];
40    }
41    get text() {
42      return this._text;
43    }
44    set text(t3) {
45      this._text = t3;
46    }
47  }
48  function e2(t3, e3) {
49    if (!Array.isArray(t3) || !Array.isArray(e3)) return false;
50    if (t3 === e3) return true;
51    if (t3.length !== e3.length) return false;
52    for (let n2 = 0; n2 < t3.length; n2++) if (!(t3[n2] === e3[n2] || t3[n2].equals && t3[n2].equals(e3[n2]))) return false;
53    return true;
54  }
55  t2.INVALID_TYPE = 0, t2.EPSILON = -2, t2.MIN_USER_TOKEN_TYPE = 1, t2.EOF = -1, t2.DEFAULT_CHANNEL = 0, t2.HIDDEN_CHANNEL = 1;
56  const i2 = Math.round(Math.random() * Math.pow(2, 32));
57  function r2(t3) {
58    if (!t3) return 0;
59    const e3 = typeof t3, n2 = "string" === e3 ? t3 : !("object" !== e3 || !t3.toString) && t3.toString();
60    if (!n2) return 0;
61    let s2, r3;
62    const o3 = 3 & n2.length, a3 = n2.length - o3;
63    let l3 = i2;
64    const h3 = 3432918353, c3 = 461845907;
65    let u3 = 0;
66    for (; u3 < a3; ) r3 = 255 & n2.charCodeAt(u3) | (255 & n2.charCodeAt(++u3)) << 8 | (255 & n2.charCodeAt(++u3)) << 16 | (255 & n2.charCodeAt(++u3)) << 24, ++u3, r3 = (65535 & r3) * h3 + (((r3 >>> 16) * h3 & 65535) << 16) & 4294967295, r3 = r3 << 15 | r3 >>> 17, r3 = (65535 & r3) * c3 + (((r3 >>> 16) * c3 & 65535) << 16) & 4294967295, l3 ^= r3, l3 = l3 << 13 | l3 >>> 19, s2 = 5 * (65535 & l3) + ((5 * (l3 >>> 16) & 65535) << 16) & 4294967295, l3 = 27492 + (65535 & s2) + ((58964 + (s2 >>> 16) & 65535) << 16);
67    switch (r3 = 0, o3) {
68      case 3:
69        r3 ^= (255 & n2.charCodeAt(u3 + 2)) << 16;
70      case 2:
71        r3 ^= (255 & n2.charCodeAt(u3 + 1)) << 8;
72      case 1:
73        r3 ^= 255 & n2.charCodeAt(u3), r3 = (65535 & r3) * h3 + (((r3 >>> 16) * h3 & 65535) << 16) & 4294967295, r3 = r3 << 15 | r3 >>> 17, r3 = (65535 & r3) * c3 + (((r3 >>> 16) * c3 & 65535) << 16) & 4294967295, l3 ^= r3;
74    }
75    return l3 ^= n2.length, l3 ^= l3 >>> 16, l3 = 2246822507 * (65535 & l3) + ((2246822507 * (l3 >>> 16) & 65535) << 16) & 4294967295, l3 ^= l3 >>> 13, l3 = 3266489909 * (65535 & l3) + ((3266489909 * (l3 >>> 16) & 65535) << 16) & 4294967295, l3 ^= l3 >>> 16, l3 >>> 0;
76  }
77  class o2 {
78    constructor() {
79      this.count = 0, this.hash = 0;
80    }
81    update() {
82      for (let t3 = 0; t3 < arguments.length; t3++) {
83        const e3 = arguments[t3];
84        if (null != e3) if (Array.isArray(e3)) this.update.apply(this, e3);
85        else {
86          let t4 = 0;
87          switch (typeof e3) {
88            case "undefined":
89            case "function":
90              continue;
91            case "number":
92            case "boolean":
93              t4 = e3;
94              break;
95            case "string":
96              t4 = r2(e3);
97              break;
98            default:
99              e3.updateHashCode ? e3.updateHashCode(this) : console.log("No updateHashCode for " + e3.toString());
100              continue;
101          }
102          t4 *= 3432918353, t4 = t4 << 15 | t4 >>> 17, t4 *= 461845907, this.count = this.count + 1;
103          let n2 = this.hash ^ t4;
104          n2 = n2 << 13 | n2 >>> 19, n2 = 5 * n2 + 3864292196, this.hash = n2;
105        }
106      }
107    }
108    finish() {
109      let t3 = this.hash ^ 4 * this.count;
110      return t3 ^= t3 >>> 16, t3 *= 2246822507, t3 ^= t3 >>> 13, t3 *= 3266489909, t3 ^= t3 >>> 16, t3;
111    }
112    static hashStuff() {
113      const t3 = new o2();
114      return t3.update.apply(t3, arguments), t3.finish();
115    }
116  }
117  function a2(t3) {
118    return t3 ? "string" == typeof t3 ? r2(t3) : t3.hashCode() : -1;
119  }
120  function l2(t3, e3) {
121    return t3 ? t3.equals(e3) : t3 === e3;
122  }
123  function h2(t3) {
124    return null === t3 ? "null" : t3;
125  }
126  function c2(t3) {
127    return Array.isArray(t3) ? "[" + t3.map(h2).join(", ") + "]" : "null";
128  }
129  const u2 = "h-";
130  class d2 {
131    constructor(t3, e3) {
132      this.data = {}, this.hashFunction = t3 || a2, this.equalsFunction = e3 || l2;
133    }
134    add(t3) {
135      const e3 = u2 + this.hashFunction(t3);
136      if (e3 in this.data) {
137        const n2 = this.data[e3];
138        for (let e4 = 0; e4 < n2.length; e4++) if (this.equalsFunction(t3, n2[e4])) return n2[e4];
139        return n2.push(t3), t3;
140      }
141      return this.data[e3] = [t3], t3;
142    }
143    has(t3) {
144      return null != this.get(t3);
145    }
146    get(t3) {
147      const e3 = u2 + this.hashFunction(t3);
148      if (e3 in this.data) {
149        const n2 = this.data[e3];
150        for (let e4 = 0; e4 < n2.length; e4++) if (this.equalsFunction(t3, n2[e4])) return n2[e4];
151      }
152      return null;
153    }
154    values() {
155      return Object.keys(this.data).filter(((t3) => t3.startsWith(u2))).flatMap(((t3) => this.data[t3]), this);
156    }
157    toString() {
158      return c2(this.values());
159    }
160    get length() {
161      return Object.keys(this.data).filter(((t3) => t3.startsWith(u2))).map(((t3) => this.data[t3].length), this).reduce(((t3, e3) => t3 + e3), 0);
162    }
163  }
164  class p2 {
165    hashCode() {
166      const t3 = new o2();
167      return this.updateHashCode(t3), t3.finish();
168    }
169    evaluate(t3, e3) {
170    }
171    evalPrecedence(t3, e3) {
172      return this;
173    }
174    static andContext(t3, e3) {
175      if (null === t3 || t3 === p2.NONE) return e3;
176      if (null === e3 || e3 === p2.NONE) return t3;
177      const n2 = new g2(t3, e3);
178      return 1 === n2.opnds.length ? n2.opnds[0] : n2;
179    }
180    static orContext(t3, e3) {
181      if (null === t3) return e3;
182      if (null === e3) return t3;
183      if (t3 === p2.NONE || e3 === p2.NONE) return p2.NONE;
184      const n2 = new f2(t3, e3);
185      return 1 === n2.opnds.length ? n2.opnds[0] : n2;
186    }
187  }
188  class g2 extends p2 {
189    constructor(t3, e3) {
190      super();
191      const n2 = new d2();
192      t3 instanceof g2 ? t3.opnds.map((function(t4) {
193        n2.add(t4);
194      })) : n2.add(t3), e3 instanceof g2 ? e3.opnds.map((function(t4) {
195        n2.add(t4);
196      })) : n2.add(e3);
197      const s2 = x2(n2);
198      if (s2.length > 0) {
199        let t4 = null;
200        s2.map((function(e4) {
201          (null === t4 || e4.precedence < t4.precedence) && (t4 = e4);
202        })), n2.add(t4);
203      }
204      this.opnds = Array.from(n2.values());
205    }
206    equals(t3) {
207      return this === t3 || t3 instanceof g2 && e2(this.opnds, t3.opnds);
208    }
209    updateHashCode(t3) {
210      t3.update(this.opnds, "AND");
211    }
212    evaluate(t3, e3) {
213      for (let n2 = 0; n2 < this.opnds.length; n2++) if (!this.opnds[n2].evaluate(t3, e3)) return false;
214      return true;
215    }
216    evalPrecedence(t3, e3) {
217      let n2 = false;
218      const s2 = [];
219      for (let i4 = 0; i4 < this.opnds.length; i4++) {
220        const r3 = this.opnds[i4], o3 = r3.evalPrecedence(t3, e3);
221        if (n2 |= o3 !== r3, null === o3) return null;
222        o3 !== p2.NONE && s2.push(o3);
223      }
224      if (!n2) return this;
225      if (0 === s2.length) return p2.NONE;
226      let i3 = null;
227      return s2.map((function(t4) {
228        i3 = null === i3 ? t4 : p2.andContext(i3, t4);
229      })), i3;
230    }
231    toString() {
232      const t3 = this.opnds.map(((t4) => t4.toString()));
233      return (t3.length > 3 ? t3.slice(3) : t3).join("&&");
234    }
235  }
236  class f2 extends p2 {
237    constructor(t3, e3) {
238      super();
239      const n2 = new d2();
240      t3 instanceof f2 ? t3.opnds.map((function(t4) {
241        n2.add(t4);
242      })) : n2.add(t3), e3 instanceof f2 ? e3.opnds.map((function(t4) {
243        n2.add(t4);
244      })) : n2.add(e3);
245      const s2 = x2(n2);
246      if (s2.length > 0) {
247        const t4 = s2.sort((function(t5, e5) {
248          return t5.compareTo(e5);
249        })), e4 = t4[t4.length - 1];
250        n2.add(e4);
251      }
252      this.opnds = Array.from(n2.values());
253    }
254    equals(t3) {
255      return this === t3 || t3 instanceof f2 && e2(this.opnds, t3.opnds);
256    }
257    updateHashCode(t3) {
258      t3.update(this.opnds, "OR");
259    }
260    evaluate(t3, e3) {
261      for (let n2 = 0; n2 < this.opnds.length; n2++) if (this.opnds[n2].evaluate(t3, e3)) return true;
262      return false;
263    }
264    evalPrecedence(t3, e3) {
265      let n2 = false;
266      const s2 = [];
267      for (let i3 = 0; i3 < this.opnds.length; i3++) {
268        const r3 = this.opnds[i3], o3 = r3.evalPrecedence(t3, e3);
269        if (n2 |= o3 !== r3, o3 === p2.NONE) return p2.NONE;
270        null !== o3 && s2.push(o3);
271      }
272      if (!n2) return this;
273      if (0 === s2.length) return null;
274      return s2.map((function(t4) {
275        return t4;
276      })), null;
277    }
278    toString() {
279      const t3 = this.opnds.map(((t4) => t4.toString()));
280      return (t3.length > 3 ? t3.slice(3) : t3).join("||");
281    }
282  }
283  function x2(t3) {
284    const e3 = [];
285    return t3.values().map((function(t4) {
286      t4 instanceof p2.PrecedencePredicate && e3.push(t4);
287    })), e3;
288  }
289  function T2(t3, e3) {
290    if (null === t3) {
291      const t4 = { state: null, alt: null, context: null, semanticContext: null };
292      return e3 && (t4.reachesIntoOuterContext = 0), t4;
293    }
294    {
295      const n2 = {};
296      return n2.state = t3.state || null, n2.alt = void 0 === t3.alt ? null : t3.alt, n2.context = t3.context || null, n2.semanticContext = t3.semanticContext || null, e3 && (n2.reachesIntoOuterContext = t3.reachesIntoOuterContext || 0, n2.precedenceFilterSuppressed = t3.precedenceFilterSuppressed || false), n2;
297    }
298  }
299  class S2 {
300    constructor(t3, e3) {
301      this.checkContext(t3, e3), t3 = T2(t3), e3 = T2(e3, true), this.state = null !== t3.state ? t3.state : e3.state, this.alt = null !== t3.alt ? t3.alt : e3.alt, this.context = null !== t3.context ? t3.context : e3.context, this.semanticContext = null !== t3.semanticContext ? t3.semanticContext : null !== e3.semanticContext ? e3.semanticContext : p2.NONE, this.reachesIntoOuterContext = e3.reachesIntoOuterContext, this.precedenceFilterSuppressed = e3.precedenceFilterSuppressed;
302    }
303    checkContext(t3, e3) {
304      null !== t3.context && void 0 !== t3.context || null !== e3 && null !== e3.context && void 0 !== e3.context || (this.context = null);
305    }
306    hashCode() {
307      const t3 = new o2();
308      return this.updateHashCode(t3), t3.finish();
309    }
310    updateHashCode(t3) {
311      t3.update(this.state.stateNumber, this.alt, this.context, this.semanticContext);
312    }
313    equals(t3) {
314      return this === t3 || t3 instanceof S2 && this.state.stateNumber === t3.state.stateNumber && this.alt === t3.alt && (null === this.context ? null === t3.context : this.context.equals(t3.context)) && this.semanticContext.equals(t3.semanticContext) && this.precedenceFilterSuppressed === t3.precedenceFilterSuppressed;
315    }
316    hashCodeForConfigSet() {
317      const t3 = new o2();
318      return t3.update(this.state.stateNumber, this.alt, this.semanticContext), t3.finish();
319    }
320    equalsForConfigSet(t3) {
321      return this === t3 || t3 instanceof S2 && this.state.stateNumber === t3.state.stateNumber && this.alt === t3.alt && this.semanticContext.equals(t3.semanticContext);
322    }
323    toString() {
324      return "(" + this.state + "," + this.alt + (null !== this.context ? ",[" + this.context.toString() + "]" : "") + (this.semanticContext !== p2.NONE ? "," + this.semanticContext.toString() : "") + (this.reachesIntoOuterContext > 0 ? ",up=" + this.reachesIntoOuterContext : "") + ")";
325    }
326  }
327  class m2 {
328    constructor(t3, e3) {
329      this.start = t3, this.stop = e3;
330    }
331    clone() {
332      return new m2(this.start, this.stop);
333    }
334    contains(t3) {
335      return t3 >= this.start && t3 < this.stop;
336    }
337    toString() {
338      return this.start === this.stop - 1 ? this.start.toString() : this.start.toString() + ".." + (this.stop - 1).toString();
339    }
340    get length() {
341      return this.stop - this.start;
342    }
343  }
344  m2.INVALID_INTERVAL = new m2(-1, -2);
345  class E2 {
346    constructor() {
347      this.intervals = null, this.readOnly = false;
348    }
349    first(e3) {
350      return null === this.intervals || 0 === this.intervals.length ? t2.INVALID_TYPE : this.intervals[0].start;
351    }
352    addOne(t3) {
353      this.addInterval(new m2(t3, t3 + 1));
354    }
355    addRange(t3, e3) {
356      this.addInterval(new m2(t3, e3 + 1));
357    }
358    addInterval(t3) {
359      if (null === this.intervals) this.intervals = [], this.intervals.push(t3.clone());
360      else {
361        for (let e3 = 0; e3 < this.intervals.length; e3++) {
362          const n2 = this.intervals[e3];
363          if (t3.stop < n2.start) return void this.intervals.splice(e3, 0, t3);
364          if (t3.stop === n2.start) return void (this.intervals[e3] = new m2(t3.start, n2.stop));
365          if (t3.start <= n2.stop) return this.intervals[e3] = new m2(Math.min(n2.start, t3.start), Math.max(n2.stop, t3.stop)), void this.reduce(e3);
366        }
367        this.intervals.push(t3.clone());
368      }
369    }
370    addSet(t3) {
371      return null !== t3.intervals && t3.intervals.forEach(((t4) => this.addInterval(t4)), this), this;
372    }
373    reduce(t3) {
374      if (t3 < this.intervals.length - 1) {
375        const e3 = this.intervals[t3], n2 = this.intervals[t3 + 1];
376        e3.stop >= n2.stop ? (this.intervals.splice(t3 + 1, 1), this.reduce(t3)) : e3.stop >= n2.start && (this.intervals[t3] = new m2(e3.start, n2.stop), this.intervals.splice(t3 + 1, 1));
377      }
378    }
379    complement(t3, e3) {
380      const n2 = new E2();
381      return n2.addInterval(new m2(t3, e3 + 1)), null !== this.intervals && this.intervals.forEach(((t4) => n2.removeRange(t4))), n2;
382    }
383    contains(t3) {
384      if (null === this.intervals) return false;
385      for (let e3 = 0; e3 < this.intervals.length; e3++) if (this.intervals[e3].contains(t3)) return true;
386      return false;
387    }
388    removeRange(t3) {
389      if (t3.start === t3.stop - 1) this.removeOne(t3.start);
390      else if (null !== this.intervals) {
391        let e3 = 0;
392        for (let n2 = 0; n2 < this.intervals.length; n2++) {
393          const n3 = this.intervals[e3];
394          if (t3.stop <= n3.start) return;
395          if (t3.start > n3.start && t3.stop < n3.stop) {
396            this.intervals[e3] = new m2(n3.start, t3.start);
397            const s2 = new m2(t3.stop, n3.stop);
398            return void this.intervals.splice(e3, 0, s2);
399          }
400          t3.start <= n3.start && t3.stop >= n3.stop ? (this.intervals.splice(e3, 1), e3 -= 1) : t3.start < n3.stop ? this.intervals[e3] = new m2(n3.start, t3.start) : t3.stop < n3.stop && (this.intervals[e3] = new m2(t3.stop, n3.stop)), e3 += 1;
401        }
402      }
403    }
404    removeOne(t3) {
405      if (null !== this.intervals) for (let e3 = 0; e3 < this.intervals.length; e3++) {
406        const n2 = this.intervals[e3];
407        if (t3 < n2.start) return;
408        if (t3 === n2.start && t3 === n2.stop - 1) return void this.intervals.splice(e3, 1);
409        if (t3 === n2.start) return void (this.intervals[e3] = new m2(n2.start + 1, n2.stop));
410        if (t3 === n2.stop - 1) return void (this.intervals[e3] = new m2(n2.start, n2.stop - 1));
411        if (t3 < n2.stop - 1) {
412          const s2 = new m2(n2.start, t3);
413          return n2.start = t3 + 1, void this.intervals.splice(e3, 0, s2);
414        }
415      }
416    }
417    toString(t3, e3, n2) {
418      return t3 = t3 || null, e3 = e3 || null, n2 = n2 || false, null === this.intervals ? "{}" : null !== t3 || null !== e3 ? this.toTokenString(t3, e3) : n2 ? this.toCharString() : this.toIndexString();
419    }
420    toCharString() {
421      const e3 = [];
422      for (let n2 = 0; n2 < this.intervals.length; n2++) {
423        const s2 = this.intervals[n2];
424        s2.stop === s2.start + 1 ? s2.start === t2.EOF ? e3.push("<EOF>") : e3.push("'" + String.fromCharCode(s2.start) + "'") : e3.push("'" + String.fromCharCode(s2.start) + "'..'" + String.fromCharCode(s2.stop - 1) + "'");
425      }
426      return e3.length > 1 ? "{" + e3.join(", ") + "}" : e3[0];
427    }
428    toIndexString() {
429      const e3 = [];
430      for (let n2 = 0; n2 < this.intervals.length; n2++) {
431        const s2 = this.intervals[n2];
432        s2.stop === s2.start + 1 ? s2.start === t2.EOF ? e3.push("<EOF>") : e3.push(s2.start.toString()) : e3.push(s2.start.toString() + ".." + (s2.stop - 1).toString());
433      }
434      return e3.length > 1 ? "{" + e3.join(", ") + "}" : e3[0];
435    }
436    toTokenString(t3, e3) {
437      const n2 = [];
438      for (let s2 = 0; s2 < this.intervals.length; s2++) {
439        const i3 = this.intervals[s2];
440        for (let s3 = i3.start; s3 < i3.stop; s3++) n2.push(this.elementName(t3, e3, s3));
441      }
442      return n2.length > 1 ? "{" + n2.join(", ") + "}" : n2[0];
443    }
444    elementName(e3, n2, s2) {
445      return s2 === t2.EOF ? "<EOF>" : s2 === t2.EPSILON ? "<EPSILON>" : e3[s2] || n2[s2];
446    }
447    get length() {
448      return this.intervals.map(((t3) => t3.length)).reduce(((t3, e3) => t3 + e3));
449    }
450  }
451  class _2 {
452    constructor() {
453      this.atn = null, this.stateNumber = _2.INVALID_STATE_NUMBER, this.stateType = null, this.ruleIndex = 0, this.epsilonOnlyTransitions = false, this.transitions = [], this.nextTokenWithinRule = null;
454    }
455    toString() {
456      return this.stateNumber;
457    }
458    equals(t3) {
459      return t3 instanceof _2 && this.stateNumber === t3.stateNumber;
460    }
461    isNonGreedyExitState() {
462      return false;
463    }
464    addTransition(t3, e3) {
465      void 0 === e3 && (e3 = -1), 0 === this.transitions.length ? this.epsilonOnlyTransitions = t3.isEpsilon : this.epsilonOnlyTransitions !== t3.isEpsilon && (this.epsilonOnlyTransitions = false), -1 === e3 ? this.transitions.push(t3) : this.transitions.splice(e3, 1, t3);
466    }
467  }
468  _2.INVALID_TYPE = 0, _2.BASIC = 1, _2.RULE_START = 2, _2.BLOCK_START = 3, _2.PLUS_BLOCK_START = 4, _2.STAR_BLOCK_START = 5, _2.TOKEN_START = 6, _2.RULE_STOP = 7, _2.BLOCK_END = 8, _2.STAR_LOOP_BACK = 9, _2.STAR_LOOP_ENTRY = 10, _2.PLUS_LOOP_BACK = 11, _2.LOOP_END = 12, _2.serializationNames = ["INVALID", "BASIC", "RULE_START", "BLOCK_START", "PLUS_BLOCK_START", "STAR_BLOCK_START", "TOKEN_START", "RULE_STOP", "BLOCK_END", "STAR_LOOP_BACK", "STAR_LOOP_ENTRY", "PLUS_LOOP_BACK", "LOOP_END"], _2.INVALID_STATE_NUMBER = -1;
469  class A2 extends _2 {
470    constructor() {
471      return super(), this.stateType = _2.RULE_STOP, this;
472    }
473  }
474  class C2 {
475    constructor(t3) {
476      if (null == t3) throw "target cannot be null.";
477      this.target = t3, this.isEpsilon = false, this.label = null;
478    }
479  }
480  C2.EPSILON = 1, C2.RANGE = 2, C2.RULE = 3, C2.PREDICATE = 4, C2.ATOM = 5, C2.ACTION = 6, C2.SET = 7, C2.NOT_SET = 8, C2.WILDCARD = 9, C2.PRECEDENCE = 10, C2.serializationNames = ["INVALID", "EPSILON", "RANGE", "RULE", "PREDICATE", "ATOM", "ACTION", "SET", "NOT_SET", "WILDCARD", "PRECEDENCE"], C2.serializationTypes = { EpsilonTransition: C2.EPSILON, RangeTransition: C2.RANGE, RuleTransition: C2.RULE, PredicateTransition: C2.PREDICATE, AtomTransition: C2.ATOM, ActionTransition: C2.ACTION, SetTransition: C2.SET, NotSetTransition: C2.NOT_SET, WildcardTransition: C2.WILDCARD, PrecedencePredicateTransition: C2.PRECEDENCE };
481  class N2 extends C2 {
482    constructor(t3, e3, n2, s2) {
483      super(t3), this.ruleIndex = e3, this.precedence = n2, this.followState = s2, this.serializationType = C2.RULE, this.isEpsilon = true;
484    }
485    matches(t3, e3, n2) {
486      return false;
487    }
488  }
489  class y2 extends C2 {
490    constructor(e3, n2) {
491      super(e3), this.serializationType = C2.SET, null != n2 ? this.label = n2 : (this.label = new E2(), this.label.addOne(t2.INVALID_TYPE));
492    }
493    matches(t3, e3, n2) {
494      return this.label.contains(t3);
495    }
496    toString() {
497      return this.label.toString();
498    }
499  }
500  class I2 extends y2 {
501    constructor(t3, e3) {
502      super(t3, e3), this.serializationType = C2.NOT_SET;
503    }
504    matches(t3, e3, n2) {
505      return t3 >= e3 && t3 <= n2 && !super.matches(t3, e3, n2);
506    }
507    toString() {
508      return "~" + super.toString();
509    }
510  }
511  class k2 extends C2 {
512    constructor(t3) {
513      super(t3), this.serializationType = C2.WILDCARD;
514    }
515    matches(t3, e3, n2) {
516      return t3 >= e3 && t3 <= n2;
517    }
518    toString() {
519      return ".";
520    }
521  }
522  class L2 extends C2 {
523    constructor(t3) {
524      super(t3);
525    }
526  }
527  class O2 {
528  }
529  class v2 extends O2 {
530  }
531  class R2 extends v2 {
532  }
533  class w2 extends R2 {
534    get ruleContext() {
535      throw new Error("missing interface implementation");
536    }
537  }
538  class P2 extends R2 {
539  }
540  class b2 extends P2 {
541  }
542  const D2 = { toStringTree: function(t3, e3, n2) {
543    e3 = e3 || null, null !== (n2 = n2 || null) && (e3 = n2.ruleNames);
544    let s2 = D2.getNodeText(t3, e3);
545    s2 = (function(t4, e4) {
546      return t4 = t4.replace(/\t/g, "\\t").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
547    })(s2);
548    const i3 = t3.getChildCount();
549    if (0 === i3) return s2;
550    let r3 = "(" + s2 + " ";
551    i3 > 0 && (s2 = D2.toStringTree(t3.getChild(0), e3), r3 = r3.concat(s2));
552    for (let n3 = 1; n3 < i3; n3++) s2 = D2.toStringTree(t3.getChild(n3), e3), r3 = r3.concat(" " + s2);
553    return r3 = r3.concat(")"), r3;
554  }, getNodeText: function(e3, n2, s2) {
555    if (n2 = n2 || null, null !== (s2 = s2 || null) && (n2 = s2.ruleNames), null !== n2) {
556      if (e3 instanceof w2) {
557        const t3 = e3.ruleContext.getAltNumber();
558        return 0 != t3 ? n2[e3.ruleIndex] + ":" + t3 : n2[e3.ruleIndex];
559      }
560      if (e3 instanceof b2) return e3.toString();
561      if (e3 instanceof P2 && null !== e3.symbol) return e3.symbol.text;
562    }
563    const i3 = e3.getPayload();
564    return i3 instanceof t2 ? i3.text : e3.getPayload().toString();
565  }, getChildren: function(t3) {
566    const e3 = [];
567    for (let n2 = 0; n2 < t3.getChildCount(); n2++) e3.push(t3.getChild(n2));
568    return e3;
569  }, getAncestors: function(t3) {
570    let e3 = [];
571    for (t3 = t3.getParent(); null !== t3; ) e3 = [t3].concat(e3), t3 = t3.getParent();
572    return e3;
573  }, findAllTokenNodes: function(t3, e3) {
574    return D2.findAllNodes(t3, e3, true);
575  }, findAllRuleNodes: function(t3, e3) {
576    return D2.findAllNodes(t3, e3, false);
577  }, findAllNodes: function(t3, e3, n2) {
578    const s2 = [];
579    return D2._findAllNodes(t3, e3, n2, s2), s2;
580  }, _findAllNodes: function(t3, e3, n2, s2) {
581    n2 && t3 instanceof P2 ? t3.symbol.type === e3 && s2.push(t3) : !n2 && t3 instanceof w2 && t3.ruleIndex === e3 && s2.push(t3);
582    for (let i3 = 0; i3 < t3.getChildCount(); i3++) D2._findAllNodes(t3.getChild(i3), e3, n2, s2);
583  }, descendants: function(t3) {
584    let e3 = [t3];
585    for (let n2 = 0; n2 < t3.getChildCount(); n2++) e3 = e3.concat(D2.descendants(t3.getChild(n2)));
586    return e3;
587  } }, F2 = D2;
588  class M2 extends w2 {
589    constructor(t3, e3) {
590      super(), this.parentCtx = t3 || null, this.invokingState = e3 || -1;
591    }
592    depth() {
593      let t3 = 0, e3 = this;
594      for (; null !== e3; ) e3 = e3.parentCtx, t3 += 1;
595      return t3;
596    }
597    isEmpty() {
598      return -1 === this.invokingState;
599    }
600    getSourceInterval() {
601      return m2.INVALID_INTERVAL;
602    }
603    get ruleContext() {
604      return this;
605    }
606    getPayload() {
607      return this;
608    }
609    getText() {
610      return 0 === this.getChildCount() ? "" : this.children.map((function(t3) {
611        return t3.getText();
612      })).join("");
613    }
614    getAltNumber() {
615      return 0;
616    }
617    setAltNumber(t3) {
618    }
619    getChild(t3) {
620      return null;
621    }
622    getChildCount() {
623      return 0;
624    }
625    accept(t3) {
626      return t3.visitChildren(this);
627    }
628    toStringTree(t3, e3) {
629      return F2.toStringTree(this, t3, e3);
630    }
631    toString(t3, e3) {
632      t3 = t3 || null, e3 = e3 || null;
633      let n2 = this, s2 = "[";
634      for (; null !== n2 && n2 !== e3; ) {
635        if (null === t3) n2.isEmpty() || (s2 += n2.invokingState);
636        else {
637          const e4 = n2.ruleIndex;
638          s2 += e4 >= 0 && e4 < t3.length ? t3[e4] : "" + e4;
639        }
640        null === n2.parentCtx || null === t3 && n2.parentCtx.isEmpty() || (s2 += " "), n2 = n2.parentCtx;
641      }
642      return s2 += "]", s2;
643    }
644  }
645  class U {
646    constructor(t3) {
647      this.cachedHashCode = t3;
648    }
649    isEmpty() {
650      return this === U.EMPTY;
651    }
652    hasEmptyPath() {
653      return this.getReturnState(this.length - 1) === U.EMPTY_RETURN_STATE;
654    }
655    hashCode() {
656      return this.cachedHashCode;
657    }
658    updateHashCode(t3) {
659      t3.update(this.cachedHashCode);
660    }
661  }
662  U.EMPTY = null, U.EMPTY_RETURN_STATE = 2147483647, U.globalNodeCount = 1, U.id = U.globalNodeCount, U.trace_atn_sim = false;
663  class B extends U {
664    constructor(t3, e3) {
665      const n2 = new o2();
666      return n2.update(t3, e3), super(n2.finish()), this.parents = t3, this.returnStates = e3, this;
667    }
668    isEmpty() {
669      return this.returnStates[0] === U.EMPTY_RETURN_STATE;
670    }
671    getParent(t3) {
672      return this.parents[t3];
673    }
674    getReturnState(t3) {
675      return this.returnStates[t3];
676    }
677    equals(t3) {
678      return this === t3 || t3 instanceof B && this.hashCode() === t3.hashCode() && e2(this.returnStates, t3.returnStates) && e2(this.parents, t3.parents);
679    }
680    toString() {
681      if (this.isEmpty()) return "[]";
682      {
683        let t3 = "[";
684        for (let e3 = 0; e3 < this.returnStates.length; e3++) e3 > 0 && (t3 += ", "), this.returnStates[e3] !== U.EMPTY_RETURN_STATE ? (t3 += this.returnStates[e3], null !== this.parents[e3] ? t3 = t3 + " " + this.parents[e3] : t3 += "null") : t3 += "$";
685        return t3 + "]";
686      }
687    }
688    get length() {
689      return this.returnStates.length;
690    }
691  }
692  class V extends U {
693    constructor(t3, e3) {
694      let n2 = 0;
695      const s2 = new o2();
696      null !== t3 ? s2.update(t3, e3) : s2.update(1), n2 = s2.finish(), super(n2), this.parentCtx = t3, this.returnState = e3;
697    }
698    getParent(t3) {
699      return this.parentCtx;
700    }
701    getReturnState(t3) {
702      return this.returnState;
703    }
704    equals(t3) {
705      return this === t3 || t3 instanceof V && this.hashCode() === t3.hashCode() && this.returnState === t3.returnState && (null == this.parentCtx ? null == t3.parentCtx : this.parentCtx.equals(t3.parentCtx));
706    }
707    toString() {
708      const t3 = null === this.parentCtx ? "" : this.parentCtx.toString();
709      return 0 === t3.length ? this.returnState === U.EMPTY_RETURN_STATE ? "$" : "" + this.returnState : this.returnState + " " + t3;
710    }
711    get length() {
712      return 1;
713    }
714    static create(t3, e3) {
715      return e3 === U.EMPTY_RETURN_STATE && null === t3 ? U.EMPTY : new V(t3, e3);
716    }
717  }
718  class z extends V {
719    constructor() {
720      super(null, U.EMPTY_RETURN_STATE);
721    }
722    isEmpty() {
723      return true;
724    }
725    getParent(t3) {
726      return null;
727    }
728    getReturnState(t3) {
729      return this.returnState;
730    }
731    equals(t3) {
732      return this === t3;
733    }
734    toString() {
735      return "$";
736    }
737  }
738  U.EMPTY = new z();
739  const q = "h-";
740  class H {
741    constructor(t3, e3) {
742      this.data = {}, this.hashFunction = t3 || a2, this.equalsFunction = e3 || l2;
743    }
744    set(t3, e3) {
745      const n2 = q + this.hashFunction(t3);
746      if (n2 in this.data) {
747        const s2 = this.data[n2];
748        for (let n3 = 0; n3 < s2.length; n3++) {
749          const i3 = s2[n3];
750          if (this.equalsFunction(t3, i3.key)) {
751            const t4 = i3.value;
752            return i3.value = e3, t4;
753          }
754        }
755        return s2.push({ key: t3, value: e3 }), e3;
756      }
757      return this.data[n2] = [{ key: t3, value: e3 }], e3;
758    }
759    containsKey(t3) {
760      const e3 = q + this.hashFunction(t3);
761      if (e3 in this.data) {
762        const n2 = this.data[e3];
763        for (let e4 = 0; e4 < n2.length; e4++) {
764          const s2 = n2[e4];
765          if (this.equalsFunction(t3, s2.key)) return true;
766        }
767      }
768      return false;
769    }
770    get(t3) {
771      const e3 = q + this.hashFunction(t3);
772      if (e3 in this.data) {
773        const n2 = this.data[e3];
774        for (let e4 = 0; e4 < n2.length; e4++) {
775          const s2 = n2[e4];
776          if (this.equalsFunction(t3, s2.key)) return s2.value;
777        }
778      }
779      return null;
780    }
781    entries() {
782      return Object.keys(this.data).filter(((t3) => t3.startsWith(q))).flatMap(((t3) => this.data[t3]), this);
783    }
784    getKeys() {
785      return this.entries().map(((t3) => t3.key));
786    }
787    getValues() {
788      return this.entries().map(((t3) => t3.value));
789    }
790    toString() {
791      return "[" + this.entries().map(((t3) => "{" + t3.key + ":" + t3.value + "}")).join(", ") + "]";
792    }
793    get length() {
794      return Object.keys(this.data).filter(((t3) => t3.startsWith(q))).map(((t3) => this.data[t3].length), this).reduce(((t3, e3) => t3 + e3), 0);
795    }
796  }
797  function K(t3, e3) {
798    if (null == e3 && (e3 = M2.EMPTY), null === e3.parentCtx || e3 === M2.EMPTY) return U.EMPTY;
799    const n2 = K(t3, e3.parentCtx), s2 = t3.states[e3.invokingState].transitions[0];
800    return V.create(n2, s2.followState.stateNumber);
801  }
802  function Y(t3, e3, n2) {
803    if (t3.isEmpty()) return t3;
804    let s2 = n2.get(t3) || null;
805    if (null !== s2) return s2;
806    if (s2 = e3.get(t3), null !== s2) return n2.set(t3, s2), s2;
807    let i3 = false, r3 = [];
808    for (let s3 = 0; s3 < r3.length; s3++) {
809      const o4 = Y(t3.getParent(s3), e3, n2);
810      if (i3 || o4 !== t3.getParent(s3)) {
811        if (!i3) {
812          r3 = [];
813          for (let e4 = 0; e4 < t3.length; e4++) r3[e4] = t3.getParent(e4);
814          i3 = true;
815        }
816        r3[s3] = o4;
817      }
818    }
819    if (!i3) return e3.add(t3), n2.set(t3, t3), t3;
820    let o3 = null;
821    return o3 = 0 === r3.length ? U.EMPTY : 1 === r3.length ? V.create(r3[0], t3.getReturnState(0)) : new B(r3, t3.returnStates), e3.add(o3), n2.set(o3, o3), n2.set(t3, o3), o3;
822  }
823  function G(t3, e3, n2, s2) {
824    if (t3 === e3) return t3;
825    if (t3 instanceof V && e3 instanceof V) return (function(t4, e4, n3, s3) {
826      if (null !== s3) {
827        let n4 = s3.get(t4, e4);
828        if (null !== n4) return n4;
829        if (n4 = s3.get(e4, t4), null !== n4) return n4;
830      }
831      const i3 = (function(t5, e5, n4) {
832        if (n4) {
833          if (t5 === U.EMPTY) return U.EMPTY;
834          if (e5 === U.EMPTY) return U.EMPTY;
835        } else {
836          if (t5 === U.EMPTY && e5 === U.EMPTY) return U.EMPTY;
837          if (t5 === U.EMPTY) {
838            const t6 = [e5.returnState, U.EMPTY_RETURN_STATE], n5 = [e5.parentCtx, null];
839            return new B(n5, t6);
840          }
841          if (e5 === U.EMPTY) {
842            const e6 = [t5.returnState, U.EMPTY_RETURN_STATE], n5 = [t5.parentCtx, null];
843            return new B(n5, e6);
844          }
845        }
846        return null;
847      })(t4, e4, n3);
848      if (null !== i3) return null !== s3 && s3.set(t4, e4, i3), i3;
849      if (t4.returnState === e4.returnState) {
850        const i4 = G(t4.parentCtx, e4.parentCtx, n3, s3);
851        if (i4 === t4.parentCtx) return t4;
852        if (i4 === e4.parentCtx) return e4;
853        const r3 = V.create(i4, t4.returnState);
854        return null !== s3 && s3.set(t4, e4, r3), r3;
855      }
856      {
857        let n4 = null;
858        if ((t4 === e4 || null !== t4.parentCtx && t4.parentCtx === e4.parentCtx) && (n4 = t4.parentCtx), null !== n4) {
859          const i5 = [t4.returnState, e4.returnState];
860          t4.returnState > e4.returnState && (i5[0] = e4.returnState, i5[1] = t4.returnState);
861          const r4 = new B([n4, n4], i5);
862          return null !== s3 && s3.set(t4, e4, r4), r4;
863        }
864        const i4 = [t4.returnState, e4.returnState];
865        let r3 = [t4.parentCtx, e4.parentCtx];
866        t4.returnState > e4.returnState && (i4[0] = e4.returnState, i4[1] = t4.returnState, r3 = [e4.parentCtx, t4.parentCtx]);
867        const o3 = new B(r3, i4);
868        return null !== s3 && s3.set(t4, e4, o3), o3;
869      }
870    })(t3, e3, n2, s2);
871    if (n2) {
872      if (t3 instanceof z) return t3;
873      if (e3 instanceof z) return e3;
874    }
875    return t3 instanceof V && (t3 = new B([t3.getParent()], [t3.returnState])), e3 instanceof V && (e3 = new B([e3.getParent()], [e3.returnState])), (function(t4, e4, n3, s3) {
876      if (null !== s3) {
877        let n4 = s3.get(t4, e4);
878        if (null !== n4) return U.trace_atn_sim && console.log("mergeArrays a=" + t4 + ",b=" + e4 + " -> previous"), n4;
879        if (n4 = s3.get(e4, t4), null !== n4) return U.trace_atn_sim && console.log("mergeArrays a=" + t4 + ",b=" + e4 + " -> previous"), n4;
880      }
881      let i3 = 0, r3 = 0, o3 = 0, a3 = new Array(t4.returnStates.length + e4.returnStates.length).fill(0), l3 = new Array(t4.returnStates.length + e4.returnStates.length).fill(null);
882      for (; i3 < t4.returnStates.length && r3 < e4.returnStates.length; ) {
883        const h4 = t4.parents[i3], c3 = e4.parents[r3];
884        if (t4.returnStates[i3] === e4.returnStates[r3]) {
885          const e5 = t4.returnStates[i3];
886          e5 === U.EMPTY_RETURN_STATE && null === h4 && null === c3 || null !== h4 && null !== c3 && h4 === c3 ? (l3[o3] = h4, a3[o3] = e5) : (l3[o3] = G(h4, c3, n3, s3), a3[o3] = e5), i3 += 1, r3 += 1;
887        } else t4.returnStates[i3] < e4.returnStates[r3] ? (l3[o3] = h4, a3[o3] = t4.returnStates[i3], i3 += 1) : (l3[o3] = c3, a3[o3] = e4.returnStates[r3], r3 += 1);
888        o3 += 1;
889      }
890      if (i3 < t4.returnStates.length) for (let e5 = i3; e5 < t4.returnStates.length; e5++) l3[o3] = t4.parents[e5], a3[o3] = t4.returnStates[e5], o3 += 1;
891      else for (let t5 = r3; t5 < e4.returnStates.length; t5++) l3[o3] = e4.parents[t5], a3[o3] = e4.returnStates[t5], o3 += 1;
892      if (o3 < l3.length) {
893        if (1 === o3) {
894          const n4 = V.create(l3[0], a3[0]);
895          return null !== s3 && s3.set(t4, e4, n4), n4;
896        }
897        l3 = l3.slice(0, o3), a3 = a3.slice(0, o3);
898      }
899      const h3 = new B(l3, a3);
900      return h3.equals(t4) ? (null !== s3 && s3.set(t4, e4, t4), U.trace_atn_sim && console.log("mergeArrays a=" + t4 + ",b=" + e4 + " -> a"), t4) : h3.equals(e4) ? (null !== s3 && s3.set(t4, e4, e4), U.trace_atn_sim && console.log("mergeArrays a=" + t4 + ",b=" + e4 + " -> b"), e4) : ((function(t5) {
901        const e5 = new H();
902        for (let n4 = 0; n4 < t5.length; n4++) {
903          const s4 = t5[n4];
904          e5.containsKey(s4) || e5.set(s4, s4);
905        }
906        for (let n4 = 0; n4 < t5.length; n4++) t5[n4] = e5.get(t5[n4]);
907      })(l3), null !== s3 && s3.set(t4, e4, h3), U.trace_atn_sim && console.log("mergeArrays a=" + t4 + ",b=" + e4 + " -> " + h3), h3);
908    })(t3, e3, n2, s2);
909  }
910  class j {
911    constructor() {
912      this.data = [];
913    }
914    add(t3) {
915      this.data[t3] = true;
916    }
917    or(t3) {
918      Object.keys(t3.data).map(((t4) => this.add(t4)), this);
919    }
920    remove(t3) {
921      delete this.data[t3];
922    }
923    has(t3) {
924      return true === this.data[t3];
925    }
926    values() {
927      return Object.keys(this.data);
928    }
929    minValue() {
930      return Math.min.apply(null, this.values());
931    }
932    hashCode() {
933      return o2.hashStuff(this.values());
934    }
935    equals(t3) {
936      return t3 instanceof j && e2(this.data, t3.data);
937    }
938    toString() {
939      return "{" + this.values().join(", ") + "}";
940    }
941    get length() {
942      return this.values().length;
943    }
944  }
945  class W {
946    constructor(t3) {
947      this.atn = t3;
948    }
949    getDecisionLookahead(t3) {
950      if (null === t3) return null;
951      const e3 = t3.transitions.length, n2 = [];
952      for (let s2 = 0; s2 < e3; s2++) {
953        n2[s2] = new E2();
954        const e4 = new d2(), i3 = false;
955        this._LOOK(t3.transition(s2).target, null, U.EMPTY, n2[s2], e4, new j(), i3, false), (0 === n2[s2].length || n2[s2].contains(W.HIT_PRED)) && (n2[s2] = null);
956      }
957      return n2;
958    }
959    LOOK(t3, e3, n2) {
960      const s2 = new E2(), i3 = null !== (n2 = n2 || null) ? K(t3.atn, n2) : null;
961      return this._LOOK(t3, e3, i3, s2, new d2(), new j(), true, true), s2;
962    }
963    _LOOK(e3, n2, s2, i3, r3, o3, a3, l3) {
964      const h3 = new S2({ state: e3, alt: 0, context: s2 }, null);
965      if (!r3.has(h3)) {
966        if (r3.add(h3), e3 === n2) {
967          if (null === s2) return void i3.addOne(t2.EPSILON);
968          if (s2.isEmpty() && l3) return void i3.addOne(t2.EOF);
969        }
970        if (e3 instanceof A2) {
971          if (null === s2) return void i3.addOne(t2.EPSILON);
972          if (s2.isEmpty() && l3) return void i3.addOne(t2.EOF);
973          if (s2 !== U.EMPTY) {
974            const t3 = o3.has(e3.ruleIndex);
975            try {
976              o3.remove(e3.ruleIndex);
977              for (let t4 = 0; t4 < s2.length; t4++) {
978                const e4 = this.atn.states[s2.getReturnState(t4)];
979                this._LOOK(e4, n2, s2.getParent(t4), i3, r3, o3, a3, l3);
980              }
981            } finally {
982              t3 && o3.add(e3.ruleIndex);
983            }
984            return;
985          }
986        }
987        for (let h4 = 0; h4 < e3.transitions.length; h4++) {
988          const c3 = e3.transitions[h4];
989          if (c3.constructor === N2) {
990            if (o3.has(c3.target.ruleIndex)) continue;
991            const t3 = V.create(s2, c3.followState.stateNumber);
992            try {
993              o3.add(c3.target.ruleIndex), this._LOOK(c3.target, n2, t3, i3, r3, o3, a3, l3);
994            } finally {
995              o3.remove(c3.target.ruleIndex);
996            }
997          } else if (c3 instanceof L2) a3 ? this._LOOK(c3.target, n2, s2, i3, r3, o3, a3, l3) : i3.addOne(W.HIT_PRED);
998          else if (c3.isEpsilon) this._LOOK(c3.target, n2, s2, i3, r3, o3, a3, l3);
999          else if (c3.constructor === k2) i3.addRange(t2.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType);
1000          else {
1001            let e4 = c3.label;
1002            null !== e4 && (c3 instanceof I2 && (e4 = e4.complement(t2.MIN_USER_TOKEN_TYPE, this.atn.maxTokenType)), i3.addSet(e4));
1003          }
1004        }
1005      }
1006    }
1007  }
1008  W.HIT_PRED = t2.INVALID_TYPE;
1009  class $ {
1010    constructor(t3, e3) {
1011      this.grammarType = t3, this.maxTokenType = e3, this.states = [], this.decisionToState = [], this.ruleToStartState = [], this.ruleToStopState = null, this.modeNameToStartState = {}, this.ruleToTokenType = null, this.lexerActions = null, this.modeToStartState = [];
1012    }
1013    nextTokensInContext(t3, e3) {
1014      return new W(this).LOOK(t3, null, e3);
1015    }
1016    nextTokensNoContext(t3) {
1017      return null !== t3.nextTokenWithinRule || (t3.nextTokenWithinRule = this.nextTokensInContext(t3, null), t3.nextTokenWithinRule.readOnly = true), t3.nextTokenWithinRule;
1018    }
1019    nextTokens(t3, e3) {
1020      return void 0 === e3 ? this.nextTokensNoContext(t3) : this.nextTokensInContext(t3, e3);
1021    }
1022    addState(t3) {
1023      null !== t3 && (t3.atn = this, t3.stateNumber = this.states.length), this.states.push(t3);
1024    }
1025    removeState(t3) {
1026      this.states[t3.stateNumber] = null;
1027    }
1028    defineDecisionState(t3) {
1029      return this.decisionToState.push(t3), t3.decision = this.decisionToState.length - 1, t3.decision;
1030    }
1031    getDecisionState(t3) {
1032      return 0 === this.decisionToState.length ? null : this.decisionToState[t3];
1033    }
1034    getExpectedTokens(e3, n2) {
1035      if (e3 < 0 || e3 >= this.states.length) throw "Invalid state number.";
1036      const s2 = this.states[e3];
1037      let i3 = this.nextTokens(s2);
1038      if (!i3.contains(t2.EPSILON)) return i3;
1039      const r3 = new E2();
1040      for (r3.addSet(i3), r3.removeOne(t2.EPSILON); null !== n2 && n2.invokingState >= 0 && i3.contains(t2.EPSILON); ) {
1041        const e4 = this.states[n2.invokingState].transitions[0];
1042        i3 = this.nextTokens(e4.followState), r3.addSet(i3), r3.removeOne(t2.EPSILON), n2 = n2.parentCtx;
1043      }
1044      return i3.contains(t2.EPSILON) && r3.addOne(t2.EOF), r3;
1045    }
1046  }
1047  $.INVALID_ALT_NUMBER = 0;
1048  class X extends _2 {
1049    constructor() {
1050      super(), this.stateType = _2.BASIC;
1051    }
1052  }
1053  class J extends _2 {
1054    constructor() {
1055      return super(), this.decision = -1, this.nonGreedy = false, this;
1056    }
1057  }
1058  class Z extends J {
1059    constructor() {
1060      return super(), this.endState = null, this;
1061    }
1062  }
1063  class Q extends _2 {
1064    constructor() {
1065      return super(), this.stateType = _2.BLOCK_END, this.startState = null, this;
1066    }
1067  }
1068  class tt extends _2 {
1069    constructor() {
1070      return super(), this.stateType = _2.LOOP_END, this.loopBackState = null, this;
1071    }
1072  }
1073  class et extends _2 {
1074    constructor() {
1075      return super(), this.stateType = _2.RULE_START, this.stopState = null, this.isPrecedenceRule = false, this;
1076    }
1077  }
1078  class nt extends J {
1079    constructor() {
1080      return super(), this.stateType = _2.TOKEN_START, this;
1081    }
1082  }
1083  class st extends J {
1084    constructor() {
1085      return super(), this.stateType = _2.PLUS_LOOP_BACK, this;
1086    }
1087  }
1088  class it extends _2 {
1089    constructor() {
1090      return super(), this.stateType = _2.STAR_LOOP_BACK, this;
1091    }
1092  }
1093  class rt extends J {
1094    constructor() {
1095      return super(), this.stateType = _2.STAR_LOOP_ENTRY, this.loopBackState = null, this.isPrecedenceDecision = null, this;
1096    }
1097  }
1098  class ot extends Z {
1099    constructor() {
1100      return super(), this.stateType = _2.PLUS_BLOCK_START, this.loopBackState = null, this;
1101    }
1102  }
1103  class at extends Z {
1104    constructor() {
1105      return super(), this.stateType = _2.STAR_BLOCK_START, this;
1106    }
1107  }
1108  class lt extends Z {
1109    constructor() {
1110      return super(), this.stateType = _2.BLOCK_START, this;
1111    }
1112  }
1113  class ht extends C2 {
1114    constructor(t3, e3) {
1115      super(t3), this.label_ = e3, this.label = this.makeLabel(), this.serializationType = C2.ATOM;
1116    }
1117    makeLabel() {
1118      const t3 = new E2();
1119      return t3.addOne(this.label_), t3;
1120    }
1121    matches(t3, e3, n2) {
1122      return this.label_ === t3;
1123    }
1124    toString() {
1125      return this.label_;
1126    }
1127  }
1128  class ct extends C2 {
1129    constructor(t3, e3, n2) {
1130      super(t3), this.serializationType = C2.RANGE, this.start = e3, this.stop = n2, this.label = this.makeLabel();
1131    }
1132    makeLabel() {
1133      const t3 = new E2();
1134      return t3.addRange(this.start, this.stop), t3;
1135    }
1136    matches(t3, e3, n2) {
1137      return t3 >= this.start && t3 <= this.stop;
1138    }
1139    toString() {
1140      return "'" + String.fromCharCode(this.start) + "'..'" + String.fromCharCode(this.stop) + "'";
1141    }
1142  }
1143  class ut extends C2 {
1144    constructor(t3, e3, n2, s2) {
1145      super(t3), this.serializationType = C2.ACTION, this.ruleIndex = e3, this.actionIndex = void 0 === n2 ? -1 : n2, this.isCtxDependent = void 0 !== s2 && s2, this.isEpsilon = true;
1146    }
1147    matches(t3, e3, n2) {
1148      return false;
1149    }
1150    toString() {
1151      return "action_" + this.ruleIndex + ":" + this.actionIndex;
1152    }
1153  }
1154  class dt extends C2 {
1155    constructor(t3, e3) {
1156      super(t3), this.serializationType = C2.EPSILON, this.isEpsilon = true, this.outermostPrecedenceReturn = e3;
1157    }
1158    matches(t3, e3, n2) {
1159      return false;
1160    }
1161    toString() {
1162      return "epsilon";
1163    }
1164  }
1165  class pt extends p2 {
1166    constructor(t3, e3, n2) {
1167      super(), this.ruleIndex = void 0 === t3 ? -1 : t3, this.predIndex = void 0 === e3 ? -1 : e3, this.isCtxDependent = void 0 !== n2 && n2;
1168    }
1169    evaluate(t3, e3) {
1170      const n2 = this.isCtxDependent ? e3 : null;
1171      return t3.sempred(n2, this.ruleIndex, this.predIndex);
1172    }
1173    updateHashCode(t3) {
1174      t3.update(this.ruleIndex, this.predIndex, this.isCtxDependent);
1175    }
1176    equals(t3) {
1177      return this === t3 || t3 instanceof pt && this.ruleIndex === t3.ruleIndex && this.predIndex === t3.predIndex && this.isCtxDependent === t3.isCtxDependent;
1178    }
1179    toString() {
1180      return "{" + this.ruleIndex + ":" + this.predIndex + "}?";
1181    }
1182  }
1183  p2.NONE = new pt();
1184  class gt extends L2 {
1185    constructor(t3, e3, n2, s2) {
1186      super(t3), this.serializationType = C2.PREDICATE, this.ruleIndex = e3, this.predIndex = n2, this.isCtxDependent = s2, this.isEpsilon = true;
1187    }
1188    matches(t3, e3, n2) {
1189      return false;
1190    }
1191    getPredicate() {
1192      return new pt(this.ruleIndex, this.predIndex, this.isCtxDependent);
1193    }
1194    toString() {
1195      return "pred_" + this.ruleIndex + ":" + this.predIndex;
1196    }
1197  }
1198  class ft extends p2 {
1199    constructor(t3) {
1200      super(), this.precedence = void 0 === t3 ? 0 : t3;
1201    }
1202    evaluate(t3, e3) {
1203      return t3.precpred(e3, this.precedence);
1204    }
1205    evalPrecedence(t3, e3) {
1206      return t3.precpred(e3, this.precedence) ? p2.NONE : null;
1207    }
1208    compareTo(t3) {
1209      return this.precedence - t3.precedence;
1210    }
1211    updateHashCode(t3) {
1212      t3.update(this.precedence);
1213    }
1214    equals(t3) {
1215      return this === t3 || t3 instanceof ft && this.precedence === t3.precedence;
1216    }
1217    toString() {
1218      return "{" + this.precedence + ">=prec}?";
1219    }
1220  }
1221  p2.PrecedencePredicate = ft;
1222  class xt extends L2 {
1223    constructor(t3, e3) {
1224      super(t3), this.serializationType = C2.PRECEDENCE, this.precedence = e3, this.isEpsilon = true;
1225    }
1226    matches(t3, e3, n2) {
1227      return false;
1228    }
1229    getPredicate() {
1230      return new ft(this.precedence);
1231    }
1232    toString() {
1233      return this.precedence + " >= _p";
1234    }
1235  }
1236  class Tt {
1237    constructor(t3) {
1238      void 0 === t3 && (t3 = null), this.readOnly = false, this.verifyATN = null === t3 || t3.verifyATN, this.generateRuleBypassTransitions = null !== t3 && t3.generateRuleBypassTransitions;
1239    }
1240  }
1241  Tt.defaultOptions = new Tt(), Tt.defaultOptions.readOnly = true;
1242  class St {
1243    constructor(t3) {
1244      this.actionType = t3, this.isPositionDependent = false;
1245    }
1246    hashCode() {
1247      const t3 = new o2();
1248      return this.updateHashCode(t3), t3.finish();
1249    }
1250    updateHashCode(t3) {
1251      t3.update(this.actionType);
1252    }
1253    equals(t3) {
1254      return this === t3;
1255    }
1256  }
1257  class mt extends St {
1258    constructor() {
1259      super(6);
1260    }
1261    execute(t3) {
1262      t3.skip();
1263    }
1264    toString() {
1265      return "skip";
1266    }
1267  }
1268  mt.INSTANCE = new mt();
1269  class Et extends St {
1270    constructor(t3) {
1271      super(0), this.channel = t3;
1272    }
1273    execute(t3) {
1274      t3._channel = this.channel;
1275    }
1276    updateHashCode(t3) {
1277      t3.update(this.actionType, this.channel);
1278    }
1279    equals(t3) {
1280      return this === t3 || t3 instanceof Et && this.channel === t3.channel;
1281    }
1282    toString() {
1283      return "channel(" + this.channel + ")";
1284    }
1285  }
1286  class _t extends St {
1287    constructor(t3, e3) {
1288      super(1), this.ruleIndex = t3, this.actionIndex = e3, this.isPositionDependent = true;
1289    }
1290    execute(t3) {
1291      t3.action(null, this.ruleIndex, this.actionIndex);
1292    }
1293    updateHashCode(t3) {
1294      t3.update(this.actionType, this.ruleIndex, this.actionIndex);
1295    }
1296    equals(t3) {
1297      return this === t3 || t3 instanceof _t && this.ruleIndex === t3.ruleIndex && this.actionIndex === t3.actionIndex;
1298    }
1299  }
1300  class At extends St {
1301    constructor() {
1302      super(3);
1303    }
1304    execute(t3) {
1305      t3.more();
1306    }
1307    toString() {
1308      return "more";
1309    }
1310  }
1311  At.INSTANCE = new At();
1312  class Ct extends St {
1313    constructor(t3) {
1314      super(7), this.type = t3;
1315    }
1316    execute(t3) {
1317      t3.type = this.type;
1318    }
1319    updateHashCode(t3) {
1320      t3.update(this.actionType, this.type);
1321    }
1322    equals(t3) {
1323      return this === t3 || t3 instanceof Ct && this.type === t3.type;
1324    }
1325    toString() {
1326      return "type(" + this.type + ")";
1327    }
1328  }
1329  class Nt extends St {
1330    constructor(t3) {
1331      super(5), this.mode = t3;
1332    }
1333    execute(t3) {
1334      t3.pushMode(this.mode);
1335    }
1336    updateHashCode(t3) {
1337      t3.update(this.actionType, this.mode);
1338    }
1339    equals(t3) {
1340      return this === t3 || t3 instanceof Nt && this.mode === t3.mode;
1341    }
1342    toString() {
1343      return "pushMode(" + this.mode + ")";
1344    }
1345  }
1346  class yt extends St {
1347    constructor() {
1348      super(4);
1349    }
1350    execute(t3) {
1351      t3.popMode();
1352    }
1353    toString() {
1354      return "popMode";
1355    }
1356  }
1357  yt.INSTANCE = new yt();
1358  class It extends St {
1359    constructor(t3) {
1360      super(2), this.mode = t3;
1361    }
1362    execute(t3) {
1363      t3.mode(this.mode);
1364    }
1365    updateHashCode(t3) {
1366      t3.update(this.actionType, this.mode);
1367    }
1368    equals(t3) {
1369      return this === t3 || t3 instanceof It && this.mode === t3.mode;
1370    }
1371    toString() {
1372      return "mode(" + this.mode + ")";
1373    }
1374  }
1375  function kt(t3, e3) {
1376    const n2 = [];
1377    return n2[t3 - 1] = e3, n2.map((function(t4) {
1378      return e3;
1379    }));
1380  }
1381  class Lt {
1382    constructor(t3) {
1383      null == t3 && (t3 = Tt.defaultOptions), this.deserializationOptions = t3, this.stateFactories = null, this.actionFactories = null;
1384    }
1385    deserialize(t3) {
1386      const e3 = this.reset(t3);
1387      this.checkVersion(e3), e3 && this.skipUUID();
1388      const n2 = this.readATN();
1389      this.readStates(n2, e3), this.readRules(n2, e3), this.readModes(n2);
1390      const s2 = [];
1391      return this.readSets(n2, s2, this.readInt.bind(this)), e3 && this.readSets(n2, s2, this.readInt32.bind(this)), this.readEdges(n2, s2), this.readDecisions(n2), this.readLexerActions(n2, e3), this.markPrecedenceDecisions(n2), this.verifyATN(n2), this.deserializationOptions.generateRuleBypassTransitions && 1 === n2.grammarType && (this.generateRuleBypassTransitions(n2), this.verifyATN(n2)), n2;
1392    }
1393    reset(t3) {
1394      if (3 === (t3.charCodeAt ? t3.charCodeAt(0) : t3[0])) {
1395        const e3 = function(t4) {
1396          const e4 = t4.charCodeAt(0);
1397          return e4 > 1 ? e4 - 2 : e4 + 65534;
1398        }, n2 = t3.split("").map(e3);
1399        return n2[0] = t3.charCodeAt(0), this.data = n2, this.pos = 0, true;
1400      }
1401      return this.data = t3, this.pos = 0, false;
1402    }
1403    skipUUID() {
1404      let t3 = 0;
1405      for (; t3++ < 8; ) this.readInt();
1406    }
1407    checkVersion(t3) {
1408      const e3 = this.readInt();
1409      if (!t3 && 4 !== e3) throw "Could not deserialize ATN with version " + e3 + " (expected 4).";
1410    }
1411    readATN() {
1412      const t3 = this.readInt(), e3 = this.readInt();
1413      return new $(t3, e3);
1414    }
1415    readStates(t3, e3) {
1416      let n2, s2, i3;
1417      const r3 = [], o3 = [], a3 = this.readInt();
1418      for (let n3 = 0; n3 < a3; n3++) {
1419        const n4 = this.readInt();
1420        if (n4 === _2.INVALID_TYPE) {
1421          t3.addState(null);
1422          continue;
1423        }
1424        let s3 = this.readInt();
1425        e3 && 65535 === s3 && (s3 = -1);
1426        const i4 = this.stateFactory(n4, s3);
1427        if (n4 === _2.LOOP_END) {
1428          const t4 = this.readInt();
1429          r3.push([i4, t4]);
1430        } else if (i4 instanceof Z) {
1431          const t4 = this.readInt();
1432          o3.push([i4, t4]);
1433        }
1434        t3.addState(i4);
1435      }
1436      for (n2 = 0; n2 < r3.length; n2++) s2 = r3[n2], s2[0].loopBackState = t3.states[s2[1]];
1437      for (n2 = 0; n2 < o3.length; n2++) s2 = o3[n2], s2[0].endState = t3.states[s2[1]];
1438      let l3 = this.readInt();
1439      for (n2 = 0; n2 < l3; n2++) i3 = this.readInt(), t3.states[i3].nonGreedy = true;
1440      let h3 = this.readInt();
1441      for (n2 = 0; n2 < h3; n2++) i3 = this.readInt(), t3.states[i3].isPrecedenceRule = true;
1442    }
1443    readRules(e3, n2) {
1444      let s2;
1445      const i3 = this.readInt();
1446      for (0 === e3.grammarType && (e3.ruleToTokenType = kt(i3, 0)), e3.ruleToStartState = kt(i3, 0), s2 = 0; s2 < i3; s2++) {
1447        const i4 = this.readInt();
1448        if (e3.ruleToStartState[s2] = e3.states[i4], 0 === e3.grammarType) {
1449          let i5 = this.readInt();
1450          n2 && 65535 === i5 && (i5 = t2.EOF), e3.ruleToTokenType[s2] = i5;
1451        }
1452      }
1453      for (e3.ruleToStopState = kt(i3, 0), s2 = 0; s2 < e3.states.length; s2++) {
1454        const t3 = e3.states[s2];
1455        t3 instanceof A2 && (e3.ruleToStopState[t3.ruleIndex] = t3, e3.ruleToStartState[t3.ruleIndex].stopState = t3);
1456      }
1457    }
1458    readModes(t3) {
1459      const e3 = this.readInt();
1460      for (let n2 = 0; n2 < e3; n2++) {
1461        let e4 = this.readInt();
1462        t3.modeToStartState.push(t3.states[e4]);
1463      }
1464    }
1465    readSets(t3, e3, n2) {
1466      const s2 = this.readInt();
1467      for (let t4 = 0; t4 < s2; t4++) {
1468        const t5 = new E2();
1469        e3.push(t5);
1470        const s3 = this.readInt();
1471        0 !== this.readInt() && t5.addOne(-1);
1472        for (let e4 = 0; e4 < s3; e4++) {
1473          const e5 = n2(), s4 = n2();
1474          t5.addRange(e5, s4);
1475        }
1476      }
1477    }
1478    readEdges(t3, e3) {
1479      let n2, s2, i3, r3, o3;
1480      const a3 = this.readInt();
1481      for (n2 = 0; n2 < a3; n2++) {
1482        const n3 = this.readInt(), s3 = this.readInt(), i4 = this.readInt(), o4 = this.readInt(), a4 = this.readInt(), l3 = this.readInt();
1483        r3 = this.edgeFactory(t3, i4, n3, s3, o4, a4, l3, e3), t3.states[n3].addTransition(r3);
1484      }
1485      for (n2 = 0; n2 < t3.states.length; n2++) for (i3 = t3.states[n2], s2 = 0; s2 < i3.transitions.length; s2++) {
1486        const e4 = i3.transitions[s2];
1487        if (!(e4 instanceof N2)) continue;
1488        let n3 = -1;
1489        t3.ruleToStartState[e4.target.ruleIndex].isPrecedenceRule && 0 === e4.precedence && (n3 = e4.target.ruleIndex), r3 = new dt(e4.followState, n3), t3.ruleToStopState[e4.target.ruleIndex].addTransition(r3);
1490      }
1491      for (n2 = 0; n2 < t3.states.length; n2++) {
1492        if (i3 = t3.states[n2], i3 instanceof Z) {
1493          if (null === i3.endState) throw "IllegalState";
1494          if (null !== i3.endState.startState) throw "IllegalState";
1495          i3.endState.startState = i3;
1496        }
1497        if (i3 instanceof st) for (s2 = 0; s2 < i3.transitions.length; s2++) o3 = i3.transitions[s2].target, o3 instanceof ot && (o3.loopBackState = i3);
1498        else if (i3 instanceof it) for (s2 = 0; s2 < i3.transitions.length; s2++) o3 = i3.transitions[s2].target, o3 instanceof rt && (o3.loopBackState = i3);
1499      }
1500    }
1501    readDecisions(t3) {
1502      const e3 = this.readInt();
1503      for (let n2 = 0; n2 < e3; n2++) {
1504        const e4 = this.readInt(), s2 = t3.states[e4];
1505        t3.decisionToState.push(s2), s2.decision = n2;
1506      }
1507    }
1508    readLexerActions(t3, e3) {
1509      if (0 === t3.grammarType) {
1510        const n2 = this.readInt();
1511        t3.lexerActions = kt(n2, null);
1512        for (let s2 = 0; s2 < n2; s2++) {
1513          const n3 = this.readInt();
1514          let i3 = this.readInt();
1515          e3 && 65535 === i3 && (i3 = -1);
1516          let r3 = this.readInt();
1517          e3 && 65535 === r3 && (r3 = -1), t3.lexerActions[s2] = this.lexerActionFactory(n3, i3, r3);
1518        }
1519      }
1520    }
1521    generateRuleBypassTransitions(t3) {
1522      let e3;
1523      const n2 = t3.ruleToStartState.length;
1524      for (e3 = 0; e3 < n2; e3++) t3.ruleToTokenType[e3] = t3.maxTokenType + e3 + 1;
1525      for (e3 = 0; e3 < n2; e3++) this.generateRuleBypassTransition(t3, e3);
1526    }
1527    generateRuleBypassTransition(t3, e3) {
1528      let n2, s2;
1529      const i3 = new lt();
1530      i3.ruleIndex = e3, t3.addState(i3);
1531      const r3 = new Q();
1532      r3.ruleIndex = e3, t3.addState(r3), i3.endState = r3, t3.defineDecisionState(i3), r3.startState = i3;
1533      let o3 = null, a3 = null;
1534      if (t3.ruleToStartState[e3].isPrecedenceRule) {
1535        for (a3 = null, n2 = 0; n2 < t3.states.length; n2++) if (s2 = t3.states[n2], this.stateIsEndStateFor(s2, e3)) {
1536          a3 = s2, o3 = s2.loopBackState.transitions[0];
1537          break;
1538        }
1539        if (null === o3) throw "Couldn't identify final state of the precedence rule prefix section.";
1540      } else a3 = t3.ruleToStopState[e3];
1541      for (n2 = 0; n2 < t3.states.length; n2++) {
1542        s2 = t3.states[n2];
1543        for (let t4 = 0; t4 < s2.transitions.length; t4++) {
1544          const e4 = s2.transitions[t4];
1545          e4 !== o3 && e4.target === a3 && (e4.target = r3);
1546        }
1547      }
1548      const l3 = t3.ruleToStartState[e3], h3 = l3.transitions.length;
1549      for (; h3 > 0; ) i3.addTransition(l3.transitions[h3 - 1]), l3.transitions = l3.transitions.slice(-1);
1550      t3.ruleToStartState[e3].addTransition(new dt(i3)), r3.addTransition(new dt(a3));
1551      const c3 = new X();
1552      t3.addState(c3), c3.addTransition(new ht(r3, t3.ruleToTokenType[e3])), i3.addTransition(new dt(c3));
1553    }
1554    stateIsEndStateFor(t3, e3) {
1555      if (t3.ruleIndex !== e3) return null;
1556      if (!(t3 instanceof rt)) return null;
1557      const n2 = t3.transitions[t3.transitions.length - 1].target;
1558      return n2 instanceof tt && n2.epsilonOnlyTransitions && n2.transitions[0].target instanceof A2 ? t3 : null;
1559    }
1560    markPrecedenceDecisions(t3) {
1561      for (let e3 = 0; e3 < t3.states.length; e3++) {
1562        const n2 = t3.states[e3];
1563        if (n2 instanceof rt && t3.ruleToStartState[n2.ruleIndex].isPrecedenceRule) {
1564          const t4 = n2.transitions[n2.transitions.length - 1].target;
1565          t4 instanceof tt && t4.epsilonOnlyTransitions && t4.transitions[0].target instanceof A2 && (n2.isPrecedenceDecision = true);
1566        }
1567      }
1568    }
1569    verifyATN(t3) {
1570      if (this.deserializationOptions.verifyATN) for (let e3 = 0; e3 < t3.states.length; e3++) {
1571        const n2 = t3.states[e3];
1572        if (null !== n2) if (this.checkCondition(n2.epsilonOnlyTransitions || n2.transitions.length <= 1), n2 instanceof ot) this.checkCondition(null !== n2.loopBackState);
1573        else if (n2 instanceof rt) if (this.checkCondition(null !== n2.loopBackState), this.checkCondition(2 === n2.transitions.length), n2.transitions[0].target instanceof at) this.checkCondition(n2.transitions[1].target instanceof tt), this.checkCondition(!n2.nonGreedy);
1574        else {
1575          if (!(n2.transitions[0].target instanceof tt)) throw "IllegalState";
1576          this.checkCondition(n2.transitions[1].target instanceof at), this.checkCondition(n2.nonGreedy);
1577        }
1578        else n2 instanceof it ? (this.checkCondition(1 === n2.transitions.length), this.checkCondition(n2.transitions[0].target instanceof rt)) : n2 instanceof tt ? this.checkCondition(null !== n2.loopBackState) : n2 instanceof et ? this.checkCondition(null !== n2.stopState) : n2 instanceof Z ? this.checkCondition(null !== n2.endState) : n2 instanceof Q ? this.checkCondition(null !== n2.startState) : n2 instanceof J ? this.checkCondition(n2.transitions.length <= 1 || n2.decision >= 0) : this.checkCondition(n2.transitions.length <= 1 || n2 instanceof A2);
1579      }
1580    }
1581    checkCondition(t3, e3) {
1582      if (!t3) throw null == e3 && (e3 = "IllegalState"), e3;
1583    }
1584    readInt() {
1585      return this.data[this.pos++];
1586    }
1587    readInt32() {
1588      return this.readInt() | this.readInt() << 16;
1589    }
1590    edgeFactory(e3, n2, s2, i3, r3, o3, a3, l3) {
1591      const h3 = e3.states[i3];
1592      switch (n2) {
1593        case C2.EPSILON:
1594          return new dt(h3);
1595        case C2.RANGE:
1596          return new ct(h3, 0 !== a3 ? t2.EOF : r3, o3);
1597        case C2.RULE:
1598          return new N2(e3.states[r3], o3, a3, h3);
1599        case C2.PREDICATE:
1600          return new gt(h3, r3, o3, 0 !== a3);
1601        case C2.PRECEDENCE:
1602          return new xt(h3, r3);
1603        case C2.ATOM:
1604          return new ht(h3, 0 !== a3 ? t2.EOF : r3);
1605        case C2.ACTION:
1606          return new ut(h3, r3, o3, 0 !== a3);
1607        case C2.SET:
1608          return new y2(h3, l3[r3]);
1609        case C2.NOT_SET:
1610          return new I2(h3, l3[r3]);
1611        case C2.WILDCARD:
1612          return new k2(h3);
1613        default:
1614          throw "The specified transition type: " + n2 + " is not valid.";
1615      }
1616    }
1617    stateFactory(t3, e3) {
1618      if (null === this.stateFactories) {
1619        const t4 = [];
1620        t4[_2.INVALID_TYPE] = null, t4[_2.BASIC] = () => new X(), t4[_2.RULE_START] = () => new et(), t4[_2.BLOCK_START] = () => new lt(), t4[_2.PLUS_BLOCK_START] = () => new ot(), t4[_2.STAR_BLOCK_START] = () => new at(), t4[_2.TOKEN_START] = () => new nt(), t4[_2.RULE_STOP] = () => new A2(), t4[_2.BLOCK_END] = () => new Q(), t4[_2.STAR_LOOP_BACK] = () => new it(), t4[_2.STAR_LOOP_ENTRY] = () => new rt(), t4[_2.PLUS_LOOP_BACK] = () => new st(), t4[_2.LOOP_END] = () => new tt(), this.stateFactories = t4;
1621      }
1622      if (t3 > this.stateFactories.length || null === this.stateFactories[t3]) throw "The specified state type " + t3 + " is not valid.";
1623      {
1624        const n2 = this.stateFactories[t3]();
1625        if (null !== n2) return n2.ruleIndex = e3, n2;
1626      }
1627    }
1628    lexerActionFactory(t3, e3, n2) {
1629      if (null === this.actionFactories) {
1630        const t4 = [];
1631        t4[0] = (t5, e4) => new Et(t5), t4[1] = (t5, e4) => new _t(t5, e4), t4[2] = (t5, e4) => new It(t5), t4[3] = (t5, e4) => At.INSTANCE, t4[4] = (t5, e4) => yt.INSTANCE, t4[5] = (t5, e4) => new Nt(t5), t4[6] = (t5, e4) => mt.INSTANCE, t4[7] = (t5, e4) => new Ct(t5), this.actionFactories = t4;
1632      }
1633      if (t3 > this.actionFactories.length || null === this.actionFactories[t3]) throw "The specified lexer action type " + t3 + " is not valid.";
1634      return this.actionFactories[t3](e3, n2);
1635    }
1636  }
1637  class Ot {
1638    syntaxError(t3, e3, n2, s2, i3, r3) {
1639    }
1640    reportAmbiguity(t3, e3, n2, s2, i3, r3, o3) {
1641    }
1642    reportAttemptingFullContext(t3, e3, n2, s2, i3, r3) {
1643    }
1644    reportContextSensitivity(t3, e3, n2, s2, i3, r3) {
1645    }
1646  }
1647  class vt extends Ot {
1648    constructor() {
1649      super();
1650    }
1651    syntaxError(t3, e3, n2, s2, i3, r3) {
1652      console.error("line " + n2 + ":" + s2 + " " + i3);
1653    }
1654  }
1655  vt.INSTANCE = new vt();
1656  class Rt extends Ot {
1657    constructor(t3) {
1658      if (super(), null === t3) throw "delegates";
1659      return this.delegates = t3, this;
1660    }
1661    syntaxError(t3, e3, n2, s2, i3, r3) {
1662      this.delegates.map(((o3) => o3.syntaxError(t3, e3, n2, s2, i3, r3)));
1663    }
1664    reportAmbiguity(t3, e3, n2, s2, i3, r3, o3) {
1665      this.delegates.map(((a3) => a3.reportAmbiguity(t3, e3, n2, s2, i3, r3, o3)));
1666    }
1667    reportAttemptingFullContext(t3, e3, n2, s2, i3, r3) {
1668      this.delegates.map(((o3) => o3.reportAttemptingFullContext(t3, e3, n2, s2, i3, r3)));
1669    }
1670    reportContextSensitivity(t3, e3, n2, s2, i3, r3) {
1671      this.delegates.map(((o3) => o3.reportContextSensitivity(t3, e3, n2, s2, i3, r3)));
1672    }
1673  }
1674  class wt {
1675    constructor() {
1676      this._listeners = [vt.INSTANCE], this._interp = null, this._stateNumber = -1;
1677    }
1678    checkVersion(t3) {
1679      const e3 = "4.13.1";
1680      e3 !== t3 && console.log("ANTLR runtime and generated code versions disagree: " + e3 + "!=" + t3);
1681    }
1682    addErrorListener(t3) {
1683      this._listeners.push(t3);
1684    }
1685    removeErrorListeners() {
1686      this._listeners = [];
1687    }
1688    getLiteralNames() {
1689      return Object.getPrototypeOf(this).constructor.literalNames || [];
1690    }
1691    getSymbolicNames() {
1692      return Object.getPrototypeOf(this).constructor.symbolicNames || [];
1693    }
1694    getTokenNames() {
1695      if (!this.tokenNames) {
1696        const t3 = this.getLiteralNames(), e3 = this.getSymbolicNames(), n2 = t3.length > e3.length ? t3.length : e3.length;
1697        this.tokenNames = [];
1698        for (let s2 = 0; s2 < n2; s2++) this.tokenNames[s2] = t3[s2] || e3[s2] || "<INVALID";
1699      }
1700      return this.tokenNames;
1701    }
1702    getTokenTypeMap() {
1703      const e3 = this.getTokenNames();
1704      if (null === e3) throw "The current recognizer does not provide a list of token names.";
1705      let n2 = this.tokenTypeMapCache[e3];
1706      return void 0 === n2 && (n2 = e3.reduce((function(t3, e4, n3) {
1707        t3[e4] = n3;
1708      })), n2.EOF = t2.EOF, this.tokenTypeMapCache[e3] = n2), n2;
1709    }
1710    getRuleIndexMap() {
1711      const t3 = this.ruleNames;
1712      if (null === t3) throw "The current recognizer does not provide a list of rule names.";
1713      let e3 = this.ruleIndexMapCache[t3];
1714      return void 0 === e3 && (e3 = t3.reduce((function(t4, e4, n2) {
1715        t4[e4] = n2;
1716      })), this.ruleIndexMapCache[t3] = e3), e3;
1717    }
1718    getTokenType(e3) {
1719      const n2 = this.getTokenTypeMap()[e3];
1720      return void 0 !== n2 ? n2 : t2.INVALID_TYPE;
1721    }
1722    getErrorHeader(t3) {
1723      return "line " + t3.getOffendingToken().line + ":" + t3.getOffendingToken().column;
1724    }
1725    getTokenErrorDisplay(e3) {
1726      if (null === e3) return "<no token>";
1727      let n2 = e3.text;
1728      return null === n2 && (n2 = e3.type === t2.EOF ? "<EOF>" : "<" + e3.type + ">"), n2 = n2.replace("\n", "\\n").replace("\r", "\\r").replace("	", "\\t"), "'" + n2 + "'";
1729    }
1730    getErrorListenerDispatch() {
1731      return new Rt(this._listeners);
1732    }
1733    sempred(t3, e3, n2) {
1734      return true;
1735    }
1736    precpred(t3, e3) {
1737      return true;
1738    }
1739    get atn() {
1740      return this._interp.atn;
1741    }
1742    get state() {
1743      return this._stateNumber;
1744    }
1745    set state(t3) {
1746      this._stateNumber = t3;
1747    }
1748  }
1749  wt.tokenTypeMapCache = {}, wt.ruleIndexMapCache = {};
1750  class Pt extends t2 {
1751    constructor(e3, n2, s2, i3, r3) {
1752      super(), this.source = void 0 !== e3 ? e3 : Pt.EMPTY_SOURCE, this.type = void 0 !== n2 ? n2 : null, this.channel = void 0 !== s2 ? s2 : t2.DEFAULT_CHANNEL, this.start = void 0 !== i3 ? i3 : -1, this.stop = void 0 !== r3 ? r3 : -1, this.tokenIndex = -1, null !== this.source[0] ? (this.line = e3[0].line, this.column = e3[0].column) : this.column = -1;
1753    }
1754    clone() {
1755      const t3 = new Pt(this.source, this.type, this.channel, this.start, this.stop);
1756      return t3.tokenIndex = this.tokenIndex, t3.line = this.line, t3.column = this.column, t3.text = this.text, t3;
1757    }
1758    cloneWithType(e3) {
1759      const n2 = new Pt(this.source, e3, this.channel, this.start, this.stop);
1760      return n2.tokenIndex = this.tokenIndex, n2.line = this.line, n2.column = this.column, e3 === t2.EOF && (n2.text = ""), n2;
1761    }
1762    toString() {
1763      let t3 = this.text;
1764      return t3 = null !== t3 ? t3.replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t") : "<no text>", "[@" + this.tokenIndex + "," + this.start + ":" + this.stop + "='" + t3 + "',<" + this.type + ">" + (this.channel > 0 ? ",channel=" + this.channel : "") + "," + this.line + ":" + this.column + "]";
1765    }
1766    get text() {
1767      if (null !== this._text) return this._text;
1768      const t3 = this.getInputStream();
1769      if (null === t3) return null;
1770      const e3 = t3.size;
1771      return this.start < e3 && this.stop < e3 ? t3.getText(this.start, this.stop) : "<EOF>";
1772    }
1773    set text(t3) {
1774      this._text = t3;
1775    }
1776  }
1777  Pt.EMPTY_SOURCE = [null, null];
1778  class bt {
1779  }
1780  class Dt extends bt {
1781    constructor(t3) {
1782      super(), this.copyText = void 0 !== t3 && t3;
1783    }
1784    create(t3, e3, n2, s2, i3, r3, o3, a3) {
1785      const l3 = new Pt(t3, e3, s2, i3, r3);
1786      return l3.line = o3, l3.column = a3, null !== n2 ? l3.text = n2 : this.copyText && null !== t3[1] && (l3.text = t3[1].getText(i3, r3)), l3;
1787    }
1788    createThin(t3, e3) {
1789      const n2 = new Pt(null, t3);
1790      return n2.text = e3, n2;
1791    }
1792  }
1793  Dt.DEFAULT = new Dt();
1794  class Ft extends Error {
1795    constructor(t3) {
1796      super(t3.message), Error.captureStackTrace && Error.captureStackTrace(this, Ft), this.message = t3.message, this.recognizer = t3.recognizer, this.input = t3.input, this.ctx = t3.ctx, this.offendingToken = null, this.offendingState = -1, null !== this.recognizer && (this.offendingState = this.recognizer.state);
1797    }
1798    getExpectedTokens() {
1799      return null !== this.recognizer ? this.recognizer.atn.getExpectedTokens(this.offendingState, this.ctx) : null;
1800    }
1801    toString() {
1802      return this.message;
1803    }
1804  }
1805  class Mt extends Ft {
1806    constructor(t3, e3, n2, s2) {
1807      super({ message: "", recognizer: t3, input: e3, ctx: null }), this.startIndex = n2, this.deadEndConfigs = s2;
1808    }
1809    toString() {
1810      let t3 = "";
1811      return this.startIndex >= 0 && this.startIndex < this.input.size && (t3 = this.input.getText(new m2(this.startIndex, this.startIndex))), "LexerNoViableAltException" + t3;
1812    }
1813  }
1814  class Ut extends wt {
1815    constructor(e3) {
1816      super(), this._input = e3, this._factory = Dt.DEFAULT, this._tokenFactorySourcePair = [this, e3], this._interp = null, this._token = null, this._tokenStartCharIndex = -1, this._tokenStartLine = -1, this._tokenStartColumn = -1, this._hitEOF = false, this._channel = t2.DEFAULT_CHANNEL, this._type = t2.INVALID_TYPE, this._modeStack = [], this._mode = Ut.DEFAULT_MODE, this._text = null;
1817    }
1818    reset() {
1819      null !== this._input && this._input.seek(0), this._token = null, this._type = t2.INVALID_TYPE, this._channel = t2.DEFAULT_CHANNEL, this._tokenStartCharIndex = -1, this._tokenStartColumn = -1, this._tokenStartLine = -1, this._text = null, this._hitEOF = false, this._mode = Ut.DEFAULT_MODE, this._modeStack = [], this._interp.reset();
1820    }
1821    nextToken() {
1822      if (null === this._input) throw "nextToken requires a non-null input stream.";
1823      const e3 = this._input.mark();
1824      try {
1825        for (; ; ) {
1826          if (this._hitEOF) return this.emitEOF(), this._token;
1827          this._token = null, this._channel = t2.DEFAULT_CHANNEL, this._tokenStartCharIndex = this._input.index, this._tokenStartColumn = this._interp.column, this._tokenStartLine = this._interp.line, this._text = null;
1828          let e4 = false;
1829          for (; ; ) {
1830            this._type = t2.INVALID_TYPE;
1831            let n2 = Ut.SKIP;
1832            try {
1833              n2 = this._interp.match(this._input, this._mode);
1834            } catch (t3) {
1835              if (!(t3 instanceof Ft)) throw console.log(t3.stack), t3;
1836              this.notifyListeners(t3), this.recover(t3);
1837            }
1838            if (this._input.LA(1) === t2.EOF && (this._hitEOF = true), this._type === t2.INVALID_TYPE && (this._type = n2), this._type === Ut.SKIP) {
1839              e4 = true;
1840              break;
1841            }
1842            if (this._type !== Ut.MORE) break;
1843          }
1844          if (!e4) return null === this._token && this.emit(), this._token;
1845        }
1846      } finally {
1847        this._input.release(e3);
1848      }
1849    }
1850    skip() {
1851      this._type = Ut.SKIP;
1852    }
1853    more() {
1854      this._type = Ut.MORE;
1855    }
1856    mode(t3) {
1857      this._mode = t3;
1858    }
1859    pushMode(t3) {
1860      this._interp.debug && console.log("pushMode " + t3), this._modeStack.push(this._mode), this.mode(t3);
1861    }
1862    popMode() {
1863      if (0 === this._modeStack.length) throw "Empty Stack";
1864      return this._interp.debug && console.log("popMode back to " + this._modeStack.slice(0, -1)), this.mode(this._modeStack.pop()), this._mode;
1865    }
1866    emitToken(t3) {
1867      this._token = t3;
1868    }
1869    emit() {
1870      const t3 = this._factory.create(this._tokenFactorySourcePair, this._type, this._text, this._channel, this._tokenStartCharIndex, this.getCharIndex() - 1, this._tokenStartLine, this._tokenStartColumn);
1871      return this.emitToken(t3), t3;
1872    }
1873    emitEOF() {
1874      const e3 = this.column, n2 = this.line, s2 = this._factory.create(this._tokenFactorySourcePair, t2.EOF, null, t2.DEFAULT_CHANNEL, this._input.index, this._input.index - 1, n2, e3);
1875      return this.emitToken(s2), s2;
1876    }
1877    getCharIndex() {
1878      return this._input.index;
1879    }
1880    getAllTokens() {
1881      const e3 = [];
1882      let n2 = this.nextToken();
1883      for (; n2.type !== t2.EOF; ) e3.push(n2), n2 = this.nextToken();
1884      return e3;
1885    }
1886    notifyListeners(t3) {
1887      const e3 = this._tokenStartCharIndex, n2 = this._input.index, s2 = this._input.getText(e3, n2), i3 = "token recognition error at: '" + this.getErrorDisplay(s2) + "'";
1888      this.getErrorListenerDispatch().syntaxError(this, null, this._tokenStartLine, this._tokenStartColumn, i3, t3);
1889    }
1890    getErrorDisplay(t3) {
1891      const e3 = [];
1892      for (let n2 = 0; n2 < t3.length; n2++) e3.push(t3[n2]);
1893      return e3.join("");
1894    }
1895    getErrorDisplayForChar(e3) {
1896      return e3.charCodeAt(0) === t2.EOF ? "<EOF>" : "\n" === e3 ? "\\n" : "	" === e3 ? "\\t" : "\r" === e3 ? "\\r" : e3;
1897    }
1898    getCharErrorDisplay(t3) {
1899      return "'" + this.getErrorDisplayForChar(t3) + "'";
1900    }
1901    recover(e3) {
1902      this._input.LA(1) !== t2.EOF && (e3 instanceof Mt ? this._interp.consume(this._input) : this._input.consume());
1903    }
1904    get inputStream() {
1905      return this._input;
1906    }
1907    set inputStream(t3) {
1908      this._input = null, this._tokenFactorySourcePair = [this, this._input], this.reset(), this._input = t3, this._tokenFactorySourcePair = [this, this._input];
1909    }
1910    get sourceName() {
1911      return this._input.sourceName;
1912    }
1913    get type() {
1914      return this._type;
1915    }
1916    set type(t3) {
1917      this._type = t3;
1918    }
1919    get line() {
1920      return this._interp.line;
1921    }
1922    set line(t3) {
1923      this._interp.line = t3;
1924    }
1925    get column() {
1926      return this._interp.column;
1927    }
1928    set column(t3) {
1929      this._interp.column = t3;
1930    }
1931    get text() {
1932      return null !== this._text ? this._text : this._interp.getText(this._input);
1933    }
1934    set text(t3) {
1935      this._text = t3;
1936    }
1937  }
1938  function Bt(t3) {
1939    return t3.hashCodeForConfigSet();
1940  }
1941  function Vt(t3, e3) {
1942    return t3 === e3 || null !== t3 && null !== e3 && t3.equalsForConfigSet(e3);
1943  }
1944  Ut.DEFAULT_MODE = 0, Ut.MORE = -2, Ut.SKIP = -3, Ut.DEFAULT_TOKEN_CHANNEL = t2.DEFAULT_CHANNEL, Ut.HIDDEN = t2.HIDDEN_CHANNEL, Ut.MIN_CHAR_VALUE = 0, Ut.MAX_CHAR_VALUE = 1114111;
1945  class zt {
1946    constructor(t3) {
1947      this.configLookup = new d2(Bt, Vt), this.fullCtx = void 0 === t3 || t3, this.readOnly = false, this.configs = [], this.uniqueAlt = 0, this.conflictingAlts = null, this.hasSemanticContext = false, this.dipsIntoOuterContext = false, this.cachedHashCode = -1;
1948    }
1949    add(t3, e3) {
1950      if (void 0 === e3 && (e3 = null), this.readOnly) throw "This set is readonly";
1951      t3.semanticContext !== p2.NONE && (this.hasSemanticContext = true), t3.reachesIntoOuterContext > 0 && (this.dipsIntoOuterContext = true);
1952      const n2 = this.configLookup.add(t3);
1953      if (n2 === t3) return this.cachedHashCode = -1, this.configs.push(t3), true;
1954      const s2 = !this.fullCtx, i3 = G(n2.context, t3.context, s2, e3);
1955      return n2.reachesIntoOuterContext = Math.max(n2.reachesIntoOuterContext, t3.reachesIntoOuterContext), t3.precedenceFilterSuppressed && (n2.precedenceFilterSuppressed = true), n2.context = i3, true;
1956    }
1957    getStates() {
1958      const t3 = new d2();
1959      for (let e3 = 0; e3 < this.configs.length; e3++) t3.add(this.configs[e3].state);
1960      return t3;
1961    }
1962    getPredicates() {
1963      const t3 = [];
1964      for (let e3 = 0; e3 < this.configs.length; e3++) {
1965        const n2 = this.configs[e3].semanticContext;
1966        n2 !== p2.NONE && t3.push(n2.semanticContext);
1967      }
1968      return t3;
1969    }
1970    optimizeConfigs(t3) {
1971      if (this.readOnly) throw "This set is readonly";
1972      if (0 !== this.configLookup.length) for (let e3 = 0; e3 < this.configs.length; e3++) {
1973        const n2 = this.configs[e3];
1974        n2.context = t3.getCachedContext(n2.context);
1975      }
1976    }
1977    addAll(t3) {
1978      for (let e3 = 0; e3 < t3.length; e3++) this.add(t3[e3]);
1979      return false;
1980    }
1981    equals(t3) {
1982      return this === t3 || t3 instanceof zt && e2(this.configs, t3.configs) && this.fullCtx === t3.fullCtx && this.uniqueAlt === t3.uniqueAlt && this.conflictingAlts === t3.conflictingAlts && this.hasSemanticContext === t3.hasSemanticContext && this.dipsIntoOuterContext === t3.dipsIntoOuterContext;
1983    }
1984    hashCode() {
1985      const t3 = new o2();
1986      return t3.update(this.configs), t3.finish();
1987    }
1988    updateHashCode(t3) {
1989      this.readOnly ? (-1 === this.cachedHashCode && (this.cachedHashCode = this.hashCode()), t3.update(this.cachedHashCode)) : t3.update(this.hashCode());
1990    }
1991    isEmpty() {
1992      return 0 === this.configs.length;
1993    }
1994    contains(t3) {
1995      if (null === this.configLookup) throw "This method is not implemented for readonly sets.";
1996      return this.configLookup.contains(t3);
1997    }
1998    containsFast(t3) {
1999      if (null === this.configLookup) throw "This method is not implemented for readonly sets.";
2000      return this.configLookup.containsFast(t3);
2001    }
2002    clear() {
2003      if (this.readOnly) throw "This set is readonly";
2004      this.configs = [], this.cachedHashCode = -1, this.configLookup = new d2();
2005    }
2006    setReadonly(t3) {
2007      this.readOnly = t3, t3 && (this.configLookup = null);
2008    }
2009    toString() {
2010      return c2(this.configs) + (this.hasSemanticContext ? ",hasSemanticContext=" + this.hasSemanticContext : "") + (this.uniqueAlt !== $.INVALID_ALT_NUMBER ? ",uniqueAlt=" + this.uniqueAlt : "") + (null !== this.conflictingAlts ? ",conflictingAlts=" + this.conflictingAlts : "") + (this.dipsIntoOuterContext ? ",dipsIntoOuterContext" : "");
2011    }
2012    get items() {
2013      return this.configs;
2014    }
2015    get length() {
2016      return this.configs.length;
2017    }
2018  }
2019  class qt {
2020    constructor(t3, e3) {
2021      return null === t3 && (t3 = -1), null === e3 && (e3 = new zt()), this.stateNumber = t3, this.configs = e3, this.edges = null, this.isAcceptState = false, this.prediction = 0, this.lexerActionExecutor = null, this.requiresFullContext = false, this.predicates = null, this;
2022    }
2023    getAltSet() {
2024      const t3 = new d2();
2025      if (null !== this.configs) for (let e3 = 0; e3 < this.configs.length; e3++) {
2026        const n2 = this.configs[e3];
2027        t3.add(n2.alt);
2028      }
2029      return 0 === t3.length ? null : t3;
2030    }
2031    equals(t3) {
2032      return this === t3 || t3 instanceof qt && this.configs.equals(t3.configs);
2033    }
2034    toString() {
2035      let t3 = this.stateNumber + ":" + this.configs;
2036      return this.isAcceptState && (t3 += "=>", null !== this.predicates ? t3 += this.predicates : t3 += this.prediction), t3;
2037    }
2038    hashCode() {
2039      const t3 = new o2();
2040      return t3.update(this.configs), t3.finish();
2041    }
2042  }
2043  class Ht {
2044    constructor(t3, e3) {
2045      return this.atn = t3, this.sharedContextCache = e3, this;
2046    }
2047    getCachedContext(t3) {
2048      if (null === this.sharedContextCache) return t3;
2049      const e3 = new H();
2050      return Y(t3, this.sharedContextCache, e3);
2051    }
2052  }
2053  Ht.ERROR = new qt(2147483647, new zt());
2054  class Kt extends zt {
2055    constructor() {
2056      super(), this.configLookup = new d2();
2057    }
2058  }
2059  class Yt extends S2 {
2060    constructor(t3, e3) {
2061      super(t3, e3);
2062      const n2 = t3.lexerActionExecutor || null;
2063      return this.lexerActionExecutor = n2 || (null !== e3 ? e3.lexerActionExecutor : null), this.passedThroughNonGreedyDecision = null !== e3 && this.checkNonGreedyDecision(e3, this.state), this.hashCodeForConfigSet = Yt.prototype.hashCode, this.equalsForConfigSet = Yt.prototype.equals, this;
2064    }
2065    updateHashCode(t3) {
2066      t3.update(this.state.stateNumber, this.alt, this.context, this.semanticContext, this.passedThroughNonGreedyDecision, this.lexerActionExecutor);
2067    }
2068    equals(t3) {
2069      return this === t3 || t3 instanceof Yt && this.passedThroughNonGreedyDecision === t3.passedThroughNonGreedyDecision && (this.lexerActionExecutor ? this.lexerActionExecutor.equals(t3.lexerActionExecutor) : !t3.lexerActionExecutor) && super.equals(t3);
2070    }
2071    checkNonGreedyDecision(t3, e3) {
2072      return t3.passedThroughNonGreedyDecision || e3 instanceof J && e3.nonGreedy;
2073    }
2074  }
2075  class Gt extends St {
2076    constructor(t3, e3) {
2077      super(e3.actionType), this.offset = t3, this.action = e3, this.isPositionDependent = true;
2078    }
2079    execute(t3) {
2080      this.action.execute(t3);
2081    }
2082    updateHashCode(t3) {
2083      t3.update(this.actionType, this.offset, this.action);
2084    }
2085    equals(t3) {
2086      return this === t3 || t3 instanceof Gt && this.offset === t3.offset && this.action === t3.action;
2087    }
2088  }
2089  class jt {
2090    constructor(t3) {
2091      return this.lexerActions = null === t3 ? [] : t3, this.cachedHashCode = o2.hashStuff(t3), this;
2092    }
2093    fixOffsetBeforeMatch(t3) {
2094      let e3 = null;
2095      for (let n2 = 0; n2 < this.lexerActions.length; n2++) !this.lexerActions[n2].isPositionDependent || this.lexerActions[n2] instanceof Gt || (null === e3 && (e3 = this.lexerActions.concat([])), e3[n2] = new Gt(t3, this.lexerActions[n2]));
2096      return null === e3 ? this : new jt(e3);
2097    }
2098    execute(t3, e3, n2) {
2099      let s2 = false;
2100      const i3 = e3.index;
2101      try {
2102        for (let r3 = 0; r3 < this.lexerActions.length; r3++) {
2103          let o3 = this.lexerActions[r3];
2104          if (o3 instanceof Gt) {
2105            const t4 = o3.offset;
2106            e3.seek(n2 + t4), o3 = o3.action, s2 = n2 + t4 !== i3;
2107          } else o3.isPositionDependent && (e3.seek(i3), s2 = false);
2108          o3.execute(t3);
2109        }
2110      } finally {
2111        s2 && e3.seek(i3);
2112      }
2113    }
2114    hashCode() {
2115      return this.cachedHashCode;
2116    }
2117    updateHashCode(t3) {
2118      t3.update(this.cachedHashCode);
2119    }
2120    equals(t3) {
2121      if (this === t3) return true;
2122      if (t3 instanceof jt) {
2123        if (this.cachedHashCode != t3.cachedHashCode) return false;
2124        if (this.lexerActions.length != t3.lexerActions.length) return false;
2125        {
2126          const e3 = this.lexerActions.length;
2127          for (let n2 = 0; n2 < e3; ++n2) if (!this.lexerActions[n2].equals(t3.lexerActions[n2])) return false;
2128          return true;
2129        }
2130      }
2131      return false;
2132    }
2133    static append(t3, e3) {
2134      if (null === t3) return new jt([e3]);
2135      const n2 = t3.lexerActions.concat([e3]);
2136      return new jt(n2);
2137    }
2138  }
2139  function Wt(t3) {
2140    t3.index = -1, t3.line = 0, t3.column = -1, t3.dfaState = null;
2141  }
2142  class $t {
2143    constructor() {
2144      Wt(this);
2145    }
2146    reset() {
2147      Wt(this);
2148    }
2149  }
2150  class Xt extends Ht {
2151    constructor(t3, e3, n2, s2) {
2152      super(e3, s2), this.decisionToDFA = n2, this.recog = t3, this.startIndex = -1, this.line = 1, this.column = 0, this.mode = Ut.DEFAULT_MODE, this.prevAccept = new $t();
2153    }
2154    copyState(t3) {
2155      this.column = t3.column, this.line = t3.line, this.mode = t3.mode, this.startIndex = t3.startIndex;
2156    }
2157    match(t3, e3) {
2158      this.mode = e3;
2159      const n2 = t3.mark();
2160      try {
2161        this.startIndex = t3.index, this.prevAccept.reset();
2162        const n3 = this.decisionToDFA[e3];
2163        return null === n3.s0 ? this.matchATN(t3) : this.execATN(t3, n3.s0);
2164      } finally {
2165        t3.release(n2);
2166      }
2167    }
2168    reset() {
2169      this.prevAccept.reset(), this.startIndex = -1, this.line = 1, this.column = 0, this.mode = Ut.DEFAULT_MODE;
2170    }
2171    matchATN(t3) {
2172      const e3 = this.atn.modeToStartState[this.mode];
2173      Xt.debug && console.log("matchATN mode " + this.mode + " start: " + e3);
2174      const n2 = this.mode, s2 = this.computeStartState(t3, e3), i3 = s2.hasSemanticContext;
2175      s2.hasSemanticContext = false;
2176      const r3 = this.addDFAState(s2);
2177      i3 || (this.decisionToDFA[this.mode].s0 = r3);
2178      const o3 = this.execATN(t3, r3);
2179      return Xt.debug && console.log("DFA after matchATN: " + this.decisionToDFA[n2].toLexerString()), o3;
2180    }
2181    execATN(e3, n2) {
2182      Xt.debug && console.log("start state closure=" + n2.configs), n2.isAcceptState && this.captureSimState(this.prevAccept, e3, n2);
2183      let s2 = e3.LA(1), i3 = n2;
2184      for (; ; ) {
2185        Xt.debug && console.log("execATN loop starting closure: " + i3.configs);
2186        let n3 = this.getExistingTargetState(i3, s2);
2187        if (null === n3 && (n3 = this.computeTargetState(e3, i3, s2)), n3 === Ht.ERROR) break;
2188        if (s2 !== t2.EOF && this.consume(e3), n3.isAcceptState && (this.captureSimState(this.prevAccept, e3, n3), s2 === t2.EOF)) break;
2189        s2 = e3.LA(1), i3 = n3;
2190      }
2191      return this.failOrAccept(this.prevAccept, e3, i3.configs, s2);
2192    }
2193    getExistingTargetState(t3, e3) {
2194      if (null === t3.edges || e3 < Xt.MIN_DFA_EDGE || e3 > Xt.MAX_DFA_EDGE) return null;
2195      let n2 = t3.edges[e3 - Xt.MIN_DFA_EDGE];
2196      return void 0 === n2 && (n2 = null), Xt.debug && null !== n2 && console.log("reuse state " + t3.stateNumber + " edge to " + n2.stateNumber), n2;
2197    }
2198    computeTargetState(t3, e3, n2) {
2199      const s2 = new Kt();
2200      return this.getReachableConfigSet(t3, e3.configs, s2, n2), 0 === s2.items.length ? (s2.hasSemanticContext || this.addDFAEdge(e3, n2, Ht.ERROR), Ht.ERROR) : this.addDFAEdge(e3, n2, null, s2);
2201    }
2202    failOrAccept(e3, n2, s2, i3) {
2203      if (null !== this.prevAccept.dfaState) {
2204        const t3 = e3.dfaState.lexerActionExecutor;
2205        return this.accept(n2, t3, this.startIndex, e3.index, e3.line, e3.column), e3.dfaState.prediction;
2206      }
2207      if (i3 === t2.EOF && n2.index === this.startIndex) return t2.EOF;
2208      throw new Mt(this.recog, n2, this.startIndex, s2);
2209    }
2210    getReachableConfigSet(e3, n2, s2, i3) {
2211      let r3 = $.INVALID_ALT_NUMBER;
2212      for (let o3 = 0; o3 < n2.items.length; o3++) {
2213        const a3 = n2.items[o3], l3 = a3.alt === r3;
2214        if (!l3 || !a3.passedThroughNonGreedyDecision) {
2215          Xt.debug && console.log("testing %s at %s\n", this.getTokenName(i3), a3.toString(this.recog, true));
2216          for (let n3 = 0; n3 < a3.state.transitions.length; n3++) {
2217            const o4 = a3.state.transitions[n3], h3 = this.getReachableTarget(o4, i3);
2218            if (null !== h3) {
2219              let n4 = a3.lexerActionExecutor;
2220              null !== n4 && (n4 = n4.fixOffsetBeforeMatch(e3.index - this.startIndex));
2221              const o5 = i3 === t2.EOF, c3 = new Yt({ state: h3, lexerActionExecutor: n4 }, a3);
2222              this.closure(e3, c3, s2, l3, true, o5) && (r3 = a3.alt);
2223            }
2224          }
2225        }
2226      }
2227    }
2228    accept(t3, e3, n2, s2, i3, r3) {
2229      Xt.debug && console.log("ACTION %s\n", e3), t3.seek(s2), this.line = i3, this.column = r3, null !== e3 && null !== this.recog && e3.execute(this.recog, t3, n2);
2230    }
2231    getReachableTarget(t3, e3) {
2232      return t3.matches(e3, 0, Ut.MAX_CHAR_VALUE) ? t3.target : null;
2233    }
2234    computeStartState(t3, e3) {
2235      const n2 = U.EMPTY, s2 = new Kt();
2236      for (let i3 = 0; i3 < e3.transitions.length; i3++) {
2237        const r3 = e3.transitions[i3].target, o3 = new Yt({ state: r3, alt: i3 + 1, context: n2 }, null);
2238        this.closure(t3, o3, s2, false, false, false);
2239      }
2240      return s2;
2241    }
2242    closure(t3, e3, n2, s2, i3, r3) {
2243      let o3 = null;
2244      if (Xt.debug && console.log("closure(" + e3.toString(this.recog, true) + ")"), e3.state instanceof A2) {
2245        if (Xt.debug && (null !== this.recog ? console.log("closure at %s rule stop %s\n", this.recog.ruleNames[e3.state.ruleIndex], e3) : console.log("closure at rule stop %s\n", e3)), null === e3.context || e3.context.hasEmptyPath()) {
2246          if (null === e3.context || e3.context.isEmpty()) return n2.add(e3), true;
2247          n2.add(new Yt({ state: e3.state, context: U.EMPTY }, e3)), s2 = true;
2248        }
2249        if (null !== e3.context && !e3.context.isEmpty()) {
2250          for (let a3 = 0; a3 < e3.context.length; a3++) if (e3.context.getReturnState(a3) !== U.EMPTY_RETURN_STATE) {
2251            const l3 = e3.context.getParent(a3), h3 = this.atn.states[e3.context.getReturnState(a3)];
2252            o3 = new Yt({ state: h3, context: l3 }, e3), s2 = this.closure(t3, o3, n2, s2, i3, r3);
2253          }
2254        }
2255        return s2;
2256      }
2257      e3.state.epsilonOnlyTransitions || s2 && e3.passedThroughNonGreedyDecision || n2.add(e3);
2258      for (let a3 = 0; a3 < e3.state.transitions.length; a3++) {
2259        const l3 = e3.state.transitions[a3];
2260        o3 = this.getEpsilonTarget(t3, e3, l3, n2, i3, r3), null !== o3 && (s2 = this.closure(t3, o3, n2, s2, i3, r3));
2261      }
2262      return s2;
2263    }
2264    getEpsilonTarget(e3, n2, s2, i3, r3, o3) {
2265      let a3 = null;
2266      if (s2.serializationType === C2.RULE) {
2267        const t3 = V.create(n2.context, s2.followState.stateNumber);
2268        a3 = new Yt({ state: s2.target, context: t3 }, n2);
2269      } else {
2270        if (s2.serializationType === C2.PRECEDENCE) throw "Precedence predicates are not supported in lexers.";
2271        if (s2.serializationType === C2.PREDICATE) Xt.debug && console.log("EVAL rule " + s2.ruleIndex + ":" + s2.predIndex), i3.hasSemanticContext = true, this.evaluatePredicate(e3, s2.ruleIndex, s2.predIndex, r3) && (a3 = new Yt({ state: s2.target }, n2));
2272        else if (s2.serializationType === C2.ACTION) if (null === n2.context || n2.context.hasEmptyPath()) {
2273          const t3 = jt.append(n2.lexerActionExecutor, this.atn.lexerActions[s2.actionIndex]);
2274          a3 = new Yt({ state: s2.target, lexerActionExecutor: t3 }, n2);
2275        } else a3 = new Yt({ state: s2.target }, n2);
2276        else s2.serializationType === C2.EPSILON ? a3 = new Yt({ state: s2.target }, n2) : s2.serializationType !== C2.ATOM && s2.serializationType !== C2.RANGE && s2.serializationType !== C2.SET || o3 && s2.matches(t2.EOF, 0, Ut.MAX_CHAR_VALUE) && (a3 = new Yt({ state: s2.target }, n2));
2277      }
2278      return a3;
2279    }
2280    evaluatePredicate(t3, e3, n2, s2) {
2281      if (null === this.recog) return true;
2282      if (!s2) return this.recog.sempred(null, e3, n2);
2283      const i3 = this.column, r3 = this.line, o3 = t3.index, a3 = t3.mark();
2284      try {
2285        return this.consume(t3), this.recog.sempred(null, e3, n2);
2286      } finally {
2287        this.column = i3, this.line = r3, t3.seek(o3), t3.release(a3);
2288      }
2289    }
2290    captureSimState(t3, e3, n2) {
2291      t3.index = e3.index, t3.line = this.line, t3.column = this.column, t3.dfaState = n2;
2292    }
2293    addDFAEdge(t3, e3, n2, s2) {
2294      if (void 0 === n2 && (n2 = null), void 0 === s2 && (s2 = null), null === n2 && null !== s2) {
2295        const t4 = s2.hasSemanticContext;
2296        if (s2.hasSemanticContext = false, n2 = this.addDFAState(s2), t4) return n2;
2297      }
2298      return e3 < Xt.MIN_DFA_EDGE || e3 > Xt.MAX_DFA_EDGE || (Xt.debug && console.log("EDGE " + t3 + " -> " + n2 + " upon " + e3), null === t3.edges && (t3.edges = []), t3.edges[e3 - Xt.MIN_DFA_EDGE] = n2), n2;
2299    }
2300    addDFAState(t3) {
2301      const e3 = new qt(null, t3);
2302      let n2 = null;
2303      for (let e4 = 0; e4 < t3.items.length; e4++) {
2304        const s3 = t3.items[e4];
2305        if (s3.state instanceof A2) {
2306          n2 = s3;
2307          break;
2308        }
2309      }
2310      null !== n2 && (e3.isAcceptState = true, e3.lexerActionExecutor = n2.lexerActionExecutor, e3.prediction = this.atn.ruleToTokenType[n2.state.ruleIndex]);
2311      const s2 = this.decisionToDFA[this.mode], i3 = s2.states.get(e3);
2312      if (null !== i3) return i3;
2313      const r3 = e3;
2314      return r3.stateNumber = s2.states.length, t3.setReadonly(true), r3.configs = t3, s2.states.add(r3), r3;
2315    }
2316    getDFA(t3) {
2317      return this.decisionToDFA[t3];
2318    }
2319    getText(t3) {
2320      return t3.getText(this.startIndex, t3.index - 1);
2321    }
2322    consume(t3) {
2323      t3.LA(1) === "\n".charCodeAt(0) ? (this.line += 1, this.column = 0) : this.column += 1, t3.consume();
2324    }
2325    getTokenName(t3) {
2326      return -1 === t3 ? "EOF" : "'" + String.fromCharCode(t3) + "'";
2327    }
2328  }
2329  Xt.debug = false, Xt.dfa_debug = false, Xt.MIN_DFA_EDGE = 0, Xt.MAX_DFA_EDGE = 127;
2330  class Jt {
2331    constructor(t3, e3) {
2332      this.alt = e3, this.pred = t3;
2333    }
2334    toString() {
2335      return "(" + this.pred + ", " + this.alt + ")";
2336    }
2337  }
2338  class Zt {
2339    constructor() {
2340      this.data = {};
2341    }
2342    get(t3) {
2343      return this.data["k-" + t3] || null;
2344    }
2345    set(t3, e3) {
2346      this.data["k-" + t3] = e3;
2347    }
2348    values() {
2349      return Object.keys(this.data).filter(((t3) => t3.startsWith("k-"))).map(((t3) => this.data[t3]), this);
2350    }
2351  }
2352  const Qt = { SLL: 0, LL: 1, LL_EXACT_AMBIG_DETECTION: 2, hasSLLConflictTerminatingPrediction: function(t3, e3) {
2353    if (Qt.allConfigsInRuleStopStates(e3)) return true;
2354    if (t3 === Qt.SLL && e3.hasSemanticContext) {
2355      const t4 = new zt();
2356      for (let n3 = 0; n3 < e3.items.length; n3++) {
2357        let s2 = e3.items[n3];
2358        s2 = new S2({ semanticContext: p2.NONE }, s2), t4.add(s2);
2359      }
2360      e3 = t4;
2361    }
2362    const n2 = Qt.getConflictingAltSubsets(e3);
2363    return Qt.hasConflictingAltSet(n2) && !Qt.hasStateAssociatedWithOneAlt(e3);
2364  }, hasConfigInRuleStopState: function(t3) {
2365    for (let e3 = 0; e3 < t3.items.length; e3++) if (t3.items[e3].state instanceof A2) return true;
2366    return false;
2367  }, allConfigsInRuleStopStates: function(t3) {
2368    for (let e3 = 0; e3 < t3.items.length; e3++) if (!(t3.items[e3].state instanceof A2)) return false;
2369    return true;
2370  }, resolvesToJustOneViableAlt: function(t3) {
2371    return Qt.getSingleViableAlt(t3);
2372  }, allSubsetsConflict: function(t3) {
2373    return !Qt.hasNonConflictingAltSet(t3);
2374  }, hasNonConflictingAltSet: function(t3) {
2375    for (let e3 = 0; e3 < t3.length; e3++) if (1 === t3[e3].length) return true;
2376    return false;
2377  }, hasConflictingAltSet: function(t3) {
2378    for (let e3 = 0; e3 < t3.length; e3++) if (t3[e3].length > 1) return true;
2379    return false;
2380  }, allSubsetsEqual: function(t3) {
2381    let e3 = null;
2382    for (let n2 = 0; n2 < t3.length; n2++) {
2383      const s2 = t3[n2];
2384      if (null === e3) e3 = s2;
2385      else if (s2 !== e3) return false;
2386    }
2387    return true;
2388  }, getUniqueAlt: function(t3) {
2389    const e3 = Qt.getAlts(t3);
2390    return 1 === e3.length ? e3.minValue() : $.INVALID_ALT_NUMBER;
2391  }, getAlts: function(t3) {
2392    const e3 = new j();
2393    return t3.map((function(t4) {
2394      e3.or(t4);
2395    })), e3;
2396  }, getConflictingAltSubsets: function(t3) {
2397    const e3 = new H();
2398    return e3.hashFunction = function(t4) {
2399      o2.hashStuff(t4.state.stateNumber, t4.context);
2400    }, e3.equalsFunction = function(t4, e4) {
2401      return t4.state.stateNumber === e4.state.stateNumber && t4.context.equals(e4.context);
2402    }, t3.items.map((function(t4) {
2403      let n2 = e3.get(t4);
2404      null === n2 && (n2 = new j(), e3.set(t4, n2)), n2.add(t4.alt);
2405    })), e3.getValues();
2406  }, getStateToAltMap: function(t3) {
2407    const e3 = new Zt();
2408    return t3.items.map((function(t4) {
2409      let n2 = e3.get(t4.state);
2410      null === n2 && (n2 = new j(), e3.set(t4.state, n2)), n2.add(t4.alt);
2411    })), e3;
2412  }, hasStateAssociatedWithOneAlt: function(t3) {
2413    const e3 = Qt.getStateToAltMap(t3).values();
2414    for (let t4 = 0; t4 < e3.length; t4++) if (1 === e3[t4].length) return true;
2415    return false;
2416  }, getSingleViableAlt: function(t3) {
2417    let e3 = null;
2418    for (let n2 = 0; n2 < t3.length; n2++) {
2419      const s2 = t3[n2].minValue();
2420      if (null === e3) e3 = s2;
2421      else if (e3 !== s2) return $.INVALID_ALT_NUMBER;
2422    }
2423    return e3;
2424  } }, te = Qt;
2425  class ee extends Ft {
2426    constructor(t3, e3, n2, s2, i3, r3) {
2427      r3 = r3 || t3._ctx, s2 = s2 || t3.getCurrentToken(), n2 = n2 || t3.getCurrentToken(), e3 = e3 || t3.getInputStream(), super({ message: "", recognizer: t3, input: e3, ctx: r3 }), this.deadEndConfigs = i3, this.startToken = n2, this.offendingToken = s2;
2428    }
2429  }
2430  class ne {
2431    constructor(t3) {
2432      this.defaultMapCtor = t3 || H, this.cacheMap = new this.defaultMapCtor();
2433    }
2434    get(t3, e3) {
2435      const n2 = this.cacheMap.get(t3) || null;
2436      return null === n2 ? null : n2.get(e3) || null;
2437    }
2438    set(t3, e3, n2) {
2439      let s2 = this.cacheMap.get(t3) || null;
2440      null === s2 && (s2 = new this.defaultMapCtor(), this.cacheMap.set(t3, s2)), s2.set(e3, n2);
2441    }
2442  }
2443  class se extends Ht {
2444    constructor(t3, e3, n2, s2) {
2445      super(e3, s2), this.parser = t3, this.decisionToDFA = n2, this.predictionMode = te.LL, this._input = null, this._startIndex = 0, this._outerContext = null, this._dfa = null, this.mergeCache = null, this.debug = false, this.debug_closure = false, this.debug_add = false, this.trace_atn_sim = false, this.dfa_debug = false, this.retry_debug = false;
2446    }
2447    reset() {
2448    }
2449    adaptivePredict(t3, e3, n2) {
2450      (this.debug || this.trace_atn_sim) && console.log("adaptivePredict decision " + e3 + " exec LA(1)==" + this.getLookaheadName(t3) + " line " + t3.LT(1).line + ":" + t3.LT(1).column), this._input = t3, this._startIndex = t3.index, this._outerContext = n2;
2451      const s2 = this.decisionToDFA[e3];
2452      this._dfa = s2;
2453      const i3 = t3.mark(), r3 = t3.index;
2454      try {
2455        let e4;
2456        if (e4 = s2.precedenceDfa ? s2.getPrecedenceStartState(this.parser.getPrecedence()) : s2.s0, null === e4) {
2457          null === n2 && (n2 = M2.EMPTY), this.debug && console.log("predictATN decision " + s2.decision + " exec LA(1)==" + this.getLookaheadName(t3) + ", outerContext=" + n2.toString(this.parser.ruleNames));
2458          const i5 = false;
2459          let r4 = this.computeStartState(s2.atnStartState, M2.EMPTY, i5);
2460          s2.precedenceDfa ? (s2.s0.configs = r4, r4 = this.applyPrecedenceFilter(r4), e4 = this.addDFAState(s2, new qt(null, r4)), s2.setPrecedenceStartState(this.parser.getPrecedence(), e4)) : (e4 = this.addDFAState(s2, new qt(null, r4)), s2.s0 = e4);
2461        }
2462        const i4 = this.execATN(s2, e4, t3, r3, n2);
2463        return this.debug && console.log("DFA after predictATN: " + s2.toString(this.parser.literalNames, this.parser.symbolicNames)), i4;
2464      } finally {
2465        this._dfa = null, this.mergeCache = null, t3.seek(r3), t3.release(i3);
2466      }
2467    }
2468    execATN(e3, n2, s2, i3, r3) {
2469      let o3;
2470      (this.debug || this.trace_atn_sim) && console.log("execATN decision " + e3.decision + ", DFA state " + n2 + ", LA(1)==" + this.getLookaheadName(s2) + " line " + s2.LT(1).line + ":" + s2.LT(1).column);
2471      let a3 = n2;
2472      this.debug && console.log("s0 = " + n2);
2473      let l3 = s2.LA(1);
2474      for (; ; ) {
2475        let n3 = this.getExistingTargetState(a3, l3);
2476        if (null === n3 && (n3 = this.computeTargetState(e3, a3, l3)), n3 === Ht.ERROR) {
2477          const t3 = this.noViableAlt(s2, r3, a3.configs, i3);
2478          if (s2.seek(i3), o3 = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(a3.configs, r3), o3 !== $.INVALID_ALT_NUMBER) return o3;
2479          throw t3;
2480        }
2481        if (n3.requiresFullContext && this.predictionMode !== te.SLL) {
2482          let t3 = null;
2483          if (null !== n3.predicates) {
2484            this.debug && console.log("DFA state has preds in DFA sim LL failover");
2485            const e4 = s2.index;
2486            if (e4 !== i3 && s2.seek(i3), t3 = this.evalSemanticContext(n3.predicates, r3, true), 1 === t3.length) return this.debug && console.log("Full LL avoided"), t3.minValue();
2487            e4 !== i3 && s2.seek(e4);
2488          }
2489          this.dfa_debug && console.log("ctx sensitive state " + r3 + " in " + n3);
2490          const a4 = true, l4 = this.computeStartState(e3.atnStartState, r3, a4);
2491          return this.reportAttemptingFullContext(e3, t3, n3.configs, i3, s2.index), o3 = this.execATNWithFullContext(e3, n3, l4, s2, i3, r3), o3;
2492        }
2493        if (n3.isAcceptState) {
2494          if (null === n3.predicates) return n3.prediction;
2495          const t3 = s2.index;
2496          s2.seek(i3);
2497          const o4 = this.evalSemanticContext(n3.predicates, r3, true);
2498          if (0 === o4.length) throw this.noViableAlt(s2, r3, n3.configs, i3);
2499          return 1 === o4.length || this.reportAmbiguity(e3, n3, i3, t3, false, o4, n3.configs), o4.minValue();
2500        }
2501        a3 = n3, l3 !== t2.EOF && (s2.consume(), l3 = s2.LA(1));
2502      }
2503    }
2504    getExistingTargetState(t3, e3) {
2505      const n2 = t3.edges;
2506      return null === n2 ? null : n2[e3 + 1] || null;
2507    }
2508    computeTargetState(t3, e3, n2) {
2509      const s2 = this.computeReachSet(e3.configs, n2, false);
2510      if (null === s2) return this.addDFAEdge(t3, e3, n2, Ht.ERROR), Ht.ERROR;
2511      let i3 = new qt(null, s2);
2512      const r3 = this.getUniqueAlt(s2);
2513      if (this.debug) {
2514        const t4 = te.getConflictingAltSubsets(s2);
2515        console.log("SLL altSubSets=" + c2(t4) + ", configs=" + s2 + ", predict=" + r3 + ", allSubsetsConflict=" + te.allSubsetsConflict(t4) + ", conflictingAlts=" + this.getConflictingAlts(s2));
2516      }
2517      return r3 !== $.INVALID_ALT_NUMBER ? (i3.isAcceptState = true, i3.configs.uniqueAlt = r3, i3.prediction = r3) : te.hasSLLConflictTerminatingPrediction(this.predictionMode, s2) && (i3.configs.conflictingAlts = this.getConflictingAlts(s2), i3.requiresFullContext = true, i3.isAcceptState = true, i3.prediction = i3.configs.conflictingAlts.minValue()), i3.isAcceptState && i3.configs.hasSemanticContext && (this.predicateDFAState(i3, this.atn.getDecisionState(t3.decision)), null !== i3.predicates && (i3.prediction = $.INVALID_ALT_NUMBER)), i3 = this.addDFAEdge(t3, e3, n2, i3), i3;
2518    }
2519    predicateDFAState(t3, e3) {
2520      const n2 = e3.transitions.length, s2 = this.getConflictingAltsOrUniqueAlt(t3.configs), i3 = this.getPredsForAmbigAlts(s2, t3.configs, n2);
2521      null !== i3 ? (t3.predicates = this.getPredicatePredictions(s2, i3), t3.prediction = $.INVALID_ALT_NUMBER) : t3.prediction = s2.minValue();
2522    }
2523    execATNWithFullContext(e3, n2, s2, i3, r3, o3) {
2524      (this.debug || this.trace_atn_sim) && console.log("execATNWithFullContext " + s2);
2525      let a3, l3 = false, h3 = s2;
2526      i3.seek(r3);
2527      let c3 = i3.LA(1), u3 = -1;
2528      for (; ; ) {
2529        if (a3 = this.computeReachSet(h3, c3, true), null === a3) {
2530          const t3 = this.noViableAlt(i3, o3, h3, r3);
2531          i3.seek(r3);
2532          const e5 = this.getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(h3, o3);
2533          if (e5 !== $.INVALID_ALT_NUMBER) return e5;
2534          throw t3;
2535        }
2536        const e4 = te.getConflictingAltSubsets(a3);
2537        if (this.debug && console.log("LL altSubSets=" + e4 + ", predict=" + te.getUniqueAlt(e4) + ", resolvesToJustOneViableAlt=" + te.resolvesToJustOneViableAlt(e4)), a3.uniqueAlt = this.getUniqueAlt(a3), a3.uniqueAlt !== $.INVALID_ALT_NUMBER) {
2538          u3 = a3.uniqueAlt;
2539          break;
2540        }
2541        if (this.predictionMode !== te.LL_EXACT_AMBIG_DETECTION) {
2542          if (u3 = te.resolvesToJustOneViableAlt(e4), u3 !== $.INVALID_ALT_NUMBER) break;
2543        } else if (te.allSubsetsConflict(e4) && te.allSubsetsEqual(e4)) {
2544          l3 = true, u3 = te.getSingleViableAlt(e4);
2545          break;
2546        }
2547        h3 = a3, c3 !== t2.EOF && (i3.consume(), c3 = i3.LA(1));
2548      }
2549      return a3.uniqueAlt !== $.INVALID_ALT_NUMBER ? (this.reportContextSensitivity(e3, u3, a3, r3, i3.index), u3) : (this.reportAmbiguity(e3, n2, r3, i3.index, l3, null, a3), u3);
2550    }
2551    computeReachSet(e3, n2, s2) {
2552      this.debug && console.log("in computeReachSet, starting closure: " + e3), null === this.mergeCache && (this.mergeCache = new ne());
2553      const i3 = new zt(s2);
2554      let r3 = null;
2555      for (let o4 = 0; o4 < e3.items.length; o4++) {
2556        const a3 = e3.items[o4];
2557        if (this.debug && console.log("testing " + this.getTokenName(n2) + " at " + a3), a3.state instanceof A2) (s2 || n2 === t2.EOF) && (null === r3 && (r3 = []), r3.push(a3), this.debug_add && console.log("added " + a3 + " to skippedStopStates"));
2558        else for (let t3 = 0; t3 < a3.state.transitions.length; t3++) {
2559          const e4 = a3.state.transitions[t3], s3 = this.getReachableTarget(e4, n2);
2560          if (null !== s3) {
2561            const t4 = new S2({ state: s3 }, a3);
2562            i3.add(t4, this.mergeCache), this.debug_add && console.log("added " + t4 + " to intermediate");
2563          }
2564        }
2565      }
2566      let o3 = null;
2567      if (null === r3 && n2 !== t2.EOF && (1 === i3.items.length || this.getUniqueAlt(i3) !== $.INVALID_ALT_NUMBER) && (o3 = i3), null === o3) {
2568        o3 = new zt(s2);
2569        const e4 = new d2(), r4 = n2 === t2.EOF;
2570        for (let t3 = 0; t3 < i3.items.length; t3++) this.closure(i3.items[t3], o3, e4, false, s2, r4);
2571      }
2572      if (n2 === t2.EOF && (o3 = this.removeAllConfigsNotInRuleStopState(o3, o3 === i3)), !(null === r3 || s2 && te.hasConfigInRuleStopState(o3))) for (let t3 = 0; t3 < r3.length; t3++) o3.add(r3[t3], this.mergeCache);
2573      return this.trace_atn_sim && console.log("computeReachSet " + e3 + " -> " + o3), 0 === o3.items.length ? null : o3;
2574    }
2575    removeAllConfigsNotInRuleStopState(e3, n2) {
2576      if (te.allConfigsInRuleStopStates(e3)) return e3;
2577      const s2 = new zt(e3.fullCtx);
2578      for (let i3 = 0; i3 < e3.items.length; i3++) {
2579        const r3 = e3.items[i3];
2580        if (r3.state instanceof A2) s2.add(r3, this.mergeCache);
2581        else if (n2 && r3.state.epsilonOnlyTransitions && this.atn.nextTokens(r3.state).contains(t2.EPSILON)) {
2582          const t3 = this.atn.ruleToStopState[r3.state.ruleIndex];
2583          s2.add(new S2({ state: t3 }, r3), this.mergeCache);
2584        }
2585      }
2586      return s2;
2587    }
2588    computeStartState(t3, e3, n2) {
2589      const s2 = K(this.atn, e3), i3 = new zt(n2);
2590      this.trace_atn_sim && console.log("computeStartState from ATN state " + t3 + " initialContext=" + s2.toString(this.parser));
2591      for (let e4 = 0; e4 < t3.transitions.length; e4++) {
2592        const r3 = t3.transitions[e4].target, o3 = new S2({ state: r3, alt: e4 + 1, context: s2 }, null), a3 = new d2();
2593        this.closure(o3, i3, a3, true, n2, false);
2594      }
2595      return i3;
2596    }
2597    applyPrecedenceFilter(t3) {
2598      let e3;
2599      const n2 = [], s2 = new zt(t3.fullCtx);
2600      for (let i3 = 0; i3 < t3.items.length; i3++) {
2601        if (e3 = t3.items[i3], 1 !== e3.alt) continue;
2602        const r3 = e3.semanticContext.evalPrecedence(this.parser, this._outerContext);
2603        null !== r3 && (n2[e3.state.stateNumber] = e3.context, r3 !== e3.semanticContext ? s2.add(new S2({ semanticContext: r3 }, e3), this.mergeCache) : s2.add(e3, this.mergeCache));
2604      }
2605      for (let i3 = 0; i3 < t3.items.length; i3++) if (e3 = t3.items[i3], 1 !== e3.alt) {
2606        if (!e3.precedenceFilterSuppressed) {
2607          const t4 = n2[e3.state.stateNumber] || null;
2608          if (null !== t4 && t4.equals(e3.context)) continue;
2609        }
2610        s2.add(e3, this.mergeCache);
2611      }
2612      return s2;
2613    }
2614    getReachableTarget(t3, e3) {
2615      return t3.matches(e3, 0, this.atn.maxTokenType) ? t3.target : null;
2616    }
2617    getPredsForAmbigAlts(t3, e3, n2) {
2618      let s2 = [];
2619      for (let n3 = 0; n3 < e3.items.length; n3++) {
2620        const i4 = e3.items[n3];
2621        t3.has(i4.alt) && (s2[i4.alt] = p2.orContext(s2[i4.alt] || null, i4.semanticContext));
2622      }
2623      let i3 = 0;
2624      for (let t4 = 1; t4 < n2 + 1; t4++) {
2625        const e4 = s2[t4] || null;
2626        null === e4 ? s2[t4] = p2.NONE : e4 !== p2.NONE && (i3 += 1);
2627      }
2628      return 0 === i3 && (s2 = null), this.debug && console.log("getPredsForAmbigAlts result " + c2(s2)), s2;
2629    }
2630    getPredicatePredictions(t3, e3) {
2631      const n2 = [];
2632      let s2 = false;
2633      for (let i3 = 1; i3 < e3.length; i3++) {
2634        const r3 = e3[i3];
2635        null !== t3 && t3.has(i3) && n2.push(new Jt(r3, i3)), r3 !== p2.NONE && (s2 = true);
2636      }
2637      return s2 ? n2 : null;
2638    }
2639    getSynValidOrSemInvalidAltThatFinishedDecisionEntryRule(t3, e3) {
2640      const n2 = this.splitAccordingToSemanticValidity(t3, e3), s2 = n2[0], i3 = n2[1];
2641      let r3 = this.getAltThatFinishedDecisionEntryRule(s2);
2642      return r3 !== $.INVALID_ALT_NUMBER || i3.items.length > 0 && (r3 = this.getAltThatFinishedDecisionEntryRule(i3), r3 !== $.INVALID_ALT_NUMBER) ? r3 : $.INVALID_ALT_NUMBER;
2643    }
2644    getAltThatFinishedDecisionEntryRule(t3) {
2645      const e3 = [];
2646      for (let n2 = 0; n2 < t3.items.length; n2++) {
2647        const s2 = t3.items[n2];
2648        (s2.reachesIntoOuterContext > 0 || s2.state instanceof A2 && s2.context.hasEmptyPath()) && e3.indexOf(s2.alt) < 0 && e3.push(s2.alt);
2649      }
2650      return 0 === e3.length ? $.INVALID_ALT_NUMBER : Math.min.apply(null, e3);
2651    }
2652    splitAccordingToSemanticValidity(t3, e3) {
2653      const n2 = new zt(t3.fullCtx), s2 = new zt(t3.fullCtx);
2654      for (let i3 = 0; i3 < t3.items.length; i3++) {
2655        const r3 = t3.items[i3];
2656        r3.semanticContext !== p2.NONE ? r3.semanticContext.evaluate(this.parser, e3) ? n2.add(r3) : s2.add(r3) : n2.add(r3);
2657      }
2658      return [n2, s2];
2659    }
2660    evalSemanticContext(t3, e3, n2) {
2661      const s2 = new j();
2662      for (let i3 = 0; i3 < t3.length; i3++) {
2663        const r3 = t3[i3];
2664        if (r3.pred === p2.NONE) {
2665          if (s2.add(r3.alt), !n2) break;
2666          continue;
2667        }
2668        const o3 = r3.pred.evaluate(this.parser, e3);
2669        if ((this.debug || this.dfa_debug) && console.log("eval pred " + r3 + "=" + o3), o3 && ((this.debug || this.dfa_debug) && console.log("PREDICT " + r3.alt), s2.add(r3.alt), !n2)) break;
2670      }
2671      return s2;
2672    }
2673    closure(t3, e3, n2, s2, i3, r3) {
2674      this.closureCheckingStopState(t3, e3, n2, s2, i3, 0, r3);
2675    }
2676    closureCheckingStopState(t3, e3, n2, s2, i3, r3, o3) {
2677      if ((this.trace_atn_sim || this.debug_closure) && console.log("closure(" + t3.toString(this.parser, true) + ")"), t3.state instanceof A2) {
2678        if (!t3.context.isEmpty()) {
2679          for (let a3 = 0; a3 < t3.context.length; a3++) {
2680            if (t3.context.getReturnState(a3) === U.EMPTY_RETURN_STATE) {
2681              if (i3) {
2682                e3.add(new S2({ state: t3.state, context: U.EMPTY }, t3), this.mergeCache);
2683                continue;
2684              }
2685              this.debug && console.log("FALLING off rule " + this.getRuleName(t3.state.ruleIndex)), this.closure_(t3, e3, n2, s2, i3, r3, o3);
2686              continue;
2687            }
2688            const l3 = this.atn.states[t3.context.getReturnState(a3)], h3 = t3.context.getParent(a3), c3 = { state: l3, alt: t3.alt, context: h3, semanticContext: t3.semanticContext }, u3 = new S2(c3, null);
2689            u3.reachesIntoOuterContext = t3.reachesIntoOuterContext, this.closureCheckingStopState(u3, e3, n2, s2, i3, r3 - 1, o3);
2690          }
2691          return;
2692        }
2693        if (i3) return void e3.add(t3, this.mergeCache);
2694        this.debug && console.log("FALLING off rule " + this.getRuleName(t3.state.ruleIndex));
2695      }
2696      this.closure_(t3, e3, n2, s2, i3, r3, o3);
2697    }
2698    closure_(t3, e3, n2, s2, i3, r3, o3) {
2699      const a3 = t3.state;
2700      a3.epsilonOnlyTransitions || e3.add(t3, this.mergeCache);
2701      for (let l3 = 0; l3 < a3.transitions.length; l3++) {
2702        if (0 === l3 && this.canDropLoopEntryEdgeInLeftRecursiveRule(t3)) continue;
2703        const h3 = a3.transitions[l3], c3 = s2 && !(h3 instanceof ut), u3 = this.getEpsilonTarget(t3, h3, c3, 0 === r3, i3, o3);
2704        if (null !== u3) {
2705          let s3 = r3;
2706          if (t3.state instanceof A2) {
2707            if (null !== this._dfa && this._dfa.precedenceDfa && h3.outermostPrecedenceReturn === this._dfa.atnStartState.ruleIndex && (u3.precedenceFilterSuppressed = true), u3.reachesIntoOuterContext += 1, n2.add(u3) !== u3) continue;
2708            e3.dipsIntoOuterContext = true, s3 -= 1, this.debug && console.log("dips into outer ctx: " + u3);
2709          } else {
2710            if (!h3.isEpsilon && n2.add(u3) !== u3) continue;
2711            h3 instanceof N2 && s3 >= 0 && (s3 += 1);
2712          }
2713          this.closureCheckingStopState(u3, e3, n2, c3, i3, s3, o3);
2714        }
2715      }
2716    }
2717    canDropLoopEntryEdgeInLeftRecursiveRule(t3) {
2718      const e3 = t3.state;
2719      if (e3.stateType !== _2.STAR_LOOP_ENTRY) return false;
2720      if (e3.stateType !== _2.STAR_LOOP_ENTRY || !e3.isPrecedenceDecision || t3.context.isEmpty() || t3.context.hasEmptyPath()) return false;
2721      const n2 = t3.context.length;
2722      for (let s3 = 0; s3 < n2; s3++) if (this.atn.states[t3.context.getReturnState(s3)].ruleIndex !== e3.ruleIndex) return false;
2723      const s2 = e3.transitions[0].target.endState.stateNumber, i3 = this.atn.states[s2];
2724      for (let s3 = 0; s3 < n2; s3++) {
2725        const n3 = t3.context.getReturnState(s3), r3 = this.atn.states[n3];
2726        if (1 !== r3.transitions.length || !r3.transitions[0].isEpsilon) return false;
2727        const o3 = r3.transitions[0].target;
2728        if (!(r3.stateType === _2.BLOCK_END && o3 === e3 || r3 === i3 || o3 === i3 || o3.stateType === _2.BLOCK_END && 1 === o3.transitions.length && o3.transitions[0].isEpsilon && o3.transitions[0].target === e3)) return false;
2729      }
2730      return true;
2731    }
2732    getRuleName(t3) {
2733      return null !== this.parser && t3 >= 0 ? this.parser.ruleNames[t3] : "<rule " + t3 + ">";
2734    }
2735    getEpsilonTarget(e3, n2, s2, i3, r3, o3) {
2736      switch (n2.serializationType) {
2737        case C2.RULE:
2738          return this.ruleTransition(e3, n2);
2739        case C2.PRECEDENCE:
2740          return this.precedenceTransition(e3, n2, s2, i3, r3);
2741        case C2.PREDICATE:
2742          return this.predTransition(e3, n2, s2, i3, r3);
2743        case C2.ACTION:
2744          return this.actionTransition(e3, n2);
2745        case C2.EPSILON:
2746          return new S2({ state: n2.target }, e3);
2747        case C2.ATOM:
2748        case C2.RANGE:
2749        case C2.SET:
2750          return o3 && n2.matches(t2.EOF, 0, 1) ? new S2({ state: n2.target }, e3) : null;
2751        default:
2752          return null;
2753      }
2754    }
2755    actionTransition(t3, e3) {
2756      if (this.debug) {
2757        const t4 = -1 === e3.actionIndex ? 65535 : e3.actionIndex;
2758        console.log("ACTION edge " + e3.ruleIndex + ":" + t4);
2759      }
2760      return new S2({ state: e3.target }, t3);
2761    }
2762    precedenceTransition(t3, e3, n2, s2, i3) {
2763      this.debug && (console.log("PRED (collectPredicates=" + n2 + ") " + e3.precedence + ">=_p, ctx dependent=true"), null !== this.parser && console.log("context surrounding pred is " + c2(this.parser.getRuleInvocationStack())));
2764      let r3 = null;
2765      if (n2 && s2) if (i3) {
2766        const n3 = this._input.index;
2767        this._input.seek(this._startIndex);
2768        const s3 = e3.getPredicate().evaluate(this.parser, this._outerContext);
2769        this._input.seek(n3), s3 && (r3 = new S2({ state: e3.target }, t3));
2770      } else {
2771        const n3 = p2.andContext(t3.semanticContext, e3.getPredicate());
2772        r3 = new S2({ state: e3.target, semanticContext: n3 }, t3);
2773      }
2774      else r3 = new S2({ state: e3.target }, t3);
2775      return this.debug && console.log("config from pred transition=" + r3), r3;
2776    }
2777    predTransition(t3, e3, n2, s2, i3) {
2778      this.debug && (console.log("PRED (collectPredicates=" + n2 + ") " + e3.ruleIndex + ":" + e3.predIndex + ", ctx dependent=" + e3.isCtxDependent), null !== this.parser && console.log("context surrounding pred is " + c2(this.parser.getRuleInvocationStack())));
2779      let r3 = null;
2780      if (n2 && (e3.isCtxDependent && s2 || !e3.isCtxDependent)) if (i3) {
2781        const n3 = this._input.index;
2782        this._input.seek(this._startIndex);
2783        const s3 = e3.getPredicate().evaluate(this.parser, this._outerContext);
2784        this._input.seek(n3), s3 && (r3 = new S2({ state: e3.target }, t3));
2785      } else {
2786        const n3 = p2.andContext(t3.semanticContext, e3.getPredicate());
2787        r3 = new S2({ state: e3.target, semanticContext: n3 }, t3);
2788      }
2789      else r3 = new S2({ state: e3.target }, t3);
2790      return this.debug && console.log("config from pred transition=" + r3), r3;
2791    }
2792    ruleTransition(t3, e3) {
2793      this.debug && console.log("CALL rule " + this.getRuleName(e3.target.ruleIndex) + ", ctx=" + t3.context);
2794      const n2 = e3.followState, s2 = V.create(t3.context, n2.stateNumber);
2795      return new S2({ state: e3.target, context: s2 }, t3);
2796    }
2797    getConflictingAlts(t3) {
2798      const e3 = te.getConflictingAltSubsets(t3);
2799      return te.getAlts(e3);
2800    }
2801    getConflictingAltsOrUniqueAlt(t3) {
2802      let e3 = null;
2803      return t3.uniqueAlt !== $.INVALID_ALT_NUMBER ? (e3 = new j(), e3.add(t3.uniqueAlt)) : e3 = t3.conflictingAlts, e3;
2804    }
2805    getTokenName(e3) {
2806      if (e3 === t2.EOF) return "EOF";
2807      if (null !== this.parser && null !== this.parser.literalNames) {
2808        if (!(e3 >= this.parser.literalNames.length && e3 >= this.parser.symbolicNames.length)) return (this.parser.literalNames[e3] || this.parser.symbolicNames[e3]) + "<" + e3 + ">";
2809        console.log(e3 + " ttype out of range: " + this.parser.literalNames), console.log("" + this.parser.getInputStream().getTokens());
2810      }
2811      return "" + e3;
2812    }
2813    getLookaheadName(t3) {
2814      return this.getTokenName(t3.LA(1));
2815    }
2816    dumpDeadEndConfigs(t3) {
2817      console.log("dead end configs: ");
2818      const e3 = t3.getDeadEndConfigs();
2819      for (let t4 = 0; t4 < e3.length; t4++) {
2820        const n2 = e3[t4];
2821        let s2 = "no edges";
2822        if (n2.state.transitions.length > 0) {
2823          const t5 = n2.state.transitions[0];
2824          t5 instanceof ht ? s2 = "Atom " + this.getTokenName(t5.label) : t5 instanceof y2 && (s2 = (t5 instanceof I2 ? "~" : "") + "Set " + t5.set);
2825        }
2826        console.error(n2.toString(this.parser, true) + ":" + s2);
2827      }
2828    }
2829    noViableAlt(t3, e3, n2, s2) {
2830      return new ee(this.parser, t3, t3.get(s2), t3.LT(1), n2, e3);
2831    }
2832    getUniqueAlt(t3) {
2833      let e3 = $.INVALID_ALT_NUMBER;
2834      for (let n2 = 0; n2 < t3.items.length; n2++) {
2835        const s2 = t3.items[n2];
2836        if (e3 === $.INVALID_ALT_NUMBER) e3 = s2.alt;
2837        else if (s2.alt !== e3) return $.INVALID_ALT_NUMBER;
2838      }
2839      return e3;
2840    }
2841    addDFAEdge(t3, e3, n2, s2) {
2842      if (this.debug && console.log("EDGE " + e3 + " -> " + s2 + " upon " + this.getTokenName(n2)), null === s2) return null;
2843      if (s2 = this.addDFAState(t3, s2), null === e3 || n2 < -1 || n2 > this.atn.maxTokenType) return s2;
2844      if (null === e3.edges && (e3.edges = []), e3.edges[n2 + 1] = s2, this.debug) {
2845        const e4 = null === this.parser ? null : this.parser.literalNames, n3 = null === this.parser ? null : this.parser.symbolicNames;
2846        console.log("DFA=\n" + t3.toString(e4, n3));
2847      }
2848      return s2;
2849    }
2850    addDFAState(t3, e3) {
2851      if (e3 === Ht.ERROR) return e3;
2852      const n2 = t3.states.get(e3);
2853      return null !== n2 ? (this.trace_atn_sim && console.log("addDFAState " + e3 + " exists"), n2) : (e3.stateNumber = t3.states.length, e3.configs.readOnly || (e3.configs.optimizeConfigs(this), e3.configs.setReadonly(true)), this.trace_atn_sim && console.log("addDFAState new " + e3), t3.states.add(e3), this.debug && console.log("adding new DFA state: " + e3), e3);
2854    }
2855    reportAttemptingFullContext(t3, e3, n2, s2, i3) {
2856      if (this.debug || this.retry_debug) {
2857        const e4 = new m2(s2, i3 + 1);
2858        console.log("reportAttemptingFullContext decision=" + t3.decision + ":" + n2 + ", input=" + this.parser.getTokenStream().getText(e4));
2859      }
2860      null !== this.parser && this.parser.getErrorListenerDispatch().reportAttemptingFullContext(this.parser, t3, s2, i3, e3, n2);
2861    }
2862    reportContextSensitivity(t3, e3, n2, s2, i3) {
2863      if (this.debug || this.retry_debug) {
2864        const e4 = new m2(s2, i3 + 1);
2865        console.log("reportContextSensitivity decision=" + t3.decision + ":" + n2 + ", input=" + this.parser.getTokenStream().getText(e4));
2866      }
2867      null !== this.parser && this.parser.getErrorListenerDispatch().reportContextSensitivity(this.parser, t3, s2, i3, e3, n2);
2868    }
2869    reportAmbiguity(t3, e3, n2, s2, i3, r3, o3) {
2870      if (this.debug || this.retry_debug) {
2871        const t4 = new m2(n2, s2 + 1);
2872        console.log("reportAmbiguity " + r3 + ":" + o3 + ", input=" + this.parser.getTokenStream().getText(t4));
2873      }
2874      null !== this.parser && this.parser.getErrorListenerDispatch().reportAmbiguity(this.parser, t3, n2, s2, i3, r3, o3);
2875    }
2876  }
2877  class ie {
2878    constructor() {
2879      this.cache = new H();
2880    }
2881    add(t3) {
2882      if (t3 === U.EMPTY) return U.EMPTY;
2883      const e3 = this.cache.get(t3) || null;
2884      return null !== e3 ? e3 : (this.cache.set(t3, t3), t3);
2885    }
2886    get(t3) {
2887      return this.cache.get(t3) || null;
2888    }
2889    get length() {
2890      return this.cache.length;
2891    }
2892  }
2893  const re = { ATN: $, ATNDeserializer: Lt, LexerATNSimulator: Xt, ParserATNSimulator: se, PredictionMode: te, PredictionContextCache: ie };
2894  class oe {
2895    constructor(t3, e3, n2) {
2896      this.dfa = t3, this.literalNames = e3 || [], this.symbolicNames = n2 || [];
2897    }
2898    toString() {
2899      if (null === this.dfa.s0) return null;
2900      let t3 = "";
2901      const e3 = this.dfa.sortedStates();
2902      for (let n2 = 0; n2 < e3.length; n2++) {
2903        const s2 = e3[n2];
2904        if (null !== s2.edges) {
2905          const e4 = s2.edges.length;
2906          for (let n3 = 0; n3 < e4; n3++) {
2907            const e5 = s2.edges[n3] || null;
2908            null !== e5 && 2147483647 !== e5.stateNumber && (t3 = t3.concat(this.getStateString(s2)), t3 = t3.concat("-"), t3 = t3.concat(this.getEdgeLabel(n3)), t3 = t3.concat("->"), t3 = t3.concat(this.getStateString(e5)), t3 = t3.concat("\n"));
2909          }
2910        }
2911      }
2912      return 0 === t3.length ? null : t3;
2913    }
2914    getEdgeLabel(t3) {
2915      return 0 === t3 ? "EOF" : null !== this.literalNames || null !== this.symbolicNames ? this.literalNames[t3 - 1] || this.symbolicNames[t3 - 1] : String.fromCharCode(t3 - 1);
2916    }
2917    getStateString(t3) {
2918      const e3 = (t3.isAcceptState ? ":" : "") + "s" + t3.stateNumber + (t3.requiresFullContext ? "^" : "");
2919      return t3.isAcceptState ? null !== t3.predicates ? e3 + "=>" + c2(t3.predicates) : e3 + "=>" + t3.prediction.toString() : e3;
2920    }
2921  }
2922  class ae extends oe {
2923    constructor(t3) {
2924      super(t3, null);
2925    }
2926    getEdgeLabel(t3) {
2927      return "'" + String.fromCharCode(t3) + "'";
2928    }
2929  }
2930  class le {
2931    constructor(t3, e3) {
2932      if (void 0 === e3 && (e3 = 0), this.atnStartState = t3, this.decision = e3, this._states = new d2(), this.s0 = null, this.precedenceDfa = false, t3 instanceof rt && t3.isPrecedenceDecision) {
2933        this.precedenceDfa = true;
2934        const t4 = new qt(null, new zt());
2935        t4.edges = [], t4.isAcceptState = false, t4.requiresFullContext = false, this.s0 = t4;
2936      }
2937    }
2938    getPrecedenceStartState(t3) {
2939      if (!this.precedenceDfa) throw "Only precedence DFAs may contain a precedence start state.";
2940      return t3 < 0 || t3 >= this.s0.edges.length ? null : this.s0.edges[t3] || null;
2941    }
2942    setPrecedenceStartState(t3, e3) {
2943      if (!this.precedenceDfa) throw "Only precedence DFAs may contain a precedence start state.";
2944      t3 < 0 || (this.s0.edges[t3] = e3);
2945    }
2946    setPrecedenceDfa(t3) {
2947      if (this.precedenceDfa !== t3) {
2948        if (this._states = new d2(), t3) {
2949          const t4 = new qt(null, new zt());
2950          t4.edges = [], t4.isAcceptState = false, t4.requiresFullContext = false, this.s0 = t4;
2951        } else this.s0 = null;
2952        this.precedenceDfa = t3;
2953      }
2954    }
2955    sortedStates() {
2956      return this._states.values().sort((function(t3, e3) {
2957        return t3.stateNumber - e3.stateNumber;
2958      }));
2959    }
2960    toString(t3, e3) {
2961      return t3 = t3 || null, e3 = e3 || null, null === this.s0 ? "" : new oe(this, t3, e3).toString();
2962    }
2963    toLexerString() {
2964      return null === this.s0 ? "" : new ae(this).toString();
2965    }
2966    get states() {
2967      return this._states;
2968    }
2969  }
2970  const he = { DFA: le, DFASerializer: oe, LexerDFASerializer: ae, PredPrediction: Jt }, ce = { PredictionContext: U }, ue = { Interval: m2, IntervalSet: E2 };
2971  class de {
2972    visitTerminal(t3) {
2973    }
2974    visitErrorNode(t3) {
2975    }
2976    enterEveryRule(t3) {
2977    }
2978    exitEveryRule(t3) {
2979    }
2980  }
2981  class pe {
2982    visit(t3) {
2983      return Array.isArray(t3) ? t3.map((function(t4) {
2984        return t4.accept(this);
2985      }), this) : t3.accept(this);
2986    }
2987    visitChildren(t3) {
2988      return t3.children ? this.visit(t3.children) : null;
2989    }
2990    visitTerminal(t3) {
2991    }
2992    visitErrorNode(t3) {
2993    }
2994  }
2995  class ge {
2996    walk(t3, e3) {
2997      if (e3 instanceof b2 || void 0 !== e3.isErrorNode && e3.isErrorNode()) t3.visitErrorNode(e3);
2998      else if (e3 instanceof P2) t3.visitTerminal(e3);
2999      else {
3000        this.enterRule(t3, e3);
3001        for (let n2 = 0; n2 < e3.getChildCount(); n2++) {
3002          const s2 = e3.getChild(n2);
3003          this.walk(t3, s2);
3004        }
3005        this.exitRule(t3, e3);
3006      }
3007    }
3008    enterRule(t3, e3) {
3009      const n2 = e3.ruleContext;
3010      t3.enterEveryRule(n2), n2.enterRule(t3);
3011    }
3012    exitRule(t3, e3) {
3013      const n2 = e3.ruleContext;
3014      n2.exitRule(t3), t3.exitEveryRule(n2);
3015    }
3016  }
3017  ge.DEFAULT = new ge();
3018  const fe = { Trees: F2, RuleNode: w2, ErrorNode: b2, TerminalNode: P2, ParseTreeListener: de, ParseTreeVisitor: pe, ParseTreeWalker: ge };
3019  class xe extends Ft {
3020    constructor(t3) {
3021      super({ message: "", recognizer: t3, input: t3.getInputStream(), ctx: t3._ctx }), this.offendingToken = t3.getCurrentToken();
3022    }
3023  }
3024  class Te extends Ft {
3025    constructor(t3, e3, n2) {
3026      super({ message: Se(e3, n2 || null), recognizer: t3, input: t3.getInputStream(), ctx: t3._ctx });
3027      const s2 = t3._interp.atn.states[t3.state].transitions[0];
3028      s2 instanceof gt ? (this.ruleIndex = s2.ruleIndex, this.predicateIndex = s2.predIndex) : (this.ruleIndex = 0, this.predicateIndex = 0), this.predicate = e3, this.offendingToken = t3.getCurrentToken();
3029    }
3030  }
3031  function Se(t3, e3) {
3032    return null !== e3 ? e3 : "failed predicate: {" + t3 + "}?";
3033  }
3034  class me extends Ot {
3035    constructor(t3) {
3036      super(), t3 = t3 || true, this.exactOnly = t3;
3037    }
3038    reportAmbiguity(t3, e3, n2, s2, i3, r3, o3) {
3039      if (this.exactOnly && !i3) return;
3040      const a3 = "reportAmbiguity d=" + this.getDecisionDescription(t3, e3) + ": ambigAlts=" + this.getConflictingAlts(r3, o3) + ", input='" + t3.getTokenStream().getText(new m2(n2, s2)) + "'";
3041      t3.notifyErrorListeners(a3);
3042    }
3043    reportAttemptingFullContext(t3, e3, n2, s2, i3, r3) {
3044      const o3 = "reportAttemptingFullContext d=" + this.getDecisionDescription(t3, e3) + ", input='" + t3.getTokenStream().getText(new m2(n2, s2)) + "'";
3045      t3.notifyErrorListeners(o3);
3046    }
3047    reportContextSensitivity(t3, e3, n2, s2, i3, r3) {
3048      const o3 = "reportContextSensitivity d=" + this.getDecisionDescription(t3, e3) + ", input='" + t3.getTokenStream().getText(new m2(n2, s2)) + "'";
3049      t3.notifyErrorListeners(o3);
3050    }
3051    getDecisionDescription(t3, e3) {
3052      const n2 = e3.decision, s2 = e3.atnStartState.ruleIndex, i3 = t3.ruleNames;
3053      if (s2 < 0 || s2 >= i3.length) return "" + n2;
3054      const r3 = i3[s2] || null;
3055      return null === r3 || 0 === r3.length ? "" + n2 : `${n2} (${r3})`;
3056    }
3057    getConflictingAlts(t3, e3) {
3058      if (null !== t3) return t3;
3059      const n2 = new j();
3060      for (let t4 = 0; t4 < e3.items.length; t4++) n2.add(e3.items[t4].alt);
3061      return `{${n2.values().join(", ")}}`;
3062    }
3063  }
3064  class Ee extends Error {
3065    constructor() {
3066      super(), Error.captureStackTrace(this, Ee);
3067    }
3068  }
3069  class _e {
3070    reset(t3) {
3071    }
3072    recoverInline(t3) {
3073    }
3074    recover(t3, e3) {
3075    }
3076    sync(t3) {
3077    }
3078    inErrorRecoveryMode(t3) {
3079    }
3080    reportError(t3) {
3081    }
3082  }
3083  class Ae extends _e {
3084    constructor() {
3085      super(), this.errorRecoveryMode = false, this.lastErrorIndex = -1, this.lastErrorStates = null, this.nextTokensContext = null, this.nextTokenState = 0;
3086    }
3087    reset(t3) {
3088      this.endErrorCondition(t3);
3089    }
3090    beginErrorCondition(t3) {
3091      this.errorRecoveryMode = true;
3092    }
3093    inErrorRecoveryMode(t3) {
3094      return this.errorRecoveryMode;
3095    }
3096    endErrorCondition(t3) {
3097      this.errorRecoveryMode = false, this.lastErrorStates = null, this.lastErrorIndex = -1;
3098    }
3099    reportMatch(t3) {
3100      this.endErrorCondition(t3);
3101    }
3102    reportError(t3, e3) {
3103      this.inErrorRecoveryMode(t3) || (this.beginErrorCondition(t3), e3 instanceof ee ? this.reportNoViableAlternative(t3, e3) : e3 instanceof xe ? this.reportInputMismatch(t3, e3) : e3 instanceof Te ? this.reportFailedPredicate(t3, e3) : (console.log("unknown recognition error type: " + e3.constructor.name), console.log(e3.stack), t3.notifyErrorListeners(e3.getOffendingToken(), e3.getMessage(), e3)));
3104    }
3105    recover(t3, e3) {
3106      this.lastErrorIndex === t3.getInputStream().index && null !== this.lastErrorStates && this.lastErrorStates.indexOf(t3.state) >= 0 && t3.consume(), this.lastErrorIndex = t3._input.index, null === this.lastErrorStates && (this.lastErrorStates = []), this.lastErrorStates.push(t3.state);
3107      const n2 = this.getErrorRecoverySet(t3);
3108      this.consumeUntil(t3, n2);
3109    }
3110    sync(e3) {
3111      if (this.inErrorRecoveryMode(e3)) return;
3112      const n2 = e3._interp.atn.states[e3.state], s2 = e3.getTokenStream().LA(1), i3 = e3.atn.nextTokens(n2);
3113      if (i3.contains(s2)) return this.nextTokensContext = null, void (this.nextTokenState = _2.INVALID_STATE_NUMBER);
3114      if (i3.contains(t2.EPSILON)) null === this.nextTokensContext && (this.nextTokensContext = e3._ctx, this.nextTokensState = e3._stateNumber);
3115      else switch (n2.stateType) {
3116        case _2.BLOCK_START:
3117        case _2.STAR_BLOCK_START:
3118        case _2.PLUS_BLOCK_START:
3119        case _2.STAR_LOOP_ENTRY:
3120          if (null !== this.singleTokenDeletion(e3)) return;
3121          throw new xe(e3);
3122        case _2.PLUS_LOOP_BACK:
3123        case _2.STAR_LOOP_BACK: {
3124          this.reportUnwantedToken(e3);
3125          const t3 = new E2();
3126          t3.addSet(e3.getExpectedTokens());
3127          const n3 = t3.addSet(this.getErrorRecoverySet(e3));
3128          this.consumeUntil(e3, n3);
3129        }
3130      }
3131    }
3132    reportNoViableAlternative(e3, n2) {
3133      const s2 = e3.getTokenStream();
3134      let i3;
3135      i3 = null !== s2 ? n2.startToken.type === t2.EOF ? "<EOF>" : s2.getText(new m2(n2.startToken.tokenIndex, n2.offendingToken.tokenIndex)) : "<unknown input>";
3136      const r3 = "no viable alternative at input " + this.escapeWSAndQuote(i3);
3137      e3.notifyErrorListeners(r3, n2.offendingToken, n2);
3138    }
3139    reportInputMismatch(t3, e3) {
3140      const n2 = "mismatched input " + this.getTokenErrorDisplay(e3.offendingToken) + " expecting " + e3.getExpectedTokens().toString(t3.literalNames, t3.symbolicNames);
3141      t3.notifyErrorListeners(n2, e3.offendingToken, e3);
3142    }
3143    reportFailedPredicate(t3, e3) {
3144      const n2 = "rule " + t3.ruleNames[t3._ctx.ruleIndex] + " " + e3.message;
3145      t3.notifyErrorListeners(n2, e3.offendingToken, e3);
3146    }
3147    reportUnwantedToken(t3) {
3148      if (this.inErrorRecoveryMode(t3)) return;
3149      this.beginErrorCondition(t3);
3150      const e3 = t3.getCurrentToken(), n2 = "extraneous input " + this.getTokenErrorDisplay(e3) + " expecting " + this.getExpectedTokens(t3).toString(t3.literalNames, t3.symbolicNames);
3151      t3.notifyErrorListeners(n2, e3, null);
3152    }
3153    reportMissingToken(t3) {
3154      if (this.inErrorRecoveryMode(t3)) return;
3155      this.beginErrorCondition(t3);
3156      const e3 = t3.getCurrentToken(), n2 = "missing " + this.getExpectedTokens(t3).toString(t3.literalNames, t3.symbolicNames) + " at " + this.getTokenErrorDisplay(e3);
3157      t3.notifyErrorListeners(n2, e3, null);
3158    }
3159    recoverInline(t3) {
3160      const e3 = this.singleTokenDeletion(t3);
3161      if (null !== e3) return t3.consume(), e3;
3162      if (this.singleTokenInsertion(t3)) return this.getMissingSymbol(t3);
3163      throw new xe(t3);
3164    }
3165    singleTokenInsertion(t3) {
3166      const e3 = t3.getTokenStream().LA(1), n2 = t3._interp.atn, s2 = n2.states[t3.state].transitions[0].target;
3167      return !!n2.nextTokens(s2, t3._ctx).contains(e3) && (this.reportMissingToken(t3), true);
3168    }
3169    singleTokenDeletion(t3) {
3170      const e3 = t3.getTokenStream().LA(2);
3171      if (this.getExpectedTokens(t3).contains(e3)) {
3172        this.reportUnwantedToken(t3), t3.consume();
3173        const e4 = t3.getCurrentToken();
3174        return this.reportMatch(t3), e4;
3175      }
3176      return null;
3177    }
3178    getMissingSymbol(e3) {
3179      const n2 = e3.getCurrentToken(), s2 = this.getExpectedTokens(e3).first();
3180      let i3;
3181      i3 = s2 === t2.EOF ? "<missing EOF>" : "<missing " + e3.literalNames[s2] + ">";
3182      let r3 = n2;
3183      const o3 = e3.getTokenStream().LT(-1);
3184      return r3.type === t2.EOF && null !== o3 && (r3 = o3), e3.getTokenFactory().create(r3.source, s2, i3, t2.DEFAULT_CHANNEL, -1, -1, r3.line, r3.column);
3185    }
3186    getExpectedTokens(t3) {
3187      return t3.getExpectedTokens();
3188    }
3189    getTokenErrorDisplay(e3) {
3190      if (null === e3) return "<no token>";
3191      let n2 = e3.text;
3192      return null === n2 && (n2 = e3.type === t2.EOF ? "<EOF>" : "<" + e3.type + ">"), this.escapeWSAndQuote(n2);
3193    }
3194    escapeWSAndQuote(t3) {
3195      return "'" + (t3 = (t3 = (t3 = t3.replace(/\n/g, "\\n")).replace(/\r/g, "\\r")).replace(/\t/g, "\\t")) + "'";
3196    }
3197    getErrorRecoverySet(e3) {
3198      const n2 = e3._interp.atn;
3199      let s2 = e3._ctx;
3200      const i3 = new E2();
3201      for (; null !== s2 && s2.invokingState >= 0; ) {
3202        const t3 = n2.states[s2.invokingState].transitions[0], e4 = n2.nextTokens(t3.followState);
3203        i3.addSet(e4), s2 = s2.parentCtx;
3204      }
3205      return i3.removeOne(t2.EPSILON), i3;
3206    }
3207    consumeUntil(e3, n2) {
3208      let s2 = e3.getTokenStream().LA(1);
3209      for (; s2 !== t2.EOF && !n2.contains(s2); ) e3.consume(), s2 = e3.getTokenStream().LA(1);
3210    }
3211  }
3212  class Ce extends Ae {
3213    constructor() {
3214      super();
3215    }
3216    recover(t3, e3) {
3217      let n2 = t3._ctx;
3218      for (; null !== n2; ) n2.exception = e3, n2 = n2.parentCtx;
3219      throw new Ee(e3);
3220    }
3221    recoverInline(t3) {
3222      this.recover(t3, new xe(t3));
3223    }
3224    sync(t3) {
3225    }
3226  }
3227  const Ne = { RecognitionException: Ft, NoViableAltException: ee, LexerNoViableAltException: Mt, InputMismatchException: xe, FailedPredicateException: Te, DiagnosticErrorListener: me, BailErrorStrategy: Ce, DefaultErrorStrategy: Ae, ErrorListener: Ot };
3228  class ye {
3229    constructor(t3, e3) {
3230      if (this.name = "<empty>", this.strdata = t3, this.decodeToUnicodeCodePoints = e3 || false, this._index = 0, this.data = [], this.decodeToUnicodeCodePoints) for (let t4 = 0; t4 < this.strdata.length; ) {
3231        const e4 = this.strdata.codePointAt(t4);
3232        this.data.push(e4), t4 += e4 <= 65535 ? 1 : 2;
3233      }
3234      else {
3235        this.data = new Array(this.strdata.length);
3236        for (let t4 = 0; t4 < this.strdata.length; t4++) this.data[t4] = this.strdata.charCodeAt(t4);
3237      }
3238      this._size = this.data.length;
3239    }
3240    reset() {
3241      this._index = 0;
3242    }
3243    consume() {
3244      if (this._index >= this._size) throw "cannot consume EOF";
3245      this._index += 1;
3246    }
3247    LA(e3) {
3248      if (0 === e3) return 0;
3249      e3 < 0 && (e3 += 1);
3250      const n2 = this._index + e3 - 1;
3251      return n2 < 0 || n2 >= this._size ? t2.EOF : this.data[n2];
3252    }
3253    LT(t3) {
3254      return this.LA(t3);
3255    }
3256    mark() {
3257      return -1;
3258    }
3259    release(t3) {
3260    }
3261    seek(t3) {
3262      t3 <= this._index ? this._index = t3 : this._index = Math.min(t3, this._size);
3263    }
3264    getText(t3, e3) {
3265      if (e3 >= this._size && (e3 = this._size - 1), t3 >= this._size) return "";
3266      if (this.decodeToUnicodeCodePoints) {
3267        let n2 = "";
3268        for (let s2 = t3; s2 <= e3; s2++) n2 += String.fromCodePoint(this.data[s2]);
3269        return n2;
3270      }
3271      return this.strdata.slice(t3, e3 + 1);
3272    }
3273    toString() {
3274      return this.strdata;
3275    }
3276    get index() {
3277      return this._index;
3278    }
3279    get size() {
3280      return this._size;
3281    }
3282  }
3283  class Ie extends ye {
3284    constructor(t3, e3) {
3285      super(t3, e3);
3286    }
3287  }
3288  var ke = n(92);
3289  const Le = "undefined" != typeof process && null != process.versions && null != process.versions.node;
3290  class Oe extends Ie {
3291    static fromPath(t3, e3, n2) {
3292      if (!Le) throw new Error("FileStream is only available when running in Node!");
3293      ke.readFile(t3, e3, (function(t4, e4) {
3294        let s2 = null;
3295        null !== e4 && (s2 = new ye(e4, true)), n2(t4, s2);
3296      }));
3297    }
3298    constructor(t3, e3, n2) {
3299      if (!Le) throw new Error("FileStream is only available when running in Node!");
3300      super(ke.readFileSync(t3, e3 || "utf-8"), n2), this.fileName = t3;
3301    }
3302  }
3303  const ve = { fromString: function(t3) {
3304    return new ye(t3, true);
3305  }, fromBlob: function(t3, e3, n2, s2) {
3306    const i3 = new window.FileReader();
3307    i3.onload = function(t4) {
3308      const e4 = new ye(t4.target.result, true);
3309      n2(e4);
3310    }, i3.onerror = s2, i3.readAsText(t3, e3);
3311  }, fromBuffer: function(t3, e3) {
3312    return new ye(t3.toString(e3), true);
3313  }, fromPath: function(t3, e3, n2) {
3314    Oe.fromPath(t3, e3, n2);
3315  }, fromPathSync: function(t3, e3) {
3316    return new Oe(t3, e3);
3317  } }, Re = { arrayToString: c2, stringToCharArray: function(t3) {
3318    let e3 = new Uint16Array(t3.length);
3319    for (let n2 = 0; n2 < t3.length; n2++) e3[n2] = t3.charCodeAt(n2);
3320    return e3;
3321  } };
3322  class we {
3323  }
3324  class Pe extends we {
3325    constructor(t3) {
3326      super(), this.tokenSource = t3, this.tokens = [], this.index = -1, this.fetchedEOF = false;
3327    }
3328    mark() {
3329      return 0;
3330    }
3331    release(t3) {
3332    }
3333    reset() {
3334      this.seek(0);
3335    }
3336    seek(t3) {
3337      this.lazyInit(), this.index = this.adjustSeekIndex(t3);
3338    }
3339    get size() {
3340      return this.tokens.length;
3341    }
3342    get(t3) {
3343      return this.lazyInit(), this.tokens[t3];
3344    }
3345    consume() {
3346      let e3 = false;
3347      if (e3 = this.index >= 0 && (this.fetchedEOF ? this.index < this.tokens.length - 1 : this.index < this.tokens.length), !e3 && this.LA(1) === t2.EOF) throw "cannot consume EOF";
3348      this.sync(this.index + 1) && (this.index = this.adjustSeekIndex(this.index + 1));
3349    }
3350    sync(t3) {
3351      const e3 = t3 - this.tokens.length + 1;
3352      return !(e3 > 0) || this.fetch(e3) >= e3;
3353    }
3354    fetch(e3) {
3355      if (this.fetchedEOF) return 0;
3356      for (let n2 = 0; n2 < e3; n2++) {
3357        const e4 = this.tokenSource.nextToken();
3358        if (e4.tokenIndex = this.tokens.length, this.tokens.push(e4), e4.type === t2.EOF) return this.fetchedEOF = true, n2 + 1;
3359      }
3360      return e3;
3361    }
3362    getTokens(e3, n2, s2) {
3363      if (void 0 === s2 && (s2 = null), e3 < 0 || n2 < 0) return null;
3364      this.lazyInit();
3365      const i3 = [];
3366      n2 >= this.tokens.length && (n2 = this.tokens.length - 1);
3367      for (let r3 = e3; r3 < n2; r3++) {
3368        const e4 = this.tokens[r3];
3369        if (e4.type === t2.EOF) break;
3370        (null === s2 || s2.contains(e4.type)) && i3.push(e4);
3371      }
3372      return i3;
3373    }
3374    LA(t3) {
3375      return this.LT(t3).type;
3376    }
3377    LB(t3) {
3378      return this.index - t3 < 0 ? null : this.tokens[this.index - t3];
3379    }
3380    LT(t3) {
3381      if (this.lazyInit(), 0 === t3) return null;
3382      if (t3 < 0) return this.LB(-t3);
3383      const e3 = this.index + t3 - 1;
3384      return this.sync(e3), e3 >= this.tokens.length ? this.tokens[this.tokens.length - 1] : this.tokens[e3];
3385    }
3386    adjustSeekIndex(t3) {
3387      return t3;
3388    }
3389    lazyInit() {
3390      -1 === this.index && this.setup();
3391    }
3392    setup() {
3393      this.sync(0), this.index = this.adjustSeekIndex(0);
3394    }
3395    setTokenSource(t3) {
3396      this.tokenSource = t3, this.tokens = [], this.index = -1, this.fetchedEOF = false;
3397    }
3398    nextTokenOnChannel(e3, n2) {
3399      if (this.sync(e3), e3 >= this.tokens.length) return -1;
3400      let s2 = this.tokens[e3];
3401      for (; s2.channel !== this.channel; ) {
3402        if (s2.type === t2.EOF) return -1;
3403        e3 += 1, this.sync(e3), s2 = this.tokens[e3];
3404      }
3405      return e3;
3406    }
3407    previousTokenOnChannel(t3, e3) {
3408      for (; t3 >= 0 && this.tokens[t3].channel !== e3; ) t3 -= 1;
3409      return t3;
3410    }
3411    getHiddenTokensToRight(t3, e3) {
3412      if (void 0 === e3 && (e3 = -1), this.lazyInit(), t3 < 0 || t3 >= this.tokens.length) throw t3 + " not in 0.." + this.tokens.length - 1;
3413      const n2 = this.nextTokenOnChannel(t3 + 1, Ut.DEFAULT_TOKEN_CHANNEL), s2 = t3 + 1, i3 = -1 === n2 ? this.tokens.length - 1 : n2;
3414      return this.filterForChannel(s2, i3, e3);
3415    }
3416    getHiddenTokensToLeft(t3, e3) {
3417      if (void 0 === e3 && (e3 = -1), this.lazyInit(), t3 < 0 || t3 >= this.tokens.length) throw t3 + " not in 0.." + this.tokens.length - 1;
3418      const n2 = this.previousTokenOnChannel(t3 - 1, Ut.DEFAULT_TOKEN_CHANNEL);
3419      if (n2 === t3 - 1) return null;
3420      const s2 = n2 + 1, i3 = t3 - 1;
3421      return this.filterForChannel(s2, i3, e3);
3422    }
3423    filterForChannel(t3, e3, n2) {
3424      const s2 = [];
3425      for (let i3 = t3; i3 < e3 + 1; i3++) {
3426        const t4 = this.tokens[i3];
3427        -1 === n2 ? t4.channel !== Ut.DEFAULT_TOKEN_CHANNEL && s2.push(t4) : t4.channel === n2 && s2.push(t4);
3428      }
3429      return 0 === s2.length ? null : s2;
3430    }
3431    getSourceName() {
3432      return this.tokenSource.getSourceName();
3433    }
3434    getText(e3) {
3435      this.lazyInit(), this.fill(), e3 || (e3 = new m2(0, this.tokens.length - 1));
3436      let n2 = e3.start;
3437      n2 instanceof t2 && (n2 = n2.tokenIndex);
3438      let s2 = e3.stop;
3439      if (s2 instanceof t2 && (s2 = s2.tokenIndex), null === n2 || null === s2 || n2 < 0 || s2 < 0) return "";
3440      s2 >= this.tokens.length && (s2 = this.tokens.length - 1);
3441      let i3 = "";
3442      for (let e4 = n2; e4 < s2 + 1; e4++) {
3443        const n3 = this.tokens[e4];
3444        if (n3.type === t2.EOF) break;
3445        i3 += n3.text;
3446      }
3447      return i3;
3448    }
3449    fill() {
3450      for (this.lazyInit(); 1e3 === this.fetch(1e3); ) ;
3451    }
3452  }
3453  Object.defineProperty(Pe, "size", { get: function() {
3454    return this.tokens.length;
3455  } });
3456  class be extends Pe {
3457    constructor(e3, n2) {
3458      super(e3), this.channel = void 0 === n2 ? t2.DEFAULT_CHANNEL : n2;
3459    }
3460    adjustSeekIndex(t3) {
3461      return this.nextTokenOnChannel(t3, this.channel);
3462    }
3463    LB(t3) {
3464      if (0 === t3 || this.index - t3 < 0) return null;
3465      let e3 = this.index, n2 = 1;
3466      for (; n2 <= t3; ) e3 = this.previousTokenOnChannel(e3 - 1, this.channel), n2 += 1;
3467      return e3 < 0 ? null : this.tokens[e3];
3468    }
3469    LT(t3) {
3470      if (this.lazyInit(), 0 === t3) return null;
3471      if (t3 < 0) return this.LB(-t3);
3472      let e3 = this.index, n2 = 1;
3473      for (; n2 < t3; ) this.sync(e3 + 1) && (e3 = this.nextTokenOnChannel(e3 + 1, this.channel)), n2 += 1;
3474      return this.tokens[e3];
3475    }
3476    getNumberOfOnChannelTokens() {
3477      let e3 = 0;
3478      this.fill();
3479      for (let n2 = 0; n2 < this.tokens.length; n2++) {
3480        const s2 = this.tokens[n2];
3481        if (s2.channel === this.channel && (e3 += 1), s2.type === t2.EOF) break;
3482      }
3483      return e3;
3484    }
3485  }
3486  class De extends de {
3487    constructor(t3) {
3488      super(), this.parser = t3;
3489    }
3490    enterEveryRule(t3) {
3491      console.log("enter   " + this.parser.ruleNames[t3.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
3492    }
3493    visitTerminal(t3) {
3494      console.log("consume " + t3.symbol + " rule " + this.parser.ruleNames[this.parser._ctx.ruleIndex]);
3495    }
3496    exitEveryRule(t3) {
3497      console.log("exit    " + this.parser.ruleNames[t3.ruleIndex] + ", LT(1)=" + this.parser._input.LT(1).text);
3498    }
3499  }
3500  class Fe extends wt {
3501    constructor(t3) {
3502      super(), this._input = null, this._errHandler = new Ae(), this._precedenceStack = [], this._precedenceStack.push(0), this._ctx = null, this.buildParseTrees = true, this._tracer = null, this._parseListeners = null, this._syntaxErrors = 0, this.setInputStream(t3);
3503    }
3504    reset() {
3505      null !== this._input && this._input.seek(0), this._errHandler.reset(this), this._ctx = null, this._syntaxErrors = 0, this.setTrace(false), this._precedenceStack = [], this._precedenceStack.push(0), null !== this._interp && this._interp.reset();
3506    }
3507    match(t3) {
3508      let e3 = this.getCurrentToken();
3509      return e3.type === t3 ? (this._errHandler.reportMatch(this), this.consume()) : (e3 = this._errHandler.recoverInline(this), this.buildParseTrees && -1 === e3.tokenIndex && this._ctx.addErrorNode(e3)), e3;
3510    }
3511    matchWildcard() {
3512      let t3 = this.getCurrentToken();
3513      return t3.type > 0 ? (this._errHandler.reportMatch(this), this.consume()) : (t3 = this._errHandler.recoverInline(this), this.buildParseTrees && -1 === t3.tokenIndex && this._ctx.addErrorNode(t3)), t3;
3514    }
3515    getParseListeners() {
3516      return this._parseListeners || [];
3517    }
3518    addParseListener(t3) {
3519      if (null === t3) throw "listener";
3520      null === this._parseListeners && (this._parseListeners = []), this._parseListeners.push(t3);
3521    }
3522    removeParseListener(t3) {
3523      if (null !== this._parseListeners) {
3524        const e3 = this._parseListeners.indexOf(t3);
3525        e3 >= 0 && this._parseListeners.splice(e3, 1), 0 === this._parseListeners.length && (this._parseListeners = null);
3526      }
3527    }
3528    removeParseListeners() {
3529      this._parseListeners = null;
3530    }
3531    triggerEnterRuleEvent() {
3532      if (null !== this._parseListeners) {
3533        const t3 = this._ctx;
3534        this._parseListeners.forEach((function(e3) {
3535          e3.enterEveryRule(t3), t3.enterRule(e3);
3536        }));
3537      }
3538    }
3539    triggerExitRuleEvent() {
3540      if (null !== this._parseListeners) {
3541        const t3 = this._ctx;
3542        this._parseListeners.slice(0).reverse().forEach((function(e3) {
3543          t3.exitRule(e3), e3.exitEveryRule(t3);
3544        }));
3545      }
3546    }
3547    getTokenFactory() {
3548      return this._input.tokenSource._factory;
3549    }
3550    setTokenFactory(t3) {
3551      this._input.tokenSource._factory = t3;
3552    }
3553    getATNWithBypassAlts() {
3554      const t3 = this.getSerializedATN();
3555      if (null === t3) throw "The current parser does not support an ATN with bypass alternatives.";
3556      let e3 = this.bypassAltsAtnCache[t3];
3557      if (null === e3) {
3558        const n2 = new Tt();
3559        n2.generateRuleBypassTransitions = true, e3 = new Lt(n2).deserialize(t3), this.bypassAltsAtnCache[t3] = e3;
3560      }
3561      return e3;
3562    }
3563    getInputStream() {
3564      return this.getTokenStream();
3565    }
3566    setInputStream(t3) {
3567      this.setTokenStream(t3);
3568    }
3569    getTokenStream() {
3570      return this._input;
3571    }
3572    setTokenStream(t3) {
3573      this._input = null, this.reset(), this._input = t3;
3574    }
3575    get syntaxErrorsCount() {
3576      return this._syntaxErrors;
3577    }
3578    getCurrentToken() {
3579      return this._input.LT(1);
3580    }
3581    notifyErrorListeners(t3, e3, n2) {
3582      n2 = n2 || null, null === (e3 = e3 || null) && (e3 = this.getCurrentToken()), this._syntaxErrors += 1;
3583      const s2 = e3.line, i3 = e3.column;
3584      this.getErrorListenerDispatch().syntaxError(this, e3, s2, i3, t3, n2);
3585    }
3586    consume() {
3587      const e3 = this.getCurrentToken();
3588      e3.type !== t2.EOF && this.getInputStream().consume();
3589      const n2 = null !== this._parseListeners && this._parseListeners.length > 0;
3590      if (this.buildParseTrees || n2) {
3591        let t3;
3592        t3 = this._errHandler.inErrorRecoveryMode(this) ? this._ctx.addErrorNode(e3) : this._ctx.addTokenNode(e3), t3.invokingState = this.state, n2 && this._parseListeners.forEach((function(e4) {
3593          t3 instanceof b2 || void 0 !== t3.isErrorNode && t3.isErrorNode() ? e4.visitErrorNode(t3) : t3 instanceof P2 && e4.visitTerminal(t3);
3594        }));
3595      }
3596      return e3;
3597    }
3598    addContextToParseTree() {
3599      null !== this._ctx.parentCtx && this._ctx.parentCtx.addChild(this._ctx);
3600    }
3601    enterRule(t3, e3, n2) {
3602      this.state = e3, this._ctx = t3, this._ctx.start = this._input.LT(1), this.buildParseTrees && this.addContextToParseTree(), this.triggerEnterRuleEvent();
3603    }
3604    exitRule() {
3605      this._ctx.stop = this._input.LT(-1), this.triggerExitRuleEvent(), this.state = this._ctx.invokingState, this._ctx = this._ctx.parentCtx;
3606    }
3607    enterOuterAlt(t3, e3) {
3608      t3.setAltNumber(e3), this.buildParseTrees && this._ctx !== t3 && null !== this._ctx.parentCtx && (this._ctx.parentCtx.removeLastChild(), this._ctx.parentCtx.addChild(t3)), this._ctx = t3;
3609    }
3610    getPrecedence() {
3611      return 0 === this._precedenceStack.length ? -1 : this._precedenceStack[this._precedenceStack.length - 1];
3612    }
3613    enterRecursionRule(t3, e3, n2, s2) {
3614      this.state = e3, this._precedenceStack.push(s2), this._ctx = t3, this._ctx.start = this._input.LT(1), this.triggerEnterRuleEvent();
3615    }
3616    pushNewRecursionContext(t3, e3, n2) {
3617      const s2 = this._ctx;
3618      s2.parentCtx = t3, s2.invokingState = e3, s2.stop = this._input.LT(-1), this._ctx = t3, this._ctx.start = s2.start, this.buildParseTrees && this._ctx.addChild(s2), this.triggerEnterRuleEvent();
3619    }
3620    unrollRecursionContexts(t3) {
3621      this._precedenceStack.pop(), this._ctx.stop = this._input.LT(-1);
3622      const e3 = this._ctx, n2 = this.getParseListeners();
3623      if (null !== n2 && n2.length > 0) for (; this._ctx !== t3; ) this.triggerExitRuleEvent(), this._ctx = this._ctx.parentCtx;
3624      else this._ctx = t3;
3625      e3.parentCtx = t3, this.buildParseTrees && null !== t3 && t3.addChild(e3);
3626    }
3627    getInvokingContext(t3) {
3628      let e3 = this._ctx;
3629      for (; null !== e3; ) {
3630        if (e3.ruleIndex === t3) return e3;
3631        e3 = e3.parentCtx;
3632      }
3633      return null;
3634    }
3635    precpred(t3, e3) {
3636      return e3 >= this._precedenceStack[this._precedenceStack.length - 1];
3637    }
3638    inContext(t3) {
3639      return false;
3640    }
3641    isExpectedToken(e3) {
3642      const n2 = this._interp.atn;
3643      let s2 = this._ctx;
3644      const i3 = n2.states[this.state];
3645      let r3 = n2.nextTokens(i3);
3646      if (r3.contains(e3)) return true;
3647      if (!r3.contains(t2.EPSILON)) return false;
3648      for (; null !== s2 && s2.invokingState >= 0 && r3.contains(t2.EPSILON); ) {
3649        const t3 = n2.states[s2.invokingState].transitions[0];
3650        if (r3 = n2.nextTokens(t3.followState), r3.contains(e3)) return true;
3651        s2 = s2.parentCtx;
3652      }
3653      return !(!r3.contains(t2.EPSILON) || e3 !== t2.EOF);
3654    }
3655    getExpectedTokens() {
3656      return this._interp.atn.getExpectedTokens(this.state, this._ctx);
3657    }
3658    getExpectedTokensWithinCurrentRule() {
3659      const t3 = this._interp.atn, e3 = t3.states[this.state];
3660      return t3.nextTokens(e3);
3661    }
3662    getRuleIndex(t3) {
3663      const e3 = this.getRuleIndexMap()[t3];
3664      return null !== e3 ? e3 : -1;
3665    }
3666    getRuleInvocationStack(t3) {
3667      null === (t3 = t3 || null) && (t3 = this._ctx);
3668      const e3 = [];
3669      for (; null !== t3; ) {
3670        const n2 = t3.ruleIndex;
3671        n2 < 0 ? e3.push("n/a") : e3.push(this.ruleNames[n2]), t3 = t3.parentCtx;
3672      }
3673      return e3;
3674    }
3675    getDFAStrings() {
3676      return this._interp.decisionToDFA.toString();
3677    }
3678    dumpDFA() {
3679      let t3 = false;
3680      for (let e3 = 0; e3 < this._interp.decisionToDFA.length; e3++) {
3681        const n2 = this._interp.decisionToDFA[e3];
3682        n2.states.length > 0 && (t3 && console.log(), this.printer.println("Decision " + n2.decision + ":"), this.printer.print(n2.toString(this.literalNames, this.symbolicNames)), t3 = true);
3683      }
3684    }
3685    getSourceName() {
3686      return this._input.sourceName;
3687    }
3688    setTrace(t3) {
3689      t3 ? (null !== this._tracer && this.removeParseListener(this._tracer), this._tracer = new De(this), this.addParseListener(this._tracer)) : (this.removeParseListener(this._tracer), this._tracer = null);
3690    }
3691  }
3692  Fe.bypassAltsAtnCache = {};
3693  class Me extends P2 {
3694    constructor(t3) {
3695      super(), this.parentCtx = null, this.symbol = t3;
3696    }
3697    getChild(t3) {
3698      return null;
3699    }
3700    getSymbol() {
3701      return this.symbol;
3702    }
3703    getParent() {
3704      return this.parentCtx;
3705    }
3706    getPayload() {
3707      return this.symbol;
3708    }
3709    getSourceInterval() {
3710      if (null === this.symbol) return m2.INVALID_INTERVAL;
3711      const t3 = this.symbol.tokenIndex;
3712      return new m2(t3, t3);
3713    }
3714    getChildCount() {
3715      return 0;
3716    }
3717    accept(t3) {
3718      return t3.visitTerminal(this);
3719    }
3720    getText() {
3721      return this.symbol.text;
3722    }
3723    toString() {
3724      return this.symbol.type === t2.EOF ? "<EOF>" : this.symbol.text;
3725    }
3726  }
3727  class Ue extends Me {
3728    constructor(t3) {
3729      super(t3);
3730    }
3731    isErrorNode() {
3732      return true;
3733    }
3734    accept(t3) {
3735      return t3.visitErrorNode(this);
3736    }
3737  }
3738  class Be extends M2 {
3739    constructor(t3, e3) {
3740      super(t3, e3), this.children = null, this.start = null, this.stop = null, this.exception = null;
3741    }
3742    copyFrom(t3) {
3743      this.parentCtx = t3.parentCtx, this.invokingState = t3.invokingState, this.children = null, this.start = t3.start, this.stop = t3.stop, t3.children && (this.children = [], t3.children.map((function(t4) {
3744        t4 instanceof Ue && (this.children.push(t4), t4.parentCtx = this);
3745      }), this));
3746    }
3747    enterRule(t3) {
3748    }
3749    exitRule(t3) {
3750    }
3751    addChild(t3) {
3752      return null === this.children && (this.children = []), this.children.push(t3), t3;
3753    }
3754    removeLastChild() {
3755      null !== this.children && this.children.pop();
3756    }
3757    addTokenNode(t3) {
3758      const e3 = new Me(t3);
3759      return this.addChild(e3), e3.parentCtx = this, e3;
3760    }
3761    addErrorNode(t3) {
3762      const e3 = new Ue(t3);
3763      return this.addChild(e3), e3.parentCtx = this, e3;
3764    }
3765    getChild(t3, e3) {
3766      if (e3 = e3 || null, null === this.children || t3 < 0 || t3 >= this.children.length) return null;
3767      if (null === e3) return this.children[t3];
3768      for (let n2 = 0; n2 < this.children.length; n2++) {
3769        const s2 = this.children[n2];
3770        if (s2 instanceof e3) {
3771          if (0 === t3) return s2;
3772          t3 -= 1;
3773        }
3774      }
3775      return null;
3776    }
3777    getToken(t3, e3) {
3778      if (null === this.children || e3 < 0 || e3 >= this.children.length) return null;
3779      for (let n2 = 0; n2 < this.children.length; n2++) {
3780        const s2 = this.children[n2];
3781        if (s2 instanceof P2 && s2.symbol.type === t3) {
3782          if (0 === e3) return s2;
3783          e3 -= 1;
3784        }
3785      }
3786      return null;
3787    }
3788    getTokens(t3) {
3789      if (null === this.children) return [];
3790      {
3791        const e3 = [];
3792        for (let n2 = 0; n2 < this.children.length; n2++) {
3793          const s2 = this.children[n2];
3794          s2 instanceof P2 && s2.symbol.type === t3 && e3.push(s2);
3795        }
3796        return e3;
3797      }
3798    }
3799    getTypedRuleContext(t3, e3) {
3800      return this.getChild(e3, t3);
3801    }
3802    getTypedRuleContexts(t3) {
3803      if (null === this.children) return [];
3804      {
3805        const e3 = [];
3806        for (let n2 = 0; n2 < this.children.length; n2++) {
3807          const s2 = this.children[n2];
3808          s2 instanceof t3 && e3.push(s2);
3809        }
3810        return e3;
3811      }
3812    }
3813    getChildCount() {
3814      return null === this.children ? 0 : this.children.length;
3815    }
3816    getSourceInterval() {
3817      return null === this.start || null === this.stop ? m2.INVALID_INTERVAL : new m2(this.start.tokenIndex, this.stop.tokenIndex);
3818    }
3819  }
3820  M2.EMPTY = new Be();
3821  class Ve {
3822    constructor(t3) {
3823      this.tokens = t3, this.programs = /* @__PURE__ */ new Map();
3824    }
3825    getTokenStream() {
3826      return this.tokens;
3827    }
3828    insertAfter(t3, e3) {
3829      let n2, s2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : Ve.DEFAULT_PROGRAM_NAME;
3830      n2 = "number" == typeof t3 ? t3 : t3.tokenIndex;
3831      let i3 = this.getProgram(s2), r3 = new Ge(this.tokens, n2, i3.length, e3);
3832      i3.push(r3);
3833    }
3834    insertBefore(t3, e3) {
3835      let n2, s2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : Ve.DEFAULT_PROGRAM_NAME;
3836      n2 = "number" == typeof t3 ? t3 : t3.tokenIndex;
3837      const i3 = this.getProgram(s2), r3 = new Ye(this.tokens, n2, i3.length, e3);
3838      i3.push(r3);
3839    }
3840    replaceSingle(t3, e3) {
3841      let n2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : Ve.DEFAULT_PROGRAM_NAME;
3842      this.replace(t3, t3, e3, n2);
3843    }
3844    replace(t3, e3, n2) {
3845      let s2 = arguments.length > 3 && void 0 !== arguments[3] ? arguments[3] : Ve.DEFAULT_PROGRAM_NAME;
3846      if ("number" != typeof t3 && (t3 = t3.tokenIndex), "number" != typeof e3 && (e3 = e3.tokenIndex), t3 > e3 || t3 < 0 || e3 < 0 || e3 >= this.tokens.size) throw new RangeError(`replace: range invalid: ${t3}..${e3}(size=${this.tokens.size})`);
3847      let i3 = this.getProgram(s2), r3 = new je(this.tokens, t3, e3, i3.length, n2);
3848      i3.push(r3);
3849    }
3850    delete(t3, e3) {
3851      let n2 = arguments.length > 2 && void 0 !== arguments[2] ? arguments[2] : Ve.DEFAULT_PROGRAM_NAME;
3852      void 0 === e3 && (e3 = t3), this.replace(t3, e3, null, n2);
3853    }
3854    getProgram(t3) {
3855      let e3 = this.programs.get(t3);
3856      return null == e3 && (e3 = this.initializeProgram(t3)), e3;
3857    }
3858    initializeProgram(t3) {
3859      const e3 = [];
3860      return this.programs.set(t3, e3), e3;
3861    }
3862    getText(e3) {
3863      let n2, s2 = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : Ve.DEFAULT_PROGRAM_NAME;
3864      n2 = e3 instanceof m2 ? e3 : new m2(0, this.tokens.size - 1), "string" == typeof e3 && (s2 = e3);
3865      const i3 = this.programs.get(s2);
3866      let r3 = n2.start, o3 = n2.stop;
3867      if (o3 > this.tokens.size - 1 && (o3 = this.tokens.size - 1), r3 < 0 && (r3 = 0), null == i3 || 0 === i3.length) return this.tokens.getText(new m2(r3, o3));
3868      let a3 = [], l3 = this.reduceToSingleOperationPerIndex(i3), h3 = r3;
3869      for (; h3 <= o3 && h3 < this.tokens.size; ) {
3870        let e4 = l3.get(h3);
3871        l3.delete(h3);
3872        let n3 = this.tokens.get(h3);
3873        null == e4 ? (n3.type !== t2.EOF && a3.push(String(n3.text)), h3++) : h3 = e4.execute(a3);
3874      }
3875      if (o3 === this.tokens.size - 1) for (const t3 of l3.values()) t3.index >= this.tokens.size - 1 && a3.push(t3.text.toString());
3876      return a3.join("");
3877    }
3878    reduceToSingleOperationPerIndex(t3) {
3879      for (let e4 = 0; e4 < t3.length; e4++) {
3880        let n2 = t3[e4];
3881        if (null == n2) continue;
3882        if (!(n2 instanceof je)) continue;
3883        let s2 = n2, i3 = this.getKindOfOps(t3, Ye, e4);
3884        for (let e5 of i3) e5.index === s2.index ? (t3[e5.instructionIndex] = void 0, s2.text = e5.text.toString() + (null != s2.text ? s2.text.toString() : "")) : e5.index > s2.index && e5.index <= s2.lastIndex && (t3[e5.instructionIndex] = void 0);
3885        let r3 = this.getKindOfOps(t3, je, e4);
3886        for (let e5 of r3) {
3887          if (e5.index >= s2.index && e5.lastIndex <= s2.lastIndex) {
3888            t3[e5.instructionIndex] = void 0;
3889            continue;
3890          }
3891          let n3 = e5.lastIndex < s2.index || e5.index > s2.lastIndex;
3892          if (null != e5.text || null != s2.text || n3) {
3893            if (!n3) throw new Error(`replace op boundaries of ${s2} overlap with previous ${e5}`);
3894          } else t3[e5.instructionIndex] = void 0, s2.index = Math.min(e5.index, s2.index), s2.lastIndex = Math.max(e5.lastIndex, s2.lastIndex);
3895        }
3896      }
3897      for (let e4 = 0; e4 < t3.length; e4++) {
3898        let n2 = t3[e4];
3899        if (null == n2) continue;
3900        if (!(n2 instanceof Ye)) continue;
3901        let s2 = n2, i3 = this.getKindOfOps(t3, Ye, e4);
3902        for (let e5 of i3) e5.index === s2.index && (e5 instanceof Ge ? (s2.text = this.catOpText(e5.text, s2.text), t3[e5.instructionIndex] = void 0) : e5 instanceof Ye && (s2.text = this.catOpText(s2.text, e5.text), t3[e5.instructionIndex] = void 0));
3903        let r3 = this.getKindOfOps(t3, je, e4);
3904        for (let n3 of r3) if (s2.index !== n3.index) {
3905          if (s2.index >= n3.index && s2.index <= n3.lastIndex) throw new Error(`insert op ${s2} within boundaries of previous ${n3}`);
3906        } else n3.text = this.catOpText(s2.text, n3.text), t3[e4] = void 0;
3907      }
3908      let e3 = /* @__PURE__ */ new Map();
3909      for (let n2 of t3) if (null != n2) {
3910        if (null != e3.get(n2.index)) throw new Error("should only be one op per index");
3911        e3.set(n2.index, n2);
3912      }
3913      return e3;
3914    }
3915    catOpText(t3, e3) {
3916      let n2 = "", s2 = "";
3917      return null != t3 && (n2 = t3.toString()), null != e3 && (s2 = e3.toString()), n2 + s2;
3918    }
3919    getKindOfOps(t3, e3, n2) {
3920      return t3.slice(0, n2).filter(((t4) => t4 && t4 instanceof e3));
3921    }
3922  }
3923  var ze, qe, He;
3924  ze = Ve, He = "default", (qe = (function(t3) {
3925    var e3 = (function(t4, e4) {
3926      if ("object" != typeof t4 || null === t4) return t4;
3927      var n2 = t4[Symbol.toPrimitive];
3928      if (void 0 !== n2) {
3929        var s2 = n2.call(t4, "string");
3930        if ("object" != typeof s2) return s2;
3931        throw new TypeError("@@toPrimitive must return a primitive value.");
3932      }
3933      return String(t4);
3934    })(t3);
3935    return "symbol" == typeof e3 ? e3 : String(e3);
3936  })(qe = "DEFAULT_PROGRAM_NAME")) in ze ? Object.defineProperty(ze, qe, { value: He, enumerable: true, configurable: true, writable: true }) : ze[qe] = He;
3937  class Ke {
3938    constructor(t3, e3, n2, s2) {
3939      this.tokens = t3, this.instructionIndex = n2, this.index = e3, this.text = void 0 === s2 ? "" : s2;
3940    }
3941    toString() {
3942      let t3 = this.constructor.name;
3943      const e3 = t3.indexOf("$");
3944      return t3 = t3.substring(e3 + 1, t3.length), "<" + t3 + "@" + this.tokens.get(this.index) + ':"' + this.text + '">';
3945    }
3946  }
3947  class Ye extends Ke {
3948    constructor(t3, e3, n2, s2) {
3949      super(t3, e3, n2, s2);
3950    }
3951    execute(e3) {
3952      return this.text && e3.push(this.text.toString()), this.tokens.get(this.index).type !== t2.EOF && e3.push(String(this.tokens.get(this.index).text)), this.index + 1;
3953    }
3954  }
3955  class Ge extends Ye {
3956    constructor(t3, e3, n2, s2) {
3957      super(t3, e3 + 1, n2, s2);
3958    }
3959  }
3960  class je extends Ke {
3961    constructor(t3, e3, n2, s2, i3) {
3962      super(t3, e3, s2, i3), this.lastIndex = n2;
3963    }
3964    execute(t3) {
3965      return this.text && t3.push(this.text.toString()), this.lastIndex + 1;
3966    }
3967    toString() {
3968      return null == this.text ? "<DeleteOp@" + this.tokens.get(this.index) + ".." + this.tokens.get(this.lastIndex) + ">" : "<ReplaceOp@" + this.tokens.get(this.index) + ".." + this.tokens.get(this.lastIndex) + ':"' + this.text + '">';
3969    }
3970  }
3971  const We = { atn: re, dfa: he, context: ce, misc: ue, tree: fe, error: Ne, Token: t2, CommonToken: Pt, CharStreams: ve, CharStream: Ie, InputStream: Ie, CommonTokenStream: be, Lexer: Ut, Parser: Fe, ParserRuleContext: Be, Interval: m2, IntervalSet: E2, LL1Analyzer: W, Utils: Re, TokenStreamRewriter: Ve };
3972})();
3973var i = s.dx;
3974var r = s.q2;
3975var o = s.FO;
3976var a = s.xf;
3977var l = s.Gy;
3978var h = s.s4;
3979var c = s.c7;
3980var u = s._7;
3981var d = s.tx;
3982var p = s.gp;
3983var g = s.cK;
3984var f = s.zs;
3985var x = s.AV;
3986var T = s.Xp;
3987var S = s.VS;
3988var m = s.ul;
3989var E = s.hW;
3990var _ = s.x1;
3991var A = s.z5;
3992var C = s.oN;
3993var N = s.TB;
3994var y = s.u1;
3995var I = s._b;
3996var k = s.$F;
3997var L = s._T;
3998var O = s.db;
3999var v = s.Zx;
4000var R = s._x;
4001var w = s.r8;
4002var P = s.JI;
4003var b = s.TP;
4004var D = s.WU;
4005var F = s.Nj;
4006var M = s.ZP;
4007