pickle-jar 1.4.3 → 1.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (44) hide show
  1. package/README.md +18 -0
  2. package/package.json +15 -12
  3. package/dist/src/feature-context.d.ts +0 -6
  4. package/dist/src/feature-context.js +0 -3
  5. package/dist/src/feature-context.js.map +0 -1
  6. package/dist/src/feature-file-visitor.d.ts +0 -29
  7. package/dist/src/feature-file-visitor.js +0 -217
  8. package/dist/src/feature-file-visitor.js.map +0 -1
  9. package/dist/src/get-call-sites.d.ts +0 -2
  10. package/dist/src/get-call-sites.js +0 -12
  11. package/dist/src/get-call-sites.js.map +0 -1
  12. package/dist/src/grammar/GherkinLexer.d.ts +0 -46
  13. package/dist/src/grammar/GherkinLexer.js +0 -245
  14. package/dist/src/grammar/GherkinLexer.js.map +0 -1
  15. package/dist/src/grammar/GherkinParser.d.ts +0 -330
  16. package/dist/src/grammar/GherkinParser.js +0 -2896
  17. package/dist/src/grammar/GherkinParser.js.map +0 -1
  18. package/dist/src/grammar/GherkinParserVisitor.d.ts +0 -164
  19. package/dist/src/grammar/GherkinParserVisitor.js +0 -4
  20. package/dist/src/grammar/GherkinParserVisitor.js.map +0 -1
  21. package/dist/src/index.d.ts +0 -8
  22. package/dist/src/index.js +0 -12
  23. package/dist/src/index.js.map +0 -1
  24. package/dist/src/jest-error-listener.d.ts +0 -8
  25. package/dist/src/jest-error-listener.js +0 -22
  26. package/dist/src/jest-error-listener.js.map +0 -1
  27. package/dist/src/step-definition.d.ts +0 -5
  28. package/dist/src/step-definition.js +0 -3
  29. package/dist/src/step-definition.js.map +0 -1
  30. package/dist/src/step-tags.d.ts +0 -7
  31. package/dist/src/step-tags.js +0 -3
  32. package/dist/src/step-tags.js.map +0 -1
  33. package/dist/src/step.d.ts +0 -1
  34. package/dist/src/step.js +0 -3
  35. package/dist/src/step.js.map +0 -1
  36. package/dist/src/tags.d.ts +0 -4
  37. package/dist/src/tags.js +0 -22
  38. package/dist/src/tags.js.map +0 -1
  39. package/dist/src/test-runner.d.ts +0 -3
  40. package/dist/src/test-runner.js +0 -49
  41. package/dist/src/test-runner.js.map +0 -1
  42. package/dist/src/world.d.ts +0 -2
  43. package/dist/src/world.js +0 -3
  44. package/dist/src/world.js.map +0 -1
package/dist/src/grammar/GherkinParser.js DELETED
@@ -1,2896 +0,0 @@
1
- "use strict";
2
- // @ts-nocheck
3
- // Generated from ./src/grammar/GherkinParser.g4 by ANTLR 4.9.0-SNAPSHOT
4
- Object.defineProperty(exports, "__esModule", { value: true });
5
- exports.MultilineTextContext = exports.ContentTextContext = exports.ThenTagsContext = exports.TagsContext = exports.DocStringContext = exports.ButStepContext = exports.AndStepContext = exports.ThenStepContext = exports.AndWhenStepContext = exports.WhenStepContext = exports.AndGivenStepContext = exports.GivenStepContext = exports.StepContext = exports.CellContext = exports.TableRowContext = exports.TableHeaderContext = exports.ExamplesBlockContext = exports.ScenarioOutlineContext = exports.ScenarioContext = exports.BackgroundContext = exports.FeatureContext = exports.FeatureFileContext = exports.GherkinParser = void 0;
6
- const tslib_1 = require("tslib");
7
- const ATN_1 = require("antlr4ts/atn/ATN");
8
- const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
9
- const FailedPredicateException_1 = require("antlr4ts/FailedPredicateException");
10
- const NoViableAltException_1 = require("antlr4ts/NoViableAltException");
11
- const Parser_1 = require("antlr4ts/Parser");
12
- const ParserRuleContext_1 = require("antlr4ts/ParserRuleContext");
13
- const ParserATNSimulator_1 = require("antlr4ts/atn/ParserATNSimulator");
14
- const RecognitionException_1 = require("antlr4ts/RecognitionException");
15
- const Token_1 = require("antlr4ts/Token");
16
- const VocabularyImpl_1 = require("antlr4ts/VocabularyImpl");
17
- const Utils = tslib_1.__importStar(require("antlr4ts/misc/Utils"));
18
- class GherkinParser extends Parser_1.Parser {
19
- // @Override
20
- // @NotNull
21
- get vocabulary() {
22
- return GherkinParser.VOCABULARY;
23
- }
24
- // tslint:enable:no-trailing-whitespace
25
- // @Override
26
- get grammarFileName() { return "GherkinParser.g4"; }
27
- // @Override
28
- get ruleNames() { return GherkinParser.ruleNames; }
29
- // @Override
30
- get serializedATN() { return GherkinParser._serializedATN; }
31
- createFailedPredicateException(predicate, message) {
32
- return new FailedPredicateException_1.FailedPredicateException(this, predicate, message);
33
- }
34
- constructor(input) {
35
- super(input);
36
- this._interp = new ParserATNSimulator_1.ParserATNSimulator(GherkinParser._ATN, this);
37
- }
38
- // @RuleVersion(0)
39
- featureFile() {
40
- let _localctx = new FeatureFileContext(this._ctx, this.state);
41
- this.enterRule(_localctx, 0, GherkinParser.RULE_featureFile);
42
- let _la;
43
- try {
44
- let _alt;
45
- this.enterOuterAlt(_localctx, 1);
46
- {
47
- this.state = 47;
48
- this._errHandler.sync(this);
49
- _alt = this.interpreter.adaptivePredict(this._input, 0, this._ctx);
50
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
51
- if (_alt === 1) {
52
- {
53
- {
54
- this.state = 44;
55
- this.feature();
56
- }
57
- }
58
- }
59
- this.state = 49;
60
- this._errHandler.sync(this);
61
- _alt = this.interpreter.adaptivePredict(this._input, 0, this._ctx);
62
- }
63
- this.state = 53;
64
- this._errHandler.sync(this);
65
- _la = this._input.LA(1);
66
- while (_la === GherkinParser.NEWLINE) {
67
- {
68
- {
69
- this.state = 50;
70
- this.match(GherkinParser.NEWLINE);
71
- }
72
- }
73
- this.state = 55;
74
- this._errHandler.sync(this);
75
- _la = this._input.LA(1);
76
- }
77
- this.state = 56;
78
- this.match(GherkinParser.EOF);
79
- }
80
- }
81
- catch (re) {
82
- if (re instanceof RecognitionException_1.RecognitionException) {
83
- _localctx.exception = re;
84
- this._errHandler.reportError(this, re);
85
- this._errHandler.recover(this, re);
86
- }
87
- else {
88
- throw re;
89
- }
90
- }
91
- finally {
92
- this.exitRule();
93
- }
94
- return _localctx;
95
- }
96
- // @RuleVersion(0)
97
- feature() {
98
- let _localctx = new FeatureContext(this._ctx, this.state);
99
- this.enterRule(_localctx, 2, GherkinParser.RULE_feature);
100
- let _la;
101
- try {
102
- let _alt;
103
- this.enterOuterAlt(_localctx, 1);
104
- {
105
- this.state = 59;
106
- this._errHandler.sync(this);
107
- switch (this.interpreter.adaptivePredict(this._input, 2, this._ctx)) {
108
- case 1:
109
- {
110
- this.state = 58;
111
- this.tags();
112
- }
113
- break;
114
- }
115
- this.state = 64;
116
- this._errHandler.sync(this);
117
- _la = this._input.LA(1);
118
- while (_la === GherkinParser.NEWLINE) {
119
- {
120
- {
121
- this.state = 61;
122
- this.match(GherkinParser.NEWLINE);
123
- }
124
- }
125
- this.state = 66;
126
- this._errHandler.sync(this);
127
- _la = this._input.LA(1);
128
- }
129
- this.state = 67;
130
- this.match(GherkinParser.FEATURE);
131
- this.state = 68;
132
- this.multilineText();
133
- this.state = 70;
134
- this._errHandler.sync(this);
135
- switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
136
- case 1:
137
- {
138
- this.state = 69;
139
- this.background();
140
- }
141
- break;
142
- }
143
- this.state = 76;
144
- this._errHandler.sync(this);
145
- _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
146
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
147
- if (_alt === 1) {
148
- {
149
- this.state = 74;
150
- this._errHandler.sync(this);
151
- switch (this.interpreter.adaptivePredict(this._input, 5, this._ctx)) {
152
- case 1:
153
- {
154
- this.state = 72;
155
- this.scenario();
156
- }
157
- break;
158
- case 2:
159
- {
160
- this.state = 73;
161
- this.scenarioOutline();
162
- }
163
- break;
164
- }
165
- }
166
- }
167
- this.state = 78;
168
- this._errHandler.sync(this);
169
- _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
170
- }
171
- this.state = 82;
172
- this._errHandler.sync(this);
173
- _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
174
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
175
- if (_alt === 1) {
176
- {
177
- {
178
- this.state = 79;
179
- this.match(GherkinParser.NEWLINE);
180
- }
181
- }
182
- }
183
- this.state = 84;
184
- this._errHandler.sync(this);
185
- _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
186
- }
187
- }
188
- }
189
- catch (re) {
190
- if (re instanceof RecognitionException_1.RecognitionException) {
191
- _localctx.exception = re;
192
- this._errHandler.reportError(this, re);
193
- this._errHandler.recover(this, re);
194
- }
195
- else {
196
- throw re;
197
- }
198
- }
199
- finally {
200
- this.exitRule();
201
- }
202
- return _localctx;
203
- }
204
- // @RuleVersion(0)
205
- background() {
206
- let _localctx = new BackgroundContext(this._ctx, this.state);
207
- this.enterRule(_localctx, 4, GherkinParser.RULE_background);
208
- let _la;
209
- try {
210
- let _alt;
211
- this.enterOuterAlt(_localctx, 1);
212
- {
213
- this.state = 86;
214
- this._errHandler.sync(this);
215
- switch (this.interpreter.adaptivePredict(this._input, 8, this._ctx)) {
216
- case 1:
217
- {
218
- this.state = 85;
219
- this.tags();
220
- }
221
- break;
222
- }
223
- this.state = 91;
224
- this._errHandler.sync(this);
225
- _la = this._input.LA(1);
226
- while (_la === GherkinParser.NEWLINE) {
227
- {
228
- {
229
- this.state = 88;
230
- this.match(GherkinParser.NEWLINE);
231
- }
232
- }
233
- this.state = 93;
234
- this._errHandler.sync(this);
235
- _la = this._input.LA(1);
236
- }
237
- this.state = 94;
238
- this.match(GherkinParser.BACKGROUND);
239
- this.state = 95;
240
- this.multilineText();
241
- this.state = 96;
242
- this.givenStep();
243
- this.state = 100;
244
- this._errHandler.sync(this);
245
- _alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
246
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
247
- if (_alt === 1) {
248
- {
249
- {
250
- this.state = 97;
251
- this.andGivenStep();
252
- }
253
- }
254
- }
255
- this.state = 102;
256
- this._errHandler.sync(this);
257
- _alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
258
- }
259
- }
260
- }
261
- catch (re) {
262
- if (re instanceof RecognitionException_1.RecognitionException) {
263
- _localctx.exception = re;
264
- this._errHandler.reportError(this, re);
265
- this._errHandler.recover(this, re);
266
- }
267
- else {
268
- throw re;
269
- }
270
- }
271
- finally {
272
- this.exitRule();
273
- }
274
- return _localctx;
275
- }
276
- // @RuleVersion(0)
277
- scenario() {
278
- let _localctx = new ScenarioContext(this._ctx, this.state);
279
- this.enterRule(_localctx, 6, GherkinParser.RULE_scenario);
280
- let _la;
281
- try {
282
- this.enterOuterAlt(_localctx, 1);
283
- {
284
- this.state = 104;
285
- this._errHandler.sync(this);
286
- switch (this.interpreter.adaptivePredict(this._input, 11, this._ctx)) {
287
- case 1:
288
- {
289
- this.state = 103;
290
- this.tags();
291
- }
292
- break;
293
- }
294
- this.state = 109;
295
- this._errHandler.sync(this);
296
- _la = this._input.LA(1);
297
- while (_la === GherkinParser.NEWLINE) {
298
- {
299
- {
300
- this.state = 106;
301
- this.match(GherkinParser.NEWLINE);
302
- }
303
- }
304
- this.state = 111;
305
- this._errHandler.sync(this);
306
- _la = this._input.LA(1);
307
- }
308
- this.state = 112;
309
- this.match(GherkinParser.SCENARIO);
310
- this.state = 113;
311
- this.multilineText();
312
- this.state = 114;
313
- this.step();
314
- }
315
- }
316
- catch (re) {
317
- if (re instanceof RecognitionException_1.RecognitionException) {
318
- _localctx.exception = re;
319
- this._errHandler.reportError(this, re);
320
- this._errHandler.recover(this, re);
321
- }
322
- else {
323
- throw re;
324
- }
325
- }
326
- finally {
327
- this.exitRule();
328
- }
329
- return _localctx;
330
- }
331
- // @RuleVersion(0)
332
- scenarioOutline() {
333
- let _localctx = new ScenarioOutlineContext(this._ctx, this.state);
334
- this.enterRule(_localctx, 8, GherkinParser.RULE_scenarioOutline);
335
- let _la;
336
- try {
337
- this.enterOuterAlt(_localctx, 1);
338
- {
339
- this.state = 117;
340
- this._errHandler.sync(this);
341
- switch (this.interpreter.adaptivePredict(this._input, 13, this._ctx)) {
342
- case 1:
343
- {
344
- this.state = 116;
345
- this.tags();
346
- }
347
- break;
348
- }
349
- this.state = 122;
350
- this._errHandler.sync(this);
351
- _la = this._input.LA(1);
352
- while (_la === GherkinParser.NEWLINE) {
353
- {
354
- {
355
- this.state = 119;
356
- this.match(GherkinParser.NEWLINE);
357
- }
358
- }
359
- this.state = 124;
360
- this._errHandler.sync(this);
361
- _la = this._input.LA(1);
362
- }
363
- this.state = 125;
364
- this.match(GherkinParser.SCENARIO_OUTLINE);
365
- this.state = 126;
366
- this.multilineText();
367
- this.state = 127;
368
- this.step();
369
- this.state = 128;
370
- this.examplesBlock();
371
- }
372
- }
373
- catch (re) {
374
- if (re instanceof RecognitionException_1.RecognitionException) {
375
- _localctx.exception = re;
376
- this._errHandler.reportError(this, re);
377
- this._errHandler.recover(this, re);
378
- }
379
- else {
380
- throw re;
381
- }
382
- }
383
- finally {
384
- this.exitRule();
385
- }
386
- return _localctx;
387
- }
388
- // @RuleVersion(0)
389
- examplesBlock() {
390
- let _localctx = new ExamplesBlockContext(this._ctx, this.state);
391
- this.enterRule(_localctx, 10, GherkinParser.RULE_examplesBlock);
392
- let _la;
393
- try {
394
- this.enterOuterAlt(_localctx, 1);
395
- {
396
- this.state = 133;
397
- this._errHandler.sync(this);
398
- _la = this._input.LA(1);
399
- while (_la === GherkinParser.NEWLINE) {
400
- {
401
- {
402
- this.state = 130;
403
- this.match(GherkinParser.NEWLINE);
404
- }
405
- }
406
- this.state = 135;
407
- this._errHandler.sync(this);
408
- _la = this._input.LA(1);
409
- }
410
- this.state = 136;
411
- this.match(GherkinParser.EXAMPLES);
412
- this.state = 138;
413
- this._errHandler.sync(this);
414
- _la = this._input.LA(1);
415
- do {
416
- {
417
- {
418
- this.state = 137;
419
- this.match(GherkinParser.NEWLINE);
420
- }
421
- }
422
- this.state = 140;
423
- this._errHandler.sync(this);
424
- _la = this._input.LA(1);
425
- } while (_la === GherkinParser.NEWLINE);
426
- this.state = 142;
427
- this.tableHeader();
428
- this.state = 144;
429
- this._errHandler.sync(this);
430
- _la = this._input.LA(1);
431
- do {
432
- {
433
- {
434
- this.state = 143;
435
- this.tableRow();
436
- }
437
- }
438
- this.state = 146;
439
- this._errHandler.sync(this);
440
- _la = this._input.LA(1);
441
- } while (_la === GherkinParser.PIPE);
442
- }
443
- }
444
- catch (re) {
445
- if (re instanceof RecognitionException_1.RecognitionException) {
446
- _localctx.exception = re;
447
- this._errHandler.reportError(this, re);
448
- this._errHandler.recover(this, re);
449
- }
450
- else {
451
- throw re;
452
- }
453
- }
454
- finally {
455
- this.exitRule();
456
- }
457
- return _localctx;
458
- }
459
- // @RuleVersion(0)
460
- tableHeader() {
461
- let _localctx = new TableHeaderContext(this._ctx, this.state);
462
- this.enterRule(_localctx, 12, GherkinParser.RULE_tableHeader);
463
- try {
464
- this.enterOuterAlt(_localctx, 1);
465
- {
466
- this.state = 148;
467
- this.tableRow();
468
- }
469
- }
470
- catch (re) {
471
- if (re instanceof RecognitionException_1.RecognitionException) {
472
- _localctx.exception = re;
473
- this._errHandler.reportError(this, re);
474
- this._errHandler.recover(this, re);
475
- }
476
- else {
477
- throw re;
478
- }
479
- }
480
- finally {
481
- this.exitRule();
482
- }
483
- return _localctx;
484
- }
485
- // @RuleVersion(0)
486
- tableRow() {
487
- let _localctx = new TableRowContext(this._ctx, this.state);
488
- this.enterRule(_localctx, 14, GherkinParser.RULE_tableRow);
489
- try {
490
- let _alt;
491
- this.enterOuterAlt(_localctx, 1);
492
- {
493
- this.state = 150;
494
- this.match(GherkinParser.PIPE);
495
- this.state = 151;
496
- this.cell();
497
- this.state = 156;
498
- this._errHandler.sync(this);
499
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
500
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
501
- if (_alt === 1) {
502
- {
503
- {
504
- this.state = 152;
505
- this.match(GherkinParser.PIPE);
506
- this.state = 153;
507
- this.cell();
508
- }
509
- }
510
- }
511
- this.state = 158;
512
- this._errHandler.sync(this);
513
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
514
- }
515
- this.state = 159;
516
- this.match(GherkinParser.PIPE);
517
- this.state = 161;
518
- this._errHandler.sync(this);
519
- _alt = 1;
520
- do {
521
- switch (_alt) {
522
- case 1:
523
- {
524
- {
525
- this.state = 160;
526
- this.match(GherkinParser.NEWLINE);
527
- }
528
- }
529
- break;
530
- default:
531
- throw new NoViableAltException_1.NoViableAltException(this);
532
- }
533
- this.state = 163;
534
- this._errHandler.sync(this);
535
- _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
536
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
537
- }
538
- }
539
- catch (re) {
540
- if (re instanceof RecognitionException_1.RecognitionException) {
541
- _localctx.exception = re;
542
- this._errHandler.reportError(this, re);
543
- this._errHandler.recover(this, re);
544
- }
545
- else {
546
- throw re;
547
- }
548
- }
549
- finally {
550
- this.exitRule();
551
- }
552
- return _localctx;
553
- }
554
- // @RuleVersion(0)
555
- cell() {
556
- let _localctx = new CellContext(this._ctx, this.state);
557
- this.enterRule(_localctx, 16, GherkinParser.RULE_cell);
558
- let _la;
559
- try {
560
- this.enterOuterAlt(_localctx, 1);
561
- {
562
- this.state = 166;
563
- this._errHandler.sync(this);
564
- _la = this._input.LA(1);
565
- if (_la === GherkinParser.TEXT_CHARACTER) {
566
- {
567
- this.state = 165;
568
- this.contentText();
569
- }
570
- }
571
- }
572
- }
573
- catch (re) {
574
- if (re instanceof RecognitionException_1.RecognitionException) {
575
- _localctx.exception = re;
576
- this._errHandler.reportError(this, re);
577
- this._errHandler.recover(this, re);
578
- }
579
- else {
580
- throw re;
581
- }
582
- }
583
- finally {
584
- this.exitRule();
585
- }
586
- return _localctx;
587
- }
588
- // @RuleVersion(0)
589
- step() {
590
- let _localctx = new StepContext(this._ctx, this.state);
591
- this.enterRule(_localctx, 18, GherkinParser.RULE_step);
592
- try {
593
- let _alt;
594
- this.enterOuterAlt(_localctx, 1);
595
- {
596
- this.state = 168;
597
- this.givenStep();
598
- this.state = 172;
599
- this._errHandler.sync(this);
600
- _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
601
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
602
- if (_alt === 1) {
603
- {
604
- {
605
- this.state = 169;
606
- this.andGivenStep();
607
- }
608
- }
609
- }
610
- this.state = 174;
611
- this._errHandler.sync(this);
612
- _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
613
- }
614
- this.state = 175;
615
- this.whenStep();
616
- this.state = 179;
617
- this._errHandler.sync(this);
618
- _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
619
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
620
- if (_alt === 1) {
621
- {
622
- {
623
- this.state = 176;
624
- this.andWhenStep();
625
- }
626
- }
627
- }
628
- this.state = 181;
629
- this._errHandler.sync(this);
630
- _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
631
- }
632
- this.state = 182;
633
- this.thenStep();
634
- this.state = 186;
635
- this._errHandler.sync(this);
636
- _alt = this.interpreter.adaptivePredict(this._input, 23, this._ctx);
637
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
638
- if (_alt === 1) {
639
- {
640
- {
641
- this.state = 183;
642
- this.andStep();
643
- }
644
- }
645
- }
646
- this.state = 188;
647
- this._errHandler.sync(this);
648
- _alt = this.interpreter.adaptivePredict(this._input, 23, this._ctx);
649
- }
650
- this.state = 192;
651
- this._errHandler.sync(this);
652
- _alt = this.interpreter.adaptivePredict(this._input, 24, this._ctx);
653
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
654
- if (_alt === 1) {
655
- {
656
- {
657
- this.state = 189;
658
- this.butStep();
659
- }
660
- }
661
- }
662
- this.state = 194;
663
- this._errHandler.sync(this);
664
- _alt = this.interpreter.adaptivePredict(this._input, 24, this._ctx);
665
- }
666
- }
667
- }
668
- catch (re) {
669
- if (re instanceof RecognitionException_1.RecognitionException) {
670
- _localctx.exception = re;
671
- this._errHandler.reportError(this, re);
672
- this._errHandler.recover(this, re);
673
- }
674
- else {
675
- throw re;
676
- }
677
- }
678
- finally {
679
- this.exitRule();
680
- }
681
- return _localctx;
682
- }
683
- // @RuleVersion(0)
684
- givenStep() {
685
- let _localctx = new GivenStepContext(this._ctx, this.state);
686
- this.enterRule(_localctx, 20, GherkinParser.RULE_givenStep);
687
- let _la;
688
- try {
689
- let _alt;
690
- this.enterOuterAlt(_localctx, 1);
691
- {
692
- this.state = 196;
693
- this._errHandler.sync(this);
694
- switch (this.interpreter.adaptivePredict(this._input, 25, this._ctx)) {
695
- case 1:
696
- {
697
- this.state = 195;
698
- this.tags();
699
- }
700
- break;
701
- }
702
- this.state = 201;
703
- this._errHandler.sync(this);
704
- _la = this._input.LA(1);
705
- while (_la === GherkinParser.NEWLINE) {
706
- {
707
- {
708
- this.state = 198;
709
- this.match(GherkinParser.NEWLINE);
710
- }
711
- }
712
- this.state = 203;
713
- this._errHandler.sync(this);
714
- _la = this._input.LA(1);
715
- }
716
- this.state = 204;
717
- this.match(GherkinParser.GIVEN);
718
- this.state = 205;
719
- this.multilineText();
720
- this.state = 220;
721
- this._errHandler.sync(this);
722
- switch (this.interpreter.adaptivePredict(this._input, 30, this._ctx)) {
723
- case 1:
724
- {
725
- this.state = 213;
726
- this._errHandler.sync(this);
727
- switch (this.interpreter.adaptivePredict(this._input, 28, this._ctx)) {
728
- case 1:
729
- {
730
- this.state = 206;
731
- this.match(GherkinParser.NEWLINE);
732
- this.state = 207;
733
- this.docString();
734
- this.state = 209;
735
- this._errHandler.sync(this);
736
- _alt = 1;
737
- do {
738
- switch (_alt) {
739
- case 1:
740
- {
741
- {
742
- this.state = 208;
743
- this.match(GherkinParser.NEWLINE);
744
- }
745
- }
746
- break;
747
- default:
748
- throw new NoViableAltException_1.NoViableAltException(this);
749
- }
750
- this.state = 211;
751
- this._errHandler.sync(this);
752
- _alt = this.interpreter.adaptivePredict(this._input, 27, this._ctx);
753
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
754
- }
755
- break;
756
- }
757
- }
758
- break;
759
- case 2:
760
- {
761
- this.state = 216;
762
- this._errHandler.sync(this);
763
- _alt = 1;
764
- do {
765
- switch (_alt) {
766
- case 1:
767
- {
768
- {
769
- this.state = 215;
770
- this.match(GherkinParser.NEWLINE);
771
- }
772
- }
773
- break;
774
- default:
775
- throw new NoViableAltException_1.NoViableAltException(this);
776
- }
777
- this.state = 218;
778
- this._errHandler.sync(this);
779
- _alt = this.interpreter.adaptivePredict(this._input, 29, this._ctx);
780
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
781
- }
782
- break;
783
- }
784
- }
785
- }
786
- catch (re) {
787
- if (re instanceof RecognitionException_1.RecognitionException) {
788
- _localctx.exception = re;
789
- this._errHandler.reportError(this, re);
790
- this._errHandler.recover(this, re);
791
- }
792
- else {
793
- throw re;
794
- }
795
- }
796
- finally {
797
- this.exitRule();
798
- }
799
- return _localctx;
800
- }
801
- // @RuleVersion(0)
802
- andGivenStep() {
803
- let _localctx = new AndGivenStepContext(this._ctx, this.state);
804
- this.enterRule(_localctx, 22, GherkinParser.RULE_andGivenStep);
805
- let _la;
806
- try {
807
- let _alt;
808
- this.enterOuterAlt(_localctx, 1);
809
- {
810
- this.state = 223;
811
- this._errHandler.sync(this);
812
- switch (this.interpreter.adaptivePredict(this._input, 31, this._ctx)) {
813
- case 1:
814
- {
815
- this.state = 222;
816
- this.tags();
817
- }
818
- break;
819
- }
820
- this.state = 228;
821
- this._errHandler.sync(this);
822
- _la = this._input.LA(1);
823
- while (_la === GherkinParser.NEWLINE) {
824
- {
825
- {
826
- this.state = 225;
827
- this.match(GherkinParser.NEWLINE);
828
- }
829
- }
830
- this.state = 230;
831
- this._errHandler.sync(this);
832
- _la = this._input.LA(1);
833
- }
834
- this.state = 231;
835
- this.match(GherkinParser.AND_GIVEN);
836
- this.state = 232;
837
- this.multilineText();
838
- this.state = 247;
839
- this._errHandler.sync(this);
840
- switch (this.interpreter.adaptivePredict(this._input, 36, this._ctx)) {
841
- case 1:
842
- {
843
- this.state = 240;
844
- this._errHandler.sync(this);
845
- switch (this.interpreter.adaptivePredict(this._input, 34, this._ctx)) {
846
- case 1:
847
- {
848
- this.state = 233;
849
- this.match(GherkinParser.NEWLINE);
850
- this.state = 234;
851
- this.docString();
852
- this.state = 236;
853
- this._errHandler.sync(this);
854
- _alt = 1;
855
- do {
856
- switch (_alt) {
857
- case 1:
858
- {
859
- {
860
- this.state = 235;
861
- this.match(GherkinParser.NEWLINE);
862
- }
863
- }
864
- break;
865
- default:
866
- throw new NoViableAltException_1.NoViableAltException(this);
867
- }
868
- this.state = 238;
869
- this._errHandler.sync(this);
870
- _alt = this.interpreter.adaptivePredict(this._input, 33, this._ctx);
871
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
872
- }
873
- break;
874
- }
875
- }
876
- break;
877
- case 2:
878
- {
879
- this.state = 243;
880
- this._errHandler.sync(this);
881
- _alt = 1;
882
- do {
883
- switch (_alt) {
884
- case 1:
885
- {
886
- {
887
- this.state = 242;
888
- this.match(GherkinParser.NEWLINE);
889
- }
890
- }
891
- break;
892
- default:
893
- throw new NoViableAltException_1.NoViableAltException(this);
894
- }
895
- this.state = 245;
896
- this._errHandler.sync(this);
897
- _alt = this.interpreter.adaptivePredict(this._input, 35, this._ctx);
898
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
899
- }
900
- break;
901
- }
902
- }
903
- }
904
- catch (re) {
905
- if (re instanceof RecognitionException_1.RecognitionException) {
906
- _localctx.exception = re;
907
- this._errHandler.reportError(this, re);
908
- this._errHandler.recover(this, re);
909
- }
910
- else {
911
- throw re;
912
- }
913
- }
914
- finally {
915
- this.exitRule();
916
- }
917
- return _localctx;
918
- }
919
- // @RuleVersion(0)
920
- whenStep() {
921
- let _localctx = new WhenStepContext(this._ctx, this.state);
922
- this.enterRule(_localctx, 24, GherkinParser.RULE_whenStep);
923
- let _la;
924
- try {
925
- let _alt;
926
- this.enterOuterAlt(_localctx, 1);
927
- {
928
- this.state = 250;
929
- this._errHandler.sync(this);
930
- switch (this.interpreter.adaptivePredict(this._input, 37, this._ctx)) {
931
- case 1:
932
- {
933
- this.state = 249;
934
- this.tags();
935
- }
936
- break;
937
- }
938
- this.state = 255;
939
- this._errHandler.sync(this);
940
- _la = this._input.LA(1);
941
- while (_la === GherkinParser.NEWLINE) {
942
- {
943
- {
944
- this.state = 252;
945
- this.match(GherkinParser.NEWLINE);
946
- }
947
- }
948
- this.state = 257;
949
- this._errHandler.sync(this);
950
- _la = this._input.LA(1);
951
- }
952
- this.state = 258;
953
- this.match(GherkinParser.WHEN);
954
- this.state = 259;
955
- this.multilineText();
956
- this.state = 274;
957
- this._errHandler.sync(this);
958
- switch (this.interpreter.adaptivePredict(this._input, 42, this._ctx)) {
959
- case 1:
960
- {
961
- this.state = 267;
962
- this._errHandler.sync(this);
963
- switch (this.interpreter.adaptivePredict(this._input, 40, this._ctx)) {
964
- case 1:
965
- {
966
- this.state = 260;
967
- this.match(GherkinParser.NEWLINE);
968
- this.state = 261;
969
- this.docString();
970
- this.state = 263;
971
- this._errHandler.sync(this);
972
- _alt = 1;
973
- do {
974
- switch (_alt) {
975
- case 1:
976
- {
977
- {
978
- this.state = 262;
979
- this.match(GherkinParser.NEWLINE);
980
- }
981
- }
982
- break;
983
- default:
984
- throw new NoViableAltException_1.NoViableAltException(this);
985
- }
986
- this.state = 265;
987
- this._errHandler.sync(this);
988
- _alt = this.interpreter.adaptivePredict(this._input, 39, this._ctx);
989
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
990
- }
991
- break;
992
- }
993
- }
994
- break;
995
- case 2:
996
- {
997
- this.state = 270;
998
- this._errHandler.sync(this);
999
- _alt = 1;
1000
- do {
1001
- switch (_alt) {
1002
- case 1:
1003
- {
1004
- {
1005
- this.state = 269;
1006
- this.match(GherkinParser.NEWLINE);
1007
- }
1008
- }
1009
- break;
1010
- default:
1011
- throw new NoViableAltException_1.NoViableAltException(this);
1012
- }
1013
- this.state = 272;
1014
- this._errHandler.sync(this);
1015
- _alt = this.interpreter.adaptivePredict(this._input, 41, this._ctx);
1016
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1017
- }
1018
- break;
1019
- }
1020
- }
1021
- }
1022
- catch (re) {
1023
- if (re instanceof RecognitionException_1.RecognitionException) {
1024
- _localctx.exception = re;
1025
- this._errHandler.reportError(this, re);
1026
- this._errHandler.recover(this, re);
1027
- }
1028
- else {
1029
- throw re;
1030
- }
1031
- }
1032
- finally {
1033
- this.exitRule();
1034
- }
1035
- return _localctx;
1036
- }
1037
- // @RuleVersion(0)
1038
- andWhenStep() {
1039
- let _localctx = new AndWhenStepContext(this._ctx, this.state);
1040
- this.enterRule(_localctx, 26, GherkinParser.RULE_andWhenStep);
1041
- let _la;
1042
- try {
1043
- let _alt;
1044
- this.enterOuterAlt(_localctx, 1);
1045
- {
1046
- this.state = 277;
1047
- this._errHandler.sync(this);
1048
- switch (this.interpreter.adaptivePredict(this._input, 43, this._ctx)) {
1049
- case 1:
1050
- {
1051
- this.state = 276;
1052
- this.tags();
1053
- }
1054
- break;
1055
- }
1056
- this.state = 282;
1057
- this._errHandler.sync(this);
1058
- _la = this._input.LA(1);
1059
- while (_la === GherkinParser.NEWLINE) {
1060
- {
1061
- {
1062
- this.state = 279;
1063
- this.match(GherkinParser.NEWLINE);
1064
- }
1065
- }
1066
- this.state = 284;
1067
- this._errHandler.sync(this);
1068
- _la = this._input.LA(1);
1069
- }
1070
- this.state = 285;
1071
- this.match(GherkinParser.AND_WHEN);
1072
- this.state = 286;
1073
- this.multilineText();
1074
- this.state = 301;
1075
- this._errHandler.sync(this);
1076
- switch (this.interpreter.adaptivePredict(this._input, 48, this._ctx)) {
1077
- case 1:
1078
- {
1079
- this.state = 294;
1080
- this._errHandler.sync(this);
1081
- switch (this.interpreter.adaptivePredict(this._input, 46, this._ctx)) {
1082
- case 1:
1083
- {
1084
- this.state = 287;
1085
- this.match(GherkinParser.NEWLINE);
1086
- this.state = 288;
1087
- this.docString();
1088
- this.state = 290;
1089
- this._errHandler.sync(this);
1090
- _alt = 1;
1091
- do {
1092
- switch (_alt) {
1093
- case 1:
1094
- {
1095
- {
1096
- this.state = 289;
1097
- this.match(GherkinParser.NEWLINE);
1098
- }
1099
- }
1100
- break;
1101
- default:
1102
- throw new NoViableAltException_1.NoViableAltException(this);
1103
- }
1104
- this.state = 292;
1105
- this._errHandler.sync(this);
1106
- _alt = this.interpreter.adaptivePredict(this._input, 45, this._ctx);
1107
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1108
- }
1109
- break;
1110
- }
1111
- }
1112
- break;
1113
- case 2:
1114
- {
1115
- this.state = 297;
1116
- this._errHandler.sync(this);
1117
- _alt = 1;
1118
- do {
1119
- switch (_alt) {
1120
- case 1:
1121
- {
1122
- {
1123
- this.state = 296;
1124
- this.match(GherkinParser.NEWLINE);
1125
- }
1126
- }
1127
- break;
1128
- default:
1129
- throw new NoViableAltException_1.NoViableAltException(this);
1130
- }
1131
- this.state = 299;
1132
- this._errHandler.sync(this);
1133
- _alt = this.interpreter.adaptivePredict(this._input, 47, this._ctx);
1134
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1135
- }
1136
- break;
1137
- }
1138
- }
1139
- }
1140
- catch (re) {
1141
- if (re instanceof RecognitionException_1.RecognitionException) {
1142
- _localctx.exception = re;
1143
- this._errHandler.reportError(this, re);
1144
- this._errHandler.recover(this, re);
1145
- }
1146
- else {
1147
- throw re;
1148
- }
1149
- }
1150
- finally {
1151
- this.exitRule();
1152
- }
1153
- return _localctx;
1154
- }
1155
- // @RuleVersion(0)
1156
- thenStep() {
1157
- let _localctx = new ThenStepContext(this._ctx, this.state);
1158
- this.enterRule(_localctx, 28, GherkinParser.RULE_thenStep);
1159
- let _la;
1160
- try {
1161
- let _alt;
1162
- this.enterOuterAlt(_localctx, 1);
1163
- {
1164
- this.state = 304;
1165
- this._errHandler.sync(this);
1166
- switch (this.interpreter.adaptivePredict(this._input, 49, this._ctx)) {
1167
- case 1:
1168
- {
1169
- this.state = 303;
1170
- this.thenTags();
1171
- }
1172
- break;
1173
- }
1174
- this.state = 309;
1175
- this._errHandler.sync(this);
1176
- _la = this._input.LA(1);
1177
- while (_la === GherkinParser.NEWLINE) {
1178
- {
1179
- {
1180
- this.state = 306;
1181
- this.match(GherkinParser.NEWLINE);
1182
- }
1183
- }
1184
- this.state = 311;
1185
- this._errHandler.sync(this);
1186
- _la = this._input.LA(1);
1187
- }
1188
- this.state = 312;
1189
- this.match(GherkinParser.THEN);
1190
- this.state = 313;
1191
- this.multilineText();
1192
- this.state = 328;
1193
- this._errHandler.sync(this);
1194
- switch (this.interpreter.adaptivePredict(this._input, 54, this._ctx)) {
1195
- case 1:
1196
- {
1197
- this.state = 321;
1198
- this._errHandler.sync(this);
1199
- switch (this.interpreter.adaptivePredict(this._input, 52, this._ctx)) {
1200
- case 1:
1201
- {
1202
- this.state = 314;
1203
- this.match(GherkinParser.NEWLINE);
1204
- this.state = 315;
1205
- this.docString();
1206
- this.state = 317;
1207
- this._errHandler.sync(this);
1208
- _alt = 1;
1209
- do {
1210
- switch (_alt) {
1211
- case 1:
1212
- {
1213
- {
1214
- this.state = 316;
1215
- this.match(GherkinParser.NEWLINE);
1216
- }
1217
- }
1218
- break;
1219
- default:
1220
- throw new NoViableAltException_1.NoViableAltException(this);
1221
- }
1222
- this.state = 319;
1223
- this._errHandler.sync(this);
1224
- _alt = this.interpreter.adaptivePredict(this._input, 51, this._ctx);
1225
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1226
- }
1227
- break;
1228
- }
1229
- }
1230
- break;
1231
- case 2:
1232
- {
1233
- this.state = 324;
1234
- this._errHandler.sync(this);
1235
- _alt = 1;
1236
- do {
1237
- switch (_alt) {
1238
- case 1:
1239
- {
1240
- {
1241
- this.state = 323;
1242
- this.match(GherkinParser.NEWLINE);
1243
- }
1244
- }
1245
- break;
1246
- default:
1247
- throw new NoViableAltException_1.NoViableAltException(this);
1248
- }
1249
- this.state = 326;
1250
- this._errHandler.sync(this);
1251
- _alt = this.interpreter.adaptivePredict(this._input, 53, this._ctx);
1252
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1253
- }
1254
- break;
1255
- }
1256
- }
1257
- }
1258
- catch (re) {
1259
- if (re instanceof RecognitionException_1.RecognitionException) {
1260
- _localctx.exception = re;
1261
- this._errHandler.reportError(this, re);
1262
- this._errHandler.recover(this, re);
1263
- }
1264
- else {
1265
- throw re;
1266
- }
1267
- }
1268
- finally {
1269
- this.exitRule();
1270
- }
1271
- return _localctx;
1272
- }
1273
- // @RuleVersion(0)
1274
- andStep() {
1275
- let _localctx = new AndStepContext(this._ctx, this.state);
1276
- this.enterRule(_localctx, 30, GherkinParser.RULE_andStep);
1277
- let _la;
1278
- try {
1279
- let _alt;
1280
- this.enterOuterAlt(_localctx, 1);
1281
- {
1282
- this.state = 331;
1283
- this._errHandler.sync(this);
1284
- switch (this.interpreter.adaptivePredict(this._input, 55, this._ctx)) {
1285
- case 1:
1286
- {
1287
- this.state = 330;
1288
- this.thenTags();
1289
- }
1290
- break;
1291
- }
1292
- this.state = 336;
1293
- this._errHandler.sync(this);
1294
- _la = this._input.LA(1);
1295
- while (_la === GherkinParser.NEWLINE) {
1296
- {
1297
- {
1298
- this.state = 333;
1299
- this.match(GherkinParser.NEWLINE);
1300
- }
1301
- }
1302
- this.state = 338;
1303
- this._errHandler.sync(this);
1304
- _la = this._input.LA(1);
1305
- }
1306
- this.state = 339;
1307
- this.match(GherkinParser.AND);
1308
- this.state = 340;
1309
- this.multilineText();
1310
- this.state = 355;
1311
- this._errHandler.sync(this);
1312
- switch (this.interpreter.adaptivePredict(this._input, 60, this._ctx)) {
1313
- case 1:
1314
- {
1315
- this.state = 348;
1316
- this._errHandler.sync(this);
1317
- switch (this.interpreter.adaptivePredict(this._input, 58, this._ctx)) {
1318
- case 1:
1319
- {
1320
- this.state = 341;
1321
- this.match(GherkinParser.NEWLINE);
1322
- this.state = 342;
1323
- this.docString();
1324
- this.state = 344;
1325
- this._errHandler.sync(this);
1326
- _alt = 1;
1327
- do {
1328
- switch (_alt) {
1329
- case 1:
1330
- {
1331
- {
1332
- this.state = 343;
1333
- this.match(GherkinParser.NEWLINE);
1334
- }
1335
- }
1336
- break;
1337
- default:
1338
- throw new NoViableAltException_1.NoViableAltException(this);
1339
- }
1340
- this.state = 346;
1341
- this._errHandler.sync(this);
1342
- _alt = this.interpreter.adaptivePredict(this._input, 57, this._ctx);
1343
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1344
- }
1345
- break;
1346
- }
1347
- }
1348
- break;
1349
- case 2:
1350
- {
1351
- this.state = 351;
1352
- this._errHandler.sync(this);
1353
- _alt = 1;
1354
- do {
1355
- switch (_alt) {
1356
- case 1:
1357
- {
1358
- {
1359
- this.state = 350;
1360
- this.match(GherkinParser.NEWLINE);
1361
- }
1362
- }
1363
- break;
1364
- default:
1365
- throw new NoViableAltException_1.NoViableAltException(this);
1366
- }
1367
- this.state = 353;
1368
- this._errHandler.sync(this);
1369
- _alt = this.interpreter.adaptivePredict(this._input, 59, this._ctx);
1370
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1371
- }
1372
- break;
1373
- }
1374
- }
1375
- }
1376
- catch (re) {
1377
- if (re instanceof RecognitionException_1.RecognitionException) {
1378
- _localctx.exception = re;
1379
- this._errHandler.reportError(this, re);
1380
- this._errHandler.recover(this, re);
1381
- }
1382
- else {
1383
- throw re;
1384
- }
1385
- }
1386
- finally {
1387
- this.exitRule();
1388
- }
1389
- return _localctx;
1390
- }
1391
- // @RuleVersion(0)
1392
- butStep() {
1393
- let _localctx = new ButStepContext(this._ctx, this.state);
1394
- this.enterRule(_localctx, 32, GherkinParser.RULE_butStep);
1395
- let _la;
1396
- try {
1397
- let _alt;
1398
- this.enterOuterAlt(_localctx, 1);
1399
- {
1400
- this.state = 358;
1401
- this._errHandler.sync(this);
1402
- switch (this.interpreter.adaptivePredict(this._input, 61, this._ctx)) {
1403
- case 1:
1404
- {
1405
- this.state = 357;
1406
- this.thenTags();
1407
- }
1408
- break;
1409
- }
1410
- this.state = 363;
1411
- this._errHandler.sync(this);
1412
- _la = this._input.LA(1);
1413
- while (_la === GherkinParser.NEWLINE) {
1414
- {
1415
- {
1416
- this.state = 360;
1417
- this.match(GherkinParser.NEWLINE);
1418
- }
1419
- }
1420
- this.state = 365;
1421
- this._errHandler.sync(this);
1422
- _la = this._input.LA(1);
1423
- }
1424
- this.state = 366;
1425
- this.match(GherkinParser.BUT);
1426
- this.state = 367;
1427
- this.multilineText();
1428
- this.state = 382;
1429
- this._errHandler.sync(this);
1430
- switch (this.interpreter.adaptivePredict(this._input, 66, this._ctx)) {
1431
- case 1:
1432
- {
1433
- this.state = 375;
1434
- this._errHandler.sync(this);
1435
- switch (this.interpreter.adaptivePredict(this._input, 64, this._ctx)) {
1436
- case 1:
1437
- {
1438
- this.state = 368;
1439
- this.match(GherkinParser.NEWLINE);
1440
- this.state = 369;
1441
- this.docString();
1442
- this.state = 371;
1443
- this._errHandler.sync(this);
1444
- _alt = 1;
1445
- do {
1446
- switch (_alt) {
1447
- case 1:
1448
- {
1449
- {
1450
- this.state = 370;
1451
- this.match(GherkinParser.NEWLINE);
1452
- }
1453
- }
1454
- break;
1455
- default:
1456
- throw new NoViableAltException_1.NoViableAltException(this);
1457
- }
1458
- this.state = 373;
1459
- this._errHandler.sync(this);
1460
- _alt = this.interpreter.adaptivePredict(this._input, 63, this._ctx);
1461
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1462
- }
1463
- break;
1464
- }
1465
- }
1466
- break;
1467
- case 2:
1468
- {
1469
- this.state = 378;
1470
- this._errHandler.sync(this);
1471
- _alt = 1;
1472
- do {
1473
- switch (_alt) {
1474
- case 1:
1475
- {
1476
- {
1477
- this.state = 377;
1478
- this.match(GherkinParser.NEWLINE);
1479
- }
1480
- }
1481
- break;
1482
- default:
1483
- throw new NoViableAltException_1.NoViableAltException(this);
1484
- }
1485
- this.state = 380;
1486
- this._errHandler.sync(this);
1487
- _alt = this.interpreter.adaptivePredict(this._input, 65, this._ctx);
1488
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1489
- }
1490
- break;
1491
- }
1492
- }
1493
- }
1494
- catch (re) {
1495
- if (re instanceof RecognitionException_1.RecognitionException) {
1496
- _localctx.exception = re;
1497
- this._errHandler.reportError(this, re);
1498
- this._errHandler.recover(this, re);
1499
- }
1500
- else {
1501
- throw re;
1502
- }
1503
- }
1504
- finally {
1505
- this.exitRule();
1506
- }
1507
- return _localctx;
1508
- }
1509
- // @RuleVersion(0)
1510
- docString() {
1511
- let _localctx = new DocStringContext(this._ctx, this.state);
1512
- this.enterRule(_localctx, 34, GherkinParser.RULE_docString);
1513
- try {
1514
- this.enterOuterAlt(_localctx, 1);
1515
- {
1516
- this.state = 384;
1517
- this.match(GherkinParser.DOC_STRING);
1518
- }
1519
- }
1520
- catch (re) {
1521
- if (re instanceof RecognitionException_1.RecognitionException) {
1522
- _localctx.exception = re;
1523
- this._errHandler.reportError(this, re);
1524
- this._errHandler.recover(this, re);
1525
- }
1526
- else {
1527
- throw re;
1528
- }
1529
- }
1530
- finally {
1531
- this.exitRule();
1532
- }
1533
- return _localctx;
1534
- }
1535
- // @RuleVersion(0)
1536
- tags() {
1537
- let _localctx = new TagsContext(this._ctx, this.state);
1538
- this.enterRule(_localctx, 36, GherkinParser.RULE_tags);
1539
- let _la;
1540
- try {
1541
- let _alt;
1542
- this.enterOuterAlt(_localctx, 1);
1543
- {
1544
- this.state = 389;
1545
- this._errHandler.sync(this);
1546
- _la = this._input.LA(1);
1547
- while (_la === GherkinParser.NEWLINE) {
1548
- {
1549
- {
1550
- this.state = 386;
1551
- this.match(GherkinParser.NEWLINE);
1552
- }
1553
- }
1554
- this.state = 391;
1555
- this._errHandler.sync(this);
1556
- _la = this._input.LA(1);
1557
- }
1558
- this.state = 399;
1559
- this._errHandler.sync(this);
1560
- _la = this._input.LA(1);
1561
- do {
1562
- {
1563
- {
1564
- this.state = 392;
1565
- _la = this._input.LA(1);
1566
- if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
1567
- this._errHandler.recoverInline(this);
1568
- }
1569
- else {
1570
- if (this._input.LA(1) === Token_1.Token.EOF) {
1571
- this.matchedEOF = true;
1572
- }
1573
- this._errHandler.reportMatch(this);
1574
- this.consume();
1575
- }
1576
- this.state = 396;
1577
- this._errHandler.sync(this);
1578
- _alt = this.interpreter.adaptivePredict(this._input, 68, this._ctx);
1579
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1580
- if (_alt === 1) {
1581
- {
1582
- {
1583
- this.state = 393;
1584
- this.match(GherkinParser.NEWLINE);
1585
- }
1586
- }
1587
- }
1588
- this.state = 398;
1589
- this._errHandler.sync(this);
1590
- _alt = this.interpreter.adaptivePredict(this._input, 68, this._ctx);
1591
- }
1592
- }
1593
- }
1594
- this.state = 401;
1595
- this._errHandler.sync(this);
1596
- _la = this._input.LA(1);
1597
- } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0));
1598
- }
1599
- }
1600
- catch (re) {
1601
- if (re instanceof RecognitionException_1.RecognitionException) {
1602
- _localctx.exception = re;
1603
- this._errHandler.reportError(this, re);
1604
- this._errHandler.recover(this, re);
1605
- }
1606
- else {
1607
- throw re;
1608
- }
1609
- }
1610
- finally {
1611
- this.exitRule();
1612
- }
1613
- return _localctx;
1614
- }
1615
- // @RuleVersion(0)
1616
- thenTags() {
1617
- let _localctx = new ThenTagsContext(this._ctx, this.state);
1618
- this.enterRule(_localctx, 38, GherkinParser.RULE_thenTags);
1619
- let _la;
1620
- try {
1621
- let _alt;
1622
- this.enterOuterAlt(_localctx, 1);
1623
- {
1624
- this.state = 406;
1625
- this._errHandler.sync(this);
1626
- _la = this._input.LA(1);
1627
- while (_la === GherkinParser.NEWLINE) {
1628
- {
1629
- {
1630
- this.state = 403;
1631
- this.match(GherkinParser.NEWLINE);
1632
- }
1633
- }
1634
- this.state = 408;
1635
- this._errHandler.sync(this);
1636
- _la = this._input.LA(1);
1637
- }
1638
- this.state = 416;
1639
- this._errHandler.sync(this);
1640
- _la = this._input.LA(1);
1641
- do {
1642
- {
1643
- {
1644
- this.state = 409;
1645
- _la = this._input.LA(1);
1646
- if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TODO_TAG) | (1 << GherkinParser.FAIL_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
1647
- this._errHandler.recoverInline(this);
1648
- }
1649
- else {
1650
- if (this._input.LA(1) === Token_1.Token.EOF) {
1651
- this.matchedEOF = true;
1652
- }
1653
- this._errHandler.reportMatch(this);
1654
- this.consume();
1655
- }
1656
- this.state = 413;
1657
- this._errHandler.sync(this);
1658
- _alt = this.interpreter.adaptivePredict(this._input, 71, this._ctx);
1659
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1660
- if (_alt === 1) {
1661
- {
1662
- {
1663
- this.state = 410;
1664
- this.match(GherkinParser.NEWLINE);
1665
- }
1666
- }
1667
- }
1668
- this.state = 415;
1669
- this._errHandler.sync(this);
1670
- _alt = this.interpreter.adaptivePredict(this._input, 71, this._ctx);
1671
- }
1672
- }
1673
- }
1674
- this.state = 418;
1675
- this._errHandler.sync(this);
1676
- _la = this._input.LA(1);
1677
- } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TODO_TAG) | (1 << GherkinParser.FAIL_TAG) | (1 << GherkinParser.TAG))) !== 0));
1678
- }
1679
- }
1680
- catch (re) {
1681
- if (re instanceof RecognitionException_1.RecognitionException) {
1682
- _localctx.exception = re;
1683
- this._errHandler.reportError(this, re);
1684
- this._errHandler.recover(this, re);
1685
- }
1686
- else {
1687
- throw re;
1688
- }
1689
- }
1690
- finally {
1691
- this.exitRule();
1692
- }
1693
- return _localctx;
1694
- }
1695
- // @RuleVersion(0)
1696
- contentText() {
1697
- let _localctx = new ContentTextContext(this._ctx, this.state);
1698
- this.enterRule(_localctx, 40, GherkinParser.RULE_contentText);
1699
- let _la;
1700
- try {
1701
- this.enterOuterAlt(_localctx, 1);
1702
- {
1703
- this.state = 421;
1704
- this._errHandler.sync(this);
1705
- _la = this._input.LA(1);
1706
- do {
1707
- {
1708
- {
1709
- this.state = 420;
1710
- this.match(GherkinParser.TEXT_CHARACTER);
1711
- }
1712
- }
1713
- this.state = 423;
1714
- this._errHandler.sync(this);
1715
- _la = this._input.LA(1);
1716
- } while (_la === GherkinParser.TEXT_CHARACTER);
1717
- }
1718
- }
1719
- catch (re) {
1720
- if (re instanceof RecognitionException_1.RecognitionException) {
1721
- _localctx.exception = re;
1722
- this._errHandler.reportError(this, re);
1723
- this._errHandler.recover(this, re);
1724
- }
1725
- else {
1726
- throw re;
1727
- }
1728
- }
1729
- finally {
1730
- this.exitRule();
1731
- }
1732
- return _localctx;
1733
- }
1734
- // @RuleVersion(0)
1735
- multilineText() {
1736
- let _localctx = new MultilineTextContext(this._ctx, this.state);
1737
- this.enterRule(_localctx, 42, GherkinParser.RULE_multilineText);
1738
- let _la;
1739
- try {
1740
- let _alt;
1741
- this.enterOuterAlt(_localctx, 1);
1742
- {
1743
- this.state = 426;
1744
- this._errHandler.sync(this);
1745
- _alt = 1;
1746
- do {
1747
- switch (_alt) {
1748
- case 1:
1749
- {
1750
- {
1751
- this.state = 425;
1752
- _la = this._input.LA(1);
1753
- if (!(_la === GherkinParser.TEXT_CHARACTER || _la === GherkinParser.NEWLINE)) {
1754
- this._errHandler.recoverInline(this);
1755
- }
1756
- else {
1757
- if (this._input.LA(1) === Token_1.Token.EOF) {
1758
- this.matchedEOF = true;
1759
- }
1760
- this._errHandler.reportMatch(this);
1761
- this.consume();
1762
- }
1763
- }
1764
- }
1765
- break;
1766
- default:
1767
- throw new NoViableAltException_1.NoViableAltException(this);
1768
- }
1769
- this.state = 428;
1770
- this._errHandler.sync(this);
1771
- _alt = this.interpreter.adaptivePredict(this._input, 74, this._ctx);
1772
- } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1773
- }
1774
- }
1775
- catch (re) {
1776
- if (re instanceof RecognitionException_1.RecognitionException) {
1777
- _localctx.exception = re;
1778
- this._errHandler.reportError(this, re);
1779
- this._errHandler.recover(this, re);
1780
- }
1781
- else {
1782
- throw re;
1783
- }
1784
- }
1785
- finally {
1786
- this.exitRule();
1787
- }
1788
- return _localctx;
1789
- }
1790
- static get _ATN() {
1791
- if (!GherkinParser.__ATN) {
1792
- GherkinParser.__ATN = new ATNDeserializer_1.ATNDeserializer().deserialize(Utils.toCharArray(GherkinParser._serializedATN));
1793
- }
1794
- return GherkinParser.__ATN;
1795
- }
1796
- }
1797
- exports.GherkinParser = GherkinParser;
1798
- GherkinParser.FEATURE = 1;
1799
- GherkinParser.SCENARIO = 2;
1800
- GherkinParser.SCENARIO_OUTLINE = 3;
1801
- GherkinParser.GIVEN = 4;
1802
- GherkinParser.AND_GIVEN = 5;
1803
- GherkinParser.WHEN = 6;
1804
- GherkinParser.AND_WHEN = 7;
1805
- GherkinParser.THEN = 8;
1806
- GherkinParser.AND = 9;
1807
- GherkinParser.BUT = 10;
1808
- GherkinParser.EXAMPLES = 11;
1809
- GherkinParser.BACKGROUND = 12;
1810
- GherkinParser.PIPE = 13;
1811
- GherkinParser.ONLY_TAG = 14;
1812
- GherkinParser.SKIP_TAG = 15;
1813
- GherkinParser.TODO_TAG = 16;
1814
- GherkinParser.FAIL_TAG = 17;
1815
- GherkinParser.TAG = 18;
1816
- GherkinParser.COMMENT = 19;
1817
- GherkinParser.TEXT_CHARACTER = 20;
1818
- GherkinParser.NEWLINE = 21;
1819
- GherkinParser.WSS = 22;
1820
- GherkinParser.DOC_STRING = 23;
1821
- GherkinParser.RULE_featureFile = 0;
1822
- GherkinParser.RULE_feature = 1;
1823
- GherkinParser.RULE_background = 2;
1824
- GherkinParser.RULE_scenario = 3;
1825
- GherkinParser.RULE_scenarioOutline = 4;
1826
- GherkinParser.RULE_examplesBlock = 5;
1827
- GherkinParser.RULE_tableHeader = 6;
1828
- GherkinParser.RULE_tableRow = 7;
1829
- GherkinParser.RULE_cell = 8;
1830
- GherkinParser.RULE_step = 9;
1831
- GherkinParser.RULE_givenStep = 10;
1832
- GherkinParser.RULE_andGivenStep = 11;
1833
- GherkinParser.RULE_whenStep = 12;
1834
- GherkinParser.RULE_andWhenStep = 13;
1835
- GherkinParser.RULE_thenStep = 14;
1836
- GherkinParser.RULE_andStep = 15;
1837
- GherkinParser.RULE_butStep = 16;
1838
- GherkinParser.RULE_docString = 17;
1839
- GherkinParser.RULE_tags = 18;
1840
- GherkinParser.RULE_thenTags = 19;
1841
- GherkinParser.RULE_contentText = 20;
1842
- GherkinParser.RULE_multilineText = 21;
1843
- // tslint:disable:no-trailing-whitespace
1844
- GherkinParser.ruleNames = [
1845
- "featureFile", "feature", "background", "scenario", "scenarioOutline",
1846
- "examplesBlock", "tableHeader", "tableRow", "cell", "step", "givenStep",
1847
- "andGivenStep", "whenStep", "andWhenStep", "thenStep", "andStep", "butStep",
1848
- "docString", "tags", "thenTags", "contentText", "multilineText",
1849
- ];
1850
- GherkinParser._LITERAL_NAMES = [
1851
- undefined, undefined, undefined, undefined, undefined, undefined, undefined,
1852
- undefined, undefined, undefined, undefined, undefined, undefined, "'|'",
1853
- "'@only'", "'@skip'", "'@todo'", "'@fail'",
1854
- ];
1855
- GherkinParser._SYMBOLIC_NAMES = [
1856
- undefined, "FEATURE", "SCENARIO", "SCENARIO_OUTLINE", "GIVEN", "AND_GIVEN",
1857
- "WHEN", "AND_WHEN", "THEN", "AND", "BUT", "EXAMPLES", "BACKGROUND", "PIPE",
1858
- "ONLY_TAG", "SKIP_TAG", "TODO_TAG", "FAIL_TAG", "TAG", "COMMENT", "TEXT_CHARACTER",
1859
- "NEWLINE", "WSS", "DOC_STRING",
1860
- ];
1861
- GherkinParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(GherkinParser._LITERAL_NAMES, GherkinParser._SYMBOLIC_NAMES, []);
1862
- GherkinParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x19\u01B1\x04" +
1863
- "\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
1864
- "\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" +
1865
- "\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
1866
- "\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
1867
- "\x03\x02\x07\x020\n\x02\f\x02\x0E\x023\v\x02\x03\x02\x07\x026\n\x02\f" +
1868
- "\x02\x0E\x029\v\x02\x03\x02\x03\x02\x03\x03\x05\x03>\n\x03\x03\x03\x07" +
1869
- "\x03A\n\x03\f\x03\x0E\x03D\v\x03\x03\x03\x03\x03\x03\x03\x05\x03I\n\x03" +
1870
- "\x03\x03\x03\x03\x07\x03M\n\x03\f\x03\x0E\x03P\v\x03\x03\x03\x07\x03S" +
1871
- "\n\x03\f\x03\x0E\x03V\v\x03\x03\x04\x05\x04Y\n\x04\x03\x04\x07\x04\\\n" +
1872
- "\x04\f\x04\x0E\x04_\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04e\n\x04" +
1873
- "\f\x04\x0E\x04h\v\x04\x03\x05\x05\x05k\n\x05\x03\x05\x07\x05n\n\x05\f" +
1874
- "\x05\x0E\x05q\v\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x05\x06x\n" +
1875
- "\x06\x03\x06\x07\x06{\n\x06\f\x06\x0E\x06~\v\x06\x03\x06\x03\x06\x03\x06" +
1876
- "\x03\x06\x03\x06\x03\x07\x07\x07\x86\n\x07\f\x07\x0E\x07\x89\v\x07\x03" +
1877
- "\x07\x03\x07\x06\x07\x8D\n\x07\r\x07\x0E\x07\x8E\x03\x07\x03\x07\x06\x07" +
1878
- "\x93\n\x07\r\x07\x0E\x07\x94\x03\b\x03\b\x03\t\x03\t\x03\t\x03\t\x07\t" +
1879
- "\x9D\n\t\f\t\x0E\t\xA0\v\t\x03\t\x03\t\x06\t\xA4\n\t\r\t\x0E\t\xA5\x03" +
1880
- "\n\x05\n\xA9\n\n\x03\v\x03\v\x07\v\xAD\n\v\f\v\x0E\v\xB0\v\v\x03\v\x03" +
1881
- "\v\x07\v\xB4\n\v\f\v\x0E\v\xB7\v\v\x03\v\x03\v\x07\v\xBB\n\v\f\v\x0E\v" +
1882
- "\xBE\v\v\x03\v\x07\v\xC1\n\v\f\v\x0E\v\xC4\v\v\x03\f\x05\f\xC7\n\f\x03" +
1883
- "\f\x07\f\xCA\n\f\f\f\x0E\f\xCD\v\f\x03\f\x03\f\x03\f\x03\f\x03\f\x06\f" +
1884
- "\xD4\n\f\r\f\x0E\f\xD5\x05\f\xD8\n\f\x03\f\x06\f\xDB\n\f\r\f\x0E\f\xDC" +
1885
- "\x05\f\xDF\n\f\x03\r\x05\r\xE2\n\r\x03\r\x07\r\xE5\n\r\f\r\x0E\r\xE8\v" +
1886
- "\r\x03\r\x03\r\x03\r\x03\r\x03\r\x06\r\xEF\n\r\r\r\x0E\r\xF0\x05\r\xF3" +
1887
- "\n\r\x03\r\x06\r\xF6\n\r\r\r\x0E\r\xF7\x05\r\xFA\n\r\x03\x0E\x05\x0E\xFD" +
1888
- "\n\x0E\x03\x0E\x07\x0E\u0100\n\x0E\f\x0E\x0E\x0E\u0103\v\x0E\x03\x0E\x03" +
1889
- "\x0E\x03\x0E\x03\x0E\x03\x0E\x06\x0E\u010A\n\x0E\r\x0E\x0E\x0E\u010B\x05" +
1890
- "\x0E\u010E\n\x0E\x03\x0E\x06\x0E\u0111\n\x0E\r\x0E\x0E\x0E\u0112\x05\x0E" +
1891
- "\u0115\n\x0E\x03\x0F\x05\x0F\u0118\n\x0F\x03\x0F\x07\x0F\u011B\n\x0F\f" +
1892
- "\x0F\x0E\x0F\u011E\v\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x06\x0F" +
1893
- "\u0125\n\x0F\r\x0F\x0E\x0F\u0126\x05\x0F\u0129\n\x0F\x03\x0F\x06\x0F\u012C" +
1894
- "\n\x0F\r\x0F\x0E\x0F\u012D\x05\x0F\u0130\n\x0F\x03\x10\x05\x10\u0133\n" +
1895
- "\x10\x03\x10\x07\x10\u0136\n\x10\f\x10\x0E\x10\u0139\v\x10\x03\x10\x03" +
1896
- "\x10\x03\x10\x03\x10\x03\x10\x06\x10\u0140\n\x10\r\x10\x0E\x10\u0141\x05" +
1897
- "\x10\u0144\n\x10\x03\x10\x06\x10\u0147\n\x10\r\x10\x0E\x10\u0148\x05\x10" +
1898
- "\u014B\n\x10\x03\x11\x05\x11\u014E\n\x11\x03\x11\x07\x11\u0151\n\x11\f" +
1899
- "\x11\x0E\x11\u0154\v\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x06\x11" +
1900
- "\u015B\n\x11\r\x11\x0E\x11\u015C\x05\x11\u015F\n\x11\x03\x11\x06\x11\u0162" +
1901
- "\n\x11\r\x11\x0E\x11\u0163\x05\x11\u0166\n\x11\x03\x12\x05\x12\u0169\n" +
1902
- "\x12\x03\x12\x07\x12\u016C\n\x12\f\x12\x0E\x12\u016F\v\x12\x03\x12\x03" +
1903
- "\x12\x03\x12\x03\x12\x03\x12\x06\x12\u0176\n\x12\r\x12\x0E\x12\u0177\x05" +
1904
- "\x12\u017A\n\x12\x03\x12\x06\x12\u017D\n\x12\r\x12\x0E\x12\u017E\x05\x12" +
1905
- "\u0181\n\x12\x03\x13\x03\x13\x03\x14\x07\x14\u0186\n\x14\f\x14\x0E\x14" +
1906
- "\u0189\v\x14\x03\x14\x03\x14\x07\x14\u018D\n\x14\f\x14\x0E\x14\u0190\v" +
1907
- "\x14\x06\x14\u0192\n\x14\r\x14\x0E\x14\u0193\x03\x15\x07\x15\u0197\n\x15" +
1908
- "\f\x15\x0E\x15\u019A\v\x15\x03\x15\x03\x15\x07\x15\u019E\n\x15\f\x15\x0E" +
1909
- "\x15\u01A1\v\x15\x06\x15\u01A3\n\x15\r\x15\x0E\x15\u01A4\x03\x16\x06\x16" +
1910
- "\u01A8\n\x16\r\x16\x0E\x16\u01A9\x03\x17\x06\x17\u01AD\n\x17\r\x17\x0E" +
1911
- "\x17\u01AE\x03\x17\x02\x02\x02\x18\x02\x02\x04\x02\x06\x02\b\x02\n\x02" +
1912
- "\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02" +
1913
- "\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02\x02\x05\x04\x02\x10\x11\x14" +
1914
- "\x14\x03\x02\x10\x14\x03\x02\x16\x17\x02\u01E5\x021\x03\x02\x02\x02\x04" +
1915
- "=\x03\x02\x02\x02\x06X\x03\x02\x02\x02\bj\x03\x02\x02\x02\nw\x03\x02\x02" +
1916
- "\x02\f\x87\x03\x02\x02\x02\x0E\x96\x03\x02\x02\x02\x10\x98\x03\x02\x02" +
1917
- "\x02\x12\xA8\x03\x02\x02\x02\x14\xAA\x03\x02\x02\x02\x16\xC6\x03\x02\x02" +
1918
- "\x02\x18\xE1\x03\x02\x02\x02\x1A\xFC\x03\x02\x02\x02\x1C\u0117\x03\x02" +
1919
- "\x02\x02\x1E\u0132\x03\x02\x02\x02 \u014D\x03\x02\x02\x02\"\u0168\x03" +
1920
- "\x02\x02\x02$\u0182\x03\x02\x02\x02&\u0187\x03\x02\x02\x02(\u0198\x03" +
1921
- "\x02\x02\x02*\u01A7\x03\x02\x02\x02,\u01AC\x03\x02\x02\x02.0\x05\x04\x03" +
1922
- "\x02/.\x03\x02\x02\x0203\x03\x02\x02\x021/\x03\x02\x02\x0212\x03\x02\x02" +
1923
- "\x0227\x03\x02\x02\x0231\x03\x02\x02\x0246\x07\x17\x02\x0254\x03\x02\x02" +
1924
- "\x0269\x03\x02\x02\x0275\x03\x02\x02\x0278\x03\x02\x02\x028:\x03\x02\x02" +
1925
- "\x0297\x03\x02\x02\x02:;\x07\x02\x02\x03;\x03\x03\x02\x02\x02<>\x05&\x14" +
1926
- "\x02=<\x03\x02\x02\x02=>\x03\x02\x02\x02>B\x03\x02\x02\x02?A\x07\x17\x02" +
1927
- "\x02@?\x03\x02\x02\x02AD\x03\x02\x02\x02B@\x03\x02\x02\x02BC\x03\x02\x02" +
1928
- "\x02CE\x03\x02\x02\x02DB\x03\x02\x02\x02EF\x07\x03\x02\x02FH\x05,\x17" +
1929
- "\x02GI\x05\x06\x04\x02HG\x03\x02\x02\x02HI\x03\x02\x02\x02IN\x03\x02\x02" +
1930
- "\x02JM\x05\b\x05\x02KM\x05\n\x06\x02LJ\x03\x02\x02\x02LK\x03\x02\x02\x02" +
1931
- "MP\x03\x02\x02\x02NL\x03\x02\x02\x02NO\x03\x02\x02\x02OT\x03\x02\x02\x02" +
1932
- "PN\x03\x02\x02\x02QS\x07\x17\x02\x02RQ\x03\x02\x02\x02SV\x03\x02\x02\x02" +
1933
- "TR\x03\x02\x02\x02TU\x03\x02\x02\x02U\x05\x03\x02\x02\x02VT\x03\x02\x02" +
1934
- "\x02WY\x05&\x14\x02XW\x03\x02\x02\x02XY\x03\x02\x02\x02Y]\x03\x02\x02" +
1935
- "\x02Z\\\x07\x17\x02\x02[Z\x03\x02\x02\x02\\_\x03\x02\x02\x02][\x03\x02" +
1936
- "\x02\x02]^\x03\x02\x02\x02^`\x03\x02\x02\x02_]\x03\x02\x02\x02`a\x07\x0E" +
1937
- "\x02\x02ab\x05,\x17\x02bf\x05\x16\f\x02ce\x05\x18\r\x02dc\x03\x02\x02" +
1938
- "\x02eh\x03\x02\x02\x02fd\x03\x02\x02\x02fg\x03\x02\x02\x02g\x07\x03\x02" +
1939
- "\x02\x02hf\x03\x02\x02\x02ik\x05&\x14\x02ji\x03\x02\x02\x02jk\x03\x02" +
1940
- "\x02\x02ko\x03\x02\x02\x02ln\x07\x17\x02\x02ml\x03\x02\x02\x02nq\x03\x02" +
1941
- "\x02\x02om\x03\x02\x02\x02op\x03\x02\x02\x02pr\x03\x02\x02\x02qo\x03\x02" +
1942
- "\x02\x02rs\x07\x04\x02\x02st\x05,\x17\x02tu\x05\x14\v\x02u\t\x03\x02\x02" +
1943
- "\x02vx\x05&\x14\x02wv\x03\x02\x02\x02wx\x03\x02\x02\x02x|\x03\x02\x02" +
1944
- "\x02y{\x07\x17\x02\x02zy\x03\x02\x02\x02{~\x03\x02\x02\x02|z\x03\x02\x02" +
1945
- "\x02|}\x03\x02\x02\x02}\x7F\x03\x02\x02\x02~|\x03\x02\x02\x02\x7F\x80" +
1946
- "\x07\x05\x02\x02\x80\x81\x05,\x17\x02\x81\x82\x05\x14\v\x02\x82\x83\x05" +
1947
- "\f\x07\x02\x83\v\x03\x02\x02\x02\x84\x86\x07\x17\x02\x02\x85\x84\x03\x02" +
1948
- "\x02\x02\x86\x89\x03\x02\x02\x02\x87\x85\x03\x02\x02\x02\x87\x88\x03\x02" +
1949
- "\x02\x02\x88\x8A\x03\x02\x02\x02\x89\x87\x03\x02\x02\x02\x8A\x8C\x07\r" +
1950
- "\x02\x02\x8B\x8D\x07\x17\x02\x02\x8C\x8B\x03\x02\x02\x02\x8D\x8E\x03\x02" +
1951
- "\x02\x02\x8E\x8C\x03\x02\x02\x02\x8E\x8F\x03\x02\x02\x02\x8F\x90\x03\x02" +
1952
- "\x02\x02\x90\x92\x05\x0E\b\x02\x91\x93\x05\x10\t\x02\x92\x91\x03\x02\x02" +
1953
- "\x02\x93\x94\x03\x02\x02\x02\x94\x92\x03\x02\x02\x02\x94\x95\x03\x02\x02" +
1954
- "\x02\x95\r\x03\x02\x02\x02\x96\x97\x05\x10\t\x02\x97\x0F\x03\x02\x02\x02" +
1955
- "\x98\x99\x07\x0F\x02\x02\x99\x9E\x05\x12\n\x02\x9A\x9B\x07\x0F\x02\x02" +
1956
- "\x9B\x9D\x05\x12\n\x02\x9C\x9A\x03\x02\x02\x02\x9D\xA0\x03\x02\x02\x02" +
1957
- "\x9E\x9C\x03\x02\x02\x02\x9E\x9F\x03\x02\x02\x02\x9F\xA1\x03\x02\x02\x02" +
1958
- "\xA0\x9E\x03\x02\x02\x02\xA1\xA3\x07\x0F\x02\x02\xA2\xA4\x07\x17\x02\x02" +
1959
- "\xA3\xA2\x03\x02\x02\x02\xA4\xA5\x03\x02\x02\x02\xA5\xA3\x03\x02\x02\x02" +
1960
- "\xA5\xA6\x03\x02\x02\x02\xA6\x11\x03\x02\x02\x02\xA7\xA9\x05*\x16\x02" +
1961
- "\xA8\xA7\x03\x02\x02\x02\xA8\xA9\x03\x02\x02\x02\xA9\x13\x03\x02\x02\x02" +
1962
- "\xAA\xAE\x05\x16\f\x02\xAB\xAD\x05\x18\r\x02\xAC\xAB\x03\x02\x02\x02\xAD" +
1963
- "\xB0\x03\x02\x02\x02\xAE\xAC\x03\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF" +
1964
- "\xB1\x03\x02\x02\x02\xB0\xAE\x03\x02\x02\x02\xB1\xB5\x05\x1A\x0E\x02\xB2" +
1965
- "\xB4\x05\x1C\x0F\x02\xB3\xB2\x03\x02\x02\x02\xB4\xB7\x03\x02\x02\x02\xB5" +
1966
- "\xB3\x03\x02\x02\x02\xB5\xB6\x03\x02\x02\x02\xB6\xB8\x03\x02\x02\x02\xB7" +
1967
- "\xB5\x03\x02\x02\x02\xB8\xBC\x05\x1E\x10\x02\xB9\xBB\x05 \x11\x02\xBA" +
1968
- "\xB9\x03\x02\x02\x02\xBB\xBE\x03\x02\x02\x02\xBC\xBA\x03\x02\x02\x02\xBC" +
1969
- "\xBD\x03\x02\x02\x02\xBD\xC2\x03\x02\x02\x02\xBE\xBC\x03\x02\x02\x02\xBF" +
1970
- "\xC1\x05\"\x12\x02\xC0\xBF\x03\x02\x02\x02\xC1\xC4\x03\x02\x02\x02\xC2" +
1971
- "\xC0\x03\x02\x02\x02\xC2\xC3\x03\x02\x02\x02\xC3\x15\x03\x02\x02\x02\xC4" +
1972
- "\xC2\x03\x02\x02\x02\xC5\xC7\x05&\x14\x02\xC6\xC5\x03\x02\x02\x02\xC6" +
1973
- "\xC7\x03\x02\x02\x02\xC7\xCB\x03\x02\x02\x02\xC8\xCA\x07\x17\x02\x02\xC9" +
1974
- "\xC8\x03\x02\x02\x02\xCA\xCD\x03\x02\x02\x02\xCB\xC9\x03\x02\x02\x02\xCB" +
1975
- "\xCC\x03\x02\x02\x02\xCC\xCE\x03\x02\x02\x02\xCD\xCB\x03\x02\x02\x02\xCE" +
1976
- "\xCF\x07\x06\x02\x02\xCF\xDE\x05,\x17\x02\xD0\xD1\x07\x17\x02\x02\xD1" +
1977
- "\xD3\x05$\x13\x02\xD2\xD4\x07\x17\x02\x02\xD3\xD2\x03\x02\x02\x02\xD4" +
1978
- "\xD5\x03\x02\x02\x02\xD5\xD3\x03\x02\x02\x02\xD5\xD6\x03\x02\x02\x02\xD6" +
1979
- "\xD8\x03\x02\x02\x02\xD7\xD0\x03\x02\x02\x02\xD7\xD8\x03\x02\x02\x02\xD8" +
1980
- "\xDF\x03\x02\x02\x02\xD9\xDB\x07\x17\x02\x02\xDA\xD9\x03\x02\x02\x02\xDB" +
1981
- "\xDC\x03\x02\x02\x02\xDC\xDA\x03\x02\x02\x02\xDC\xDD\x03\x02\x02\x02\xDD" +
1982
- "\xDF\x03\x02\x02\x02\xDE\xD7\x03\x02\x02\x02\xDE\xDA\x03\x02\x02\x02\xDF" +
1983
- "\x17\x03\x02\x02\x02\xE0\xE2\x05&\x14\x02\xE1\xE0\x03\x02\x02\x02\xE1" +
1984
- "\xE2\x03\x02\x02\x02\xE2\xE6\x03\x02\x02\x02\xE3\xE5\x07\x17\x02\x02\xE4" +
1985
- "\xE3\x03\x02\x02\x02\xE5\xE8\x03\x02\x02\x02\xE6\xE4\x03\x02\x02\x02\xE6" +
1986
- "\xE7\x03\x02\x02\x02\xE7\xE9\x03\x02\x02\x02\xE8\xE6\x03\x02\x02\x02\xE9" +
1987
- "\xEA\x07\x07\x02\x02\xEA\xF9\x05,\x17\x02\xEB\xEC\x07\x17\x02\x02\xEC" +
1988
- "\xEE\x05$\x13\x02\xED\xEF\x07\x17\x02\x02\xEE\xED\x03\x02\x02\x02\xEF" +
1989
- "\xF0\x03\x02\x02\x02\xF0\xEE\x03\x02\x02\x02\xF0\xF1\x03\x02\x02\x02\xF1" +
1990
- "\xF3\x03\x02\x02\x02\xF2\xEB\x03\x02\x02\x02\xF2\xF3\x03\x02\x02\x02\xF3" +
1991
- "\xFA\x03\x02\x02\x02\xF4\xF6\x07\x17\x02\x02\xF5\xF4\x03\x02\x02\x02\xF6" +
1992
- "\xF7\x03\x02\x02\x02\xF7\xF5\x03\x02\x02\x02\xF7\xF8\x03\x02\x02\x02\xF8" +
1993
- "\xFA\x03\x02\x02\x02\xF9\xF2\x03\x02\x02\x02\xF9\xF5\x03\x02\x02\x02\xFA" +
1994
- "\x19\x03\x02\x02\x02\xFB\xFD\x05&\x14\x02\xFC\xFB\x03\x02\x02\x02\xFC" +
1995
- "\xFD\x03\x02\x02\x02\xFD\u0101\x03\x02\x02\x02\xFE\u0100\x07\x17\x02\x02" +
1996
- "\xFF\xFE\x03\x02\x02\x02\u0100\u0103\x03\x02\x02\x02\u0101\xFF\x03\x02" +
1997
- "\x02\x02\u0101\u0102\x03\x02\x02\x02\u0102\u0104\x03\x02\x02\x02\u0103" +
1998
- "\u0101\x03\x02\x02\x02\u0104\u0105\x07\b\x02\x02\u0105\u0114\x05,\x17" +
1999
- "\x02\u0106\u0107\x07\x17\x02\x02\u0107\u0109\x05$\x13\x02\u0108\u010A" +
2000
- "\x07\x17\x02\x02\u0109\u0108\x03\x02\x02\x02\u010A\u010B\x03\x02\x02\x02" +
2001
- "\u010B\u0109\x03\x02\x02\x02\u010B\u010C\x03\x02\x02\x02\u010C\u010E\x03" +
2002
- "\x02\x02\x02\u010D\u0106\x03\x02\x02\x02\u010D\u010E\x03\x02\x02\x02\u010E" +
2003
- "\u0115\x03\x02\x02\x02\u010F\u0111\x07\x17\x02\x02\u0110\u010F\x03\x02" +
2004
- "\x02\x02\u0111\u0112\x03\x02\x02\x02\u0112\u0110\x03\x02\x02\x02\u0112" +
2005
- "\u0113\x03\x02\x02\x02\u0113\u0115\x03\x02\x02\x02\u0114\u010D\x03\x02" +
2006
- "\x02\x02\u0114\u0110\x03\x02\x02\x02\u0115\x1B\x03\x02\x02\x02\u0116\u0118" +
2007
- "\x05&\x14\x02\u0117\u0116\x03\x02\x02\x02\u0117\u0118\x03\x02\x02\x02" +
2008
- "\u0118\u011C\x03\x02\x02\x02\u0119\u011B\x07\x17\x02\x02\u011A\u0119\x03" +
2009
- "\x02\x02\x02\u011B\u011E\x03\x02\x02\x02\u011C\u011A\x03\x02\x02\x02\u011C" +
2010
- "\u011D\x03\x02\x02\x02\u011D\u011F\x03\x02\x02\x02\u011E\u011C\x03\x02" +
2011
- "\x02\x02\u011F\u0120\x07\t\x02\x02\u0120\u012F\x05,\x17\x02\u0121\u0122" +
2012
- "\x07\x17\x02\x02\u0122\u0124\x05$\x13\x02\u0123\u0125\x07\x17\x02\x02" +
2013
- "\u0124\u0123\x03\x02\x02\x02\u0125\u0126\x03\x02\x02\x02\u0126\u0124\x03" +
2014
- "\x02\x02\x02\u0126\u0127\x03\x02\x02\x02\u0127\u0129\x03\x02\x02\x02\u0128" +
2015
- "\u0121\x03\x02\x02\x02\u0128\u0129\x03\x02\x02\x02\u0129\u0130\x03\x02" +
2016
- "\x02\x02\u012A\u012C\x07\x17\x02\x02\u012B\u012A\x03\x02\x02\x02\u012C" +
2017
- "\u012D\x03\x02\x02\x02\u012D\u012B\x03\x02\x02\x02\u012D\u012E\x03\x02" +
2018
- "\x02\x02\u012E\u0130\x03\x02\x02\x02\u012F\u0128\x03\x02\x02\x02\u012F" +
2019
- "\u012B\x03\x02\x02\x02\u0130\x1D\x03\x02\x02\x02\u0131\u0133\x05(\x15" +
2020
- "\x02\u0132\u0131\x03\x02\x02\x02\u0132\u0133\x03\x02\x02\x02\u0133\u0137" +
2021
- "\x03\x02\x02\x02\u0134\u0136\x07\x17\x02\x02\u0135\u0134\x03\x02\x02\x02" +
2022
- "\u0136\u0139\x03\x02\x02\x02\u0137\u0135\x03\x02\x02\x02\u0137\u0138\x03" +
2023
- "\x02\x02\x02\u0138\u013A\x03\x02\x02\x02\u0139\u0137\x03\x02\x02\x02\u013A" +
2024
- "\u013B\x07\n\x02\x02\u013B\u014A\x05,\x17\x02\u013C\u013D\x07\x17\x02" +
2025
- "\x02\u013D\u013F\x05$\x13\x02\u013E\u0140\x07\x17\x02\x02\u013F\u013E" +
2026
- "\x03\x02\x02\x02\u0140\u0141\x03\x02\x02\x02\u0141\u013F\x03\x02\x02\x02" +
2027
- "\u0141\u0142\x03\x02\x02\x02\u0142\u0144\x03\x02\x02\x02\u0143\u013C\x03" +
2028
- "\x02\x02\x02\u0143\u0144\x03\x02\x02\x02\u0144\u014B\x03\x02\x02\x02\u0145" +
2029
- "\u0147\x07\x17\x02\x02\u0146\u0145\x03\x02\x02\x02\u0147\u0148\x03\x02" +
2030
- "\x02\x02\u0148\u0146\x03\x02\x02\x02\u0148\u0149\x03\x02\x02\x02\u0149" +
2031
- "\u014B\x03\x02\x02\x02\u014A\u0143\x03\x02\x02\x02\u014A\u0146\x03\x02" +
2032
- "\x02\x02\u014B\x1F\x03\x02\x02\x02\u014C\u014E\x05(\x15\x02\u014D\u014C" +
2033
- "\x03\x02\x02\x02\u014D\u014E\x03\x02\x02\x02\u014E\u0152\x03\x02\x02\x02" +
2034
- "\u014F\u0151\x07\x17\x02\x02\u0150\u014F\x03\x02\x02\x02\u0151\u0154\x03" +
2035
- "\x02\x02\x02\u0152\u0150\x03\x02\x02\x02\u0152\u0153\x03\x02\x02\x02\u0153" +
2036
- "\u0155\x03\x02\x02\x02\u0154\u0152\x03\x02\x02\x02\u0155\u0156\x07\v\x02" +
2037
- "\x02\u0156\u0165\x05,\x17\x02\u0157\u0158\x07\x17\x02\x02\u0158\u015A" +
2038
- "\x05$\x13\x02\u0159\u015B\x07\x17\x02\x02\u015A\u0159\x03\x02\x02\x02" +
2039
- "\u015B\u015C\x03\x02\x02\x02\u015C\u015A\x03\x02\x02\x02\u015C\u015D\x03" +
2040
- "\x02\x02\x02\u015D\u015F\x03\x02\x02\x02\u015E\u0157\x03\x02\x02\x02\u015E" +
2041
- "\u015F\x03\x02\x02\x02\u015F\u0166\x03\x02\x02\x02\u0160\u0162\x07\x17" +
2042
- "\x02\x02\u0161\u0160\x03\x02\x02\x02\u0162\u0163\x03\x02\x02\x02\u0163" +
2043
- "\u0161\x03\x02\x02\x02\u0163\u0164\x03\x02\x02\x02\u0164\u0166\x03\x02" +
2044
- "\x02\x02\u0165\u015E\x03\x02\x02\x02\u0165\u0161\x03\x02\x02\x02\u0166" +
2045
- "!\x03\x02\x02\x02\u0167\u0169\x05(\x15\x02\u0168\u0167\x03\x02\x02\x02" +
2046
- "\u0168\u0169\x03\x02\x02\x02\u0169\u016D\x03\x02\x02\x02\u016A\u016C\x07" +
2047
- "\x17\x02\x02\u016B\u016A\x03\x02\x02\x02\u016C\u016F\x03\x02\x02\x02\u016D" +
2048
- "\u016B\x03\x02\x02\x02\u016D\u016E\x03\x02\x02\x02\u016E\u0170\x03\x02" +
2049
- "\x02\x02\u016F\u016D\x03\x02\x02\x02\u0170\u0171\x07\f\x02\x02\u0171\u0180" +
2050
- "\x05,\x17\x02\u0172\u0173\x07\x17\x02\x02\u0173\u0175\x05$\x13\x02\u0174" +
2051
- "\u0176\x07\x17\x02\x02\u0175\u0174\x03\x02\x02\x02\u0176\u0177\x03\x02" +
2052
- "\x02\x02\u0177\u0175\x03\x02\x02\x02\u0177\u0178\x03\x02\x02\x02\u0178" +
2053
- "\u017A\x03\x02\x02\x02\u0179\u0172\x03\x02\x02\x02\u0179\u017A\x03\x02" +
2054
- "\x02\x02\u017A\u0181\x03\x02\x02\x02\u017B\u017D\x07\x17\x02\x02\u017C" +
2055
- "\u017B\x03\x02\x02\x02\u017D\u017E\x03\x02\x02\x02\u017E\u017C\x03\x02" +
2056
- "\x02\x02\u017E\u017F\x03\x02\x02\x02\u017F\u0181\x03\x02\x02\x02\u0180" +
2057
- "\u0179\x03\x02\x02\x02\u0180\u017C\x03\x02\x02\x02\u0181#\x03\x02\x02" +
2058
- "\x02\u0182\u0183\x07\x19\x02\x02\u0183%\x03\x02\x02\x02\u0184\u0186\x07" +
2059
- "\x17\x02\x02\u0185\u0184\x03\x02\x02\x02\u0186\u0189\x03\x02\x02\x02\u0187" +
2060
- "\u0185\x03\x02\x02\x02\u0187\u0188\x03\x02\x02\x02\u0188\u0191\x03\x02" +
2061
- "\x02\x02\u0189\u0187\x03\x02\x02\x02\u018A\u018E\t\x02\x02\x02\u018B\u018D" +
2062
- "\x07\x17\x02\x02\u018C\u018B\x03\x02\x02\x02\u018D\u0190\x03\x02\x02\x02" +
2063
- "\u018E\u018C\x03\x02\x02\x02\u018E\u018F\x03\x02\x02\x02\u018F\u0192\x03" +
2064
- "\x02\x02\x02\u0190\u018E\x03\x02\x02\x02\u0191\u018A\x03\x02\x02\x02\u0192" +
2065
- "\u0193\x03\x02\x02\x02\u0193\u0191\x03\x02\x02\x02\u0193\u0194\x03\x02" +
2066
- "\x02\x02\u0194\'\x03\x02\x02\x02\u0195\u0197\x07\x17\x02\x02\u0196\u0195" +
2067
- "\x03\x02\x02\x02\u0197\u019A\x03\x02\x02\x02\u0198\u0196\x03\x02\x02\x02" +
2068
- "\u0198\u0199\x03\x02\x02\x02\u0199\u01A2\x03\x02\x02\x02\u019A\u0198\x03" +
2069
- "\x02\x02\x02\u019B\u019F\t\x03\x02\x02\u019C\u019E\x07\x17\x02\x02\u019D" +
2070
- "\u019C\x03\x02\x02\x02\u019E\u01A1\x03\x02\x02\x02\u019F\u019D\x03\x02" +
2071
- "\x02\x02\u019F\u01A0\x03\x02\x02\x02\u01A0\u01A3\x03\x02\x02\x02\u01A1" +
2072
- "\u019F\x03\x02\x02\x02\u01A2\u019B\x03\x02\x02\x02\u01A3\u01A4\x03\x02" +
2073
- "\x02\x02\u01A4\u01A2\x03\x02\x02\x02\u01A4\u01A5\x03\x02\x02\x02\u01A5" +
2074
- ")\x03\x02\x02\x02\u01A6\u01A8\x07\x16\x02\x02\u01A7\u01A6\x03\x02\x02" +
2075
- "\x02\u01A8\u01A9\x03\x02\x02\x02\u01A9\u01A7\x03\x02\x02\x02\u01A9\u01AA" +
2076
- "\x03\x02\x02\x02\u01AA+\x03\x02\x02\x02\u01AB\u01AD\t\x04\x02\x02\u01AC" +
2077
- "\u01AB\x03\x02\x02\x02\u01AD\u01AE\x03\x02\x02\x02\u01AE\u01AC\x03\x02" +
2078
- "\x02\x02\u01AE\u01AF\x03\x02\x02\x02\u01AF-\x03\x02\x02\x02M17=BHLNTX" +
2079
- "]fjow|\x87\x8E\x94\x9E\xA5\xA8\xAE\xB5\xBC\xC2\xC6\xCB\xD5\xD7\xDC\xDE" +
2080
- "\xE1\xE6\xF0\xF2\xF7\xF9\xFC\u0101\u010B\u010D\u0112\u0114\u0117\u011C" +
2081
- "\u0126\u0128\u012D\u012F\u0132\u0137\u0141\u0143\u0148\u014A\u014D\u0152" +
2082
- "\u015C\u015E\u0163\u0165\u0168\u016D\u0177\u0179\u017E\u0180\u0187\u018E" +
2083
- "\u0193\u0198\u019F\u01A4\u01A9\u01AE";
2084
- class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
2085
- EOF() { return this.getToken(GherkinParser.EOF, 0); }
2086
- feature(i) {
2087
- if (i === undefined) {
2088
- return this.getRuleContexts(FeatureContext);
2089
- }
2090
- else {
2091
- return this.getRuleContext(i, FeatureContext);
2092
- }
2093
- }
2094
- NEWLINE(i) {
2095
- if (i === undefined) {
2096
- return this.getTokens(GherkinParser.NEWLINE);
2097
- }
2098
- else {
2099
- return this.getToken(GherkinParser.NEWLINE, i);
2100
- }
2101
- }
2102
- constructor(parent, invokingState) {
2103
- super(parent, invokingState);
2104
- }
2105
- // @Override
2106
- get ruleIndex() { return GherkinParser.RULE_featureFile; }
2107
- // @Override
2108
- accept(visitor) {
2109
- if (visitor.visitFeatureFile) {
2110
- return visitor.visitFeatureFile(this);
2111
- }
2112
- else {
2113
- return visitor.visitChildren(this);
2114
- }
2115
- }
2116
- }
2117
- exports.FeatureFileContext = FeatureFileContext;
2118
- class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
2119
- FEATURE() { return this.getToken(GherkinParser.FEATURE, 0); }
2120
- multilineText() {
2121
- return this.getRuleContext(0, MultilineTextContext);
2122
- }
2123
- tags() {
2124
- return this.tryGetRuleContext(0, TagsContext);
2125
- }
2126
- NEWLINE(i) {
2127
- if (i === undefined) {
2128
- return this.getTokens(GherkinParser.NEWLINE);
2129
- }
2130
- else {
2131
- return this.getToken(GherkinParser.NEWLINE, i);
2132
- }
2133
- }
2134
- background() {
2135
- return this.tryGetRuleContext(0, BackgroundContext);
2136
- }
2137
- scenario(i) {
2138
- if (i === undefined) {
2139
- return this.getRuleContexts(ScenarioContext);
2140
- }
2141
- else {
2142
- return this.getRuleContext(i, ScenarioContext);
2143
- }
2144
- }
2145
- scenarioOutline(i) {
2146
- if (i === undefined) {
2147
- return this.getRuleContexts(ScenarioOutlineContext);
2148
- }
2149
- else {
2150
- return this.getRuleContext(i, ScenarioOutlineContext);
2151
- }
2152
- }
2153
- constructor(parent, invokingState) {
2154
- super(parent, invokingState);
2155
- }
2156
- // @Override
2157
- get ruleIndex() { return GherkinParser.RULE_feature; }
2158
- // @Override
2159
- accept(visitor) {
2160
- if (visitor.visitFeature) {
2161
- return visitor.visitFeature(this);
2162
- }
2163
- else {
2164
- return visitor.visitChildren(this);
2165
- }
2166
- }
2167
- }
2168
- exports.FeatureContext = FeatureContext;
2169
- class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
2170
- BACKGROUND() { return this.getToken(GherkinParser.BACKGROUND, 0); }
2171
- multilineText() {
2172
- return this.getRuleContext(0, MultilineTextContext);
2173
- }
2174
- givenStep() {
2175
- return this.getRuleContext(0, GivenStepContext);
2176
- }
2177
- tags() {
2178
- return this.tryGetRuleContext(0, TagsContext);
2179
- }
2180
- NEWLINE(i) {
2181
- if (i === undefined) {
2182
- return this.getTokens(GherkinParser.NEWLINE);
2183
- }
2184
- else {
2185
- return this.getToken(GherkinParser.NEWLINE, i);
2186
- }
2187
- }
2188
- andGivenStep(i) {
2189
- if (i === undefined) {
2190
- return this.getRuleContexts(AndGivenStepContext);
2191
- }
2192
- else {
2193
- return this.getRuleContext(i, AndGivenStepContext);
2194
- }
2195
- }
2196
- constructor(parent, invokingState) {
2197
- super(parent, invokingState);
2198
- }
2199
- // @Override
2200
- get ruleIndex() { return GherkinParser.RULE_background; }
2201
- // @Override
2202
- accept(visitor) {
2203
- if (visitor.visitBackground) {
2204
- return visitor.visitBackground(this);
2205
- }
2206
- else {
2207
- return visitor.visitChildren(this);
2208
- }
2209
- }
2210
- }
2211
- exports.BackgroundContext = BackgroundContext;
2212
- class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
2213
- SCENARIO() { return this.getToken(GherkinParser.SCENARIO, 0); }
2214
- multilineText() {
2215
- return this.getRuleContext(0, MultilineTextContext);
2216
- }
2217
- step() {
2218
- return this.getRuleContext(0, StepContext);
2219
- }
2220
- tags() {
2221
- return this.tryGetRuleContext(0, TagsContext);
2222
- }
2223
- NEWLINE(i) {
2224
- if (i === undefined) {
2225
- return this.getTokens(GherkinParser.NEWLINE);
2226
- }
2227
- else {
2228
- return this.getToken(GherkinParser.NEWLINE, i);
2229
- }
2230
- }
2231
- constructor(parent, invokingState) {
2232
- super(parent, invokingState);
2233
- }
2234
- // @Override
2235
- get ruleIndex() { return GherkinParser.RULE_scenario; }
2236
- // @Override
2237
- accept(visitor) {
2238
- if (visitor.visitScenario) {
2239
- return visitor.visitScenario(this);
2240
- }
2241
- else {
2242
- return visitor.visitChildren(this);
2243
- }
2244
- }
2245
- }
2246
- exports.ScenarioContext = ScenarioContext;
2247
- class ScenarioOutlineContext extends ParserRuleContext_1.ParserRuleContext {
2248
- SCENARIO_OUTLINE() { return this.getToken(GherkinParser.SCENARIO_OUTLINE, 0); }
2249
- multilineText() {
2250
- return this.getRuleContext(0, MultilineTextContext);
2251
- }
2252
- step() {
2253
- return this.getRuleContext(0, StepContext);
2254
- }
2255
- examplesBlock() {
2256
- return this.getRuleContext(0, ExamplesBlockContext);
2257
- }
2258
- tags() {
2259
- return this.tryGetRuleContext(0, TagsContext);
2260
- }
2261
- NEWLINE(i) {
2262
- if (i === undefined) {
2263
- return this.getTokens(GherkinParser.NEWLINE);
2264
- }
2265
- else {
2266
- return this.getToken(GherkinParser.NEWLINE, i);
2267
- }
2268
- }
2269
- constructor(parent, invokingState) {
2270
- super(parent, invokingState);
2271
- }
2272
- // @Override
2273
- get ruleIndex() { return GherkinParser.RULE_scenarioOutline; }
2274
- // @Override
2275
- accept(visitor) {
2276
- if (visitor.visitScenarioOutline) {
2277
- return visitor.visitScenarioOutline(this);
2278
- }
2279
- else {
2280
- return visitor.visitChildren(this);
2281
- }
2282
- }
2283
- }
2284
- exports.ScenarioOutlineContext = ScenarioOutlineContext;
2285
- class ExamplesBlockContext extends ParserRuleContext_1.ParserRuleContext {
2286
- EXAMPLES() { return this.getToken(GherkinParser.EXAMPLES, 0); }
2287
- tableHeader() {
2288
- return this.getRuleContext(0, TableHeaderContext);
2289
- }
2290
- NEWLINE(i) {
2291
- if (i === undefined) {
2292
- return this.getTokens(GherkinParser.NEWLINE);
2293
- }
2294
- else {
2295
- return this.getToken(GherkinParser.NEWLINE, i);
2296
- }
2297
- }
2298
- tableRow(i) {
2299
- if (i === undefined) {
2300
- return this.getRuleContexts(TableRowContext);
2301
- }
2302
- else {
2303
- return this.getRuleContext(i, TableRowContext);
2304
- }
2305
- }
2306
- constructor(parent, invokingState) {
2307
- super(parent, invokingState);
2308
- }
2309
- // @Override
2310
- get ruleIndex() { return GherkinParser.RULE_examplesBlock; }
2311
- // @Override
2312
- accept(visitor) {
2313
- if (visitor.visitExamplesBlock) {
2314
- return visitor.visitExamplesBlock(this);
2315
- }
2316
- else {
2317
- return visitor.visitChildren(this);
2318
- }
2319
- }
2320
- }
2321
- exports.ExamplesBlockContext = ExamplesBlockContext;
2322
- class TableHeaderContext extends ParserRuleContext_1.ParserRuleContext {
2323
- tableRow() {
2324
- return this.getRuleContext(0, TableRowContext);
2325
- }
2326
- constructor(parent, invokingState) {
2327
- super(parent, invokingState);
2328
- }
2329
- // @Override
2330
- get ruleIndex() { return GherkinParser.RULE_tableHeader; }
2331
- // @Override
2332
- accept(visitor) {
2333
- if (visitor.visitTableHeader) {
2334
- return visitor.visitTableHeader(this);
2335
- }
2336
- else {
2337
- return visitor.visitChildren(this);
2338
- }
2339
- }
2340
- }
2341
- exports.TableHeaderContext = TableHeaderContext;
2342
- class TableRowContext extends ParserRuleContext_1.ParserRuleContext {
2343
- PIPE(i) {
2344
- if (i === undefined) {
2345
- return this.getTokens(GherkinParser.PIPE);
2346
- }
2347
- else {
2348
- return this.getToken(GherkinParser.PIPE, i);
2349
- }
2350
- }
2351
- cell(i) {
2352
- if (i === undefined) {
2353
- return this.getRuleContexts(CellContext);
2354
- }
2355
- else {
2356
- return this.getRuleContext(i, CellContext);
2357
- }
2358
- }
2359
- NEWLINE(i) {
2360
- if (i === undefined) {
2361
- return this.getTokens(GherkinParser.NEWLINE);
2362
- }
2363
- else {
2364
- return this.getToken(GherkinParser.NEWLINE, i);
2365
- }
2366
- }
2367
- constructor(parent, invokingState) {
2368
- super(parent, invokingState);
2369
- }
2370
- // @Override
2371
- get ruleIndex() { return GherkinParser.RULE_tableRow; }
2372
- // @Override
2373
- accept(visitor) {
2374
- if (visitor.visitTableRow) {
2375
- return visitor.visitTableRow(this);
2376
- }
2377
- else {
2378
- return visitor.visitChildren(this);
2379
- }
2380
- }
2381
- }
2382
- exports.TableRowContext = TableRowContext;
2383
- class CellContext extends ParserRuleContext_1.ParserRuleContext {
2384
- contentText() {
2385
- return this.tryGetRuleContext(0, ContentTextContext);
2386
- }
2387
- constructor(parent, invokingState) {
2388
- super(parent, invokingState);
2389
- }
2390
- // @Override
2391
- get ruleIndex() { return GherkinParser.RULE_cell; }
2392
- // @Override
2393
- accept(visitor) {
2394
- if (visitor.visitCell) {
2395
- return visitor.visitCell(this);
2396
- }
2397
- else {
2398
- return visitor.visitChildren(this);
2399
- }
2400
- }
2401
- }
2402
- exports.CellContext = CellContext;
2403
- class StepContext extends ParserRuleContext_1.ParserRuleContext {
2404
- givenStep() {
2405
- return this.getRuleContext(0, GivenStepContext);
2406
- }
2407
- whenStep() {
2408
- return this.getRuleContext(0, WhenStepContext);
2409
- }
2410
- thenStep() {
2411
- return this.getRuleContext(0, ThenStepContext);
2412
- }
2413
- andGivenStep(i) {
2414
- if (i === undefined) {
2415
- return this.getRuleContexts(AndGivenStepContext);
2416
- }
2417
- else {
2418
- return this.getRuleContext(i, AndGivenStepContext);
2419
- }
2420
- }
2421
- andWhenStep(i) {
2422
- if (i === undefined) {
2423
- return this.getRuleContexts(AndWhenStepContext);
2424
- }
2425
- else {
2426
- return this.getRuleContext(i, AndWhenStepContext);
2427
- }
2428
- }
2429
- andStep(i) {
2430
- if (i === undefined) {
2431
- return this.getRuleContexts(AndStepContext);
2432
- }
2433
- else {
2434
- return this.getRuleContext(i, AndStepContext);
2435
- }
2436
- }
2437
- butStep(i) {
2438
- if (i === undefined) {
2439
- return this.getRuleContexts(ButStepContext);
2440
- }
2441
- else {
2442
- return this.getRuleContext(i, ButStepContext);
2443
- }
2444
- }
2445
- constructor(parent, invokingState) {
2446
- super(parent, invokingState);
2447
- }
2448
- // @Override
2449
- get ruleIndex() { return GherkinParser.RULE_step; }
2450
- // @Override
2451
- accept(visitor) {
2452
- if (visitor.visitStep) {
2453
- return visitor.visitStep(this);
2454
- }
2455
- else {
2456
- return visitor.visitChildren(this);
2457
- }
2458
- }
2459
- }
2460
- exports.StepContext = StepContext;
2461
- class GivenStepContext extends ParserRuleContext_1.ParserRuleContext {
2462
- GIVEN() { return this.getToken(GherkinParser.GIVEN, 0); }
2463
- multilineText() {
2464
- return this.getRuleContext(0, MultilineTextContext);
2465
- }
2466
- tags() {
2467
- return this.tryGetRuleContext(0, TagsContext);
2468
- }
2469
- NEWLINE(i) {
2470
- if (i === undefined) {
2471
- return this.getTokens(GherkinParser.NEWLINE);
2472
- }
2473
- else {
2474
- return this.getToken(GherkinParser.NEWLINE, i);
2475
- }
2476
- }
2477
- docString() {
2478
- return this.tryGetRuleContext(0, DocStringContext);
2479
- }
2480
- constructor(parent, invokingState) {
2481
- super(parent, invokingState);
2482
- }
2483
- // @Override
2484
- get ruleIndex() { return GherkinParser.RULE_givenStep; }
2485
- // @Override
2486
- accept(visitor) {
2487
- if (visitor.visitGivenStep) {
2488
- return visitor.visitGivenStep(this);
2489
- }
2490
- else {
2491
- return visitor.visitChildren(this);
2492
- }
2493
- }
2494
- }
2495
- exports.GivenStepContext = GivenStepContext;
2496
- class AndGivenStepContext extends ParserRuleContext_1.ParserRuleContext {
2497
- AND_GIVEN() { return this.getToken(GherkinParser.AND_GIVEN, 0); }
2498
- multilineText() {
2499
- return this.getRuleContext(0, MultilineTextContext);
2500
- }
2501
- tags() {
2502
- return this.tryGetRuleContext(0, TagsContext);
2503
- }
2504
- NEWLINE(i) {
2505
- if (i === undefined) {
2506
- return this.getTokens(GherkinParser.NEWLINE);
2507
- }
2508
- else {
2509
- return this.getToken(GherkinParser.NEWLINE, i);
2510
- }
2511
- }
2512
- docString() {
2513
- return this.tryGetRuleContext(0, DocStringContext);
2514
- }
2515
- constructor(parent, invokingState) {
2516
- super(parent, invokingState);
2517
- }
2518
- // @Override
2519
- get ruleIndex() { return GherkinParser.RULE_andGivenStep; }
2520
- // @Override
2521
- accept(visitor) {
2522
- if (visitor.visitAndGivenStep) {
2523
- return visitor.visitAndGivenStep(this);
2524
- }
2525
- else {
2526
- return visitor.visitChildren(this);
2527
- }
2528
- }
2529
- }
2530
- exports.AndGivenStepContext = AndGivenStepContext;
2531
- class WhenStepContext extends ParserRuleContext_1.ParserRuleContext {
2532
- WHEN() { return this.getToken(GherkinParser.WHEN, 0); }
2533
- multilineText() {
2534
- return this.getRuleContext(0, MultilineTextContext);
2535
- }
2536
- tags() {
2537
- return this.tryGetRuleContext(0, TagsContext);
2538
- }
2539
- NEWLINE(i) {
2540
- if (i === undefined) {
2541
- return this.getTokens(GherkinParser.NEWLINE);
2542
- }
2543
- else {
2544
- return this.getToken(GherkinParser.NEWLINE, i);
2545
- }
2546
- }
2547
- docString() {
2548
- return this.tryGetRuleContext(0, DocStringContext);
2549
- }
2550
- constructor(parent, invokingState) {
2551
- super(parent, invokingState);
2552
- }
2553
- // @Override
2554
- get ruleIndex() { return GherkinParser.RULE_whenStep; }
2555
- // @Override
2556
- accept(visitor) {
2557
- if (visitor.visitWhenStep) {
2558
- return visitor.visitWhenStep(this);
2559
- }
2560
- else {
2561
- return visitor.visitChildren(this);
2562
- }
2563
- }
2564
- }
2565
- exports.WhenStepContext = WhenStepContext;
2566
- class AndWhenStepContext extends ParserRuleContext_1.ParserRuleContext {
2567
- AND_WHEN() { return this.getToken(GherkinParser.AND_WHEN, 0); }
2568
- multilineText() {
2569
- return this.getRuleContext(0, MultilineTextContext);
2570
- }
2571
- tags() {
2572
- return this.tryGetRuleContext(0, TagsContext);
2573
- }
2574
- NEWLINE(i) {
2575
- if (i === undefined) {
2576
- return this.getTokens(GherkinParser.NEWLINE);
2577
- }
2578
- else {
2579
- return this.getToken(GherkinParser.NEWLINE, i);
2580
- }
2581
- }
2582
- docString() {
2583
- return this.tryGetRuleContext(0, DocStringContext);
2584
- }
2585
- constructor(parent, invokingState) {
2586
- super(parent, invokingState);
2587
- }
2588
- // @Override
2589
- get ruleIndex() { return GherkinParser.RULE_andWhenStep; }
2590
- // @Override
2591
- accept(visitor) {
2592
- if (visitor.visitAndWhenStep) {
2593
- return visitor.visitAndWhenStep(this);
2594
- }
2595
- else {
2596
- return visitor.visitChildren(this);
2597
- }
2598
- }
2599
- }
2600
- exports.AndWhenStepContext = AndWhenStepContext;
2601
- class ThenStepContext extends ParserRuleContext_1.ParserRuleContext {
2602
- THEN() { return this.getToken(GherkinParser.THEN, 0); }
2603
- multilineText() {
2604
- return this.getRuleContext(0, MultilineTextContext);
2605
- }
2606
- thenTags() {
2607
- return this.tryGetRuleContext(0, ThenTagsContext);
2608
- }
2609
- NEWLINE(i) {
2610
- if (i === undefined) {
2611
- return this.getTokens(GherkinParser.NEWLINE);
2612
- }
2613
- else {
2614
- return this.getToken(GherkinParser.NEWLINE, i);
2615
- }
2616
- }
2617
- docString() {
2618
- return this.tryGetRuleContext(0, DocStringContext);
2619
- }
2620
- constructor(parent, invokingState) {
2621
- super(parent, invokingState);
2622
- }
2623
- // @Override
2624
- get ruleIndex() { return GherkinParser.RULE_thenStep; }
2625
- // @Override
2626
- accept(visitor) {
2627
- if (visitor.visitThenStep) {
2628
- return visitor.visitThenStep(this);
2629
- }
2630
- else {
2631
- return visitor.visitChildren(this);
2632
- }
2633
- }
2634
- }
2635
- exports.ThenStepContext = ThenStepContext;
2636
- class AndStepContext extends ParserRuleContext_1.ParserRuleContext {
2637
- AND() { return this.getToken(GherkinParser.AND, 0); }
2638
- multilineText() {
2639
- return this.getRuleContext(0, MultilineTextContext);
2640
- }
2641
- thenTags() {
2642
- return this.tryGetRuleContext(0, ThenTagsContext);
2643
- }
2644
- NEWLINE(i) {
2645
- if (i === undefined) {
2646
- return this.getTokens(GherkinParser.NEWLINE);
2647
- }
2648
- else {
2649
- return this.getToken(GherkinParser.NEWLINE, i);
2650
- }
2651
- }
2652
- docString() {
2653
- return this.tryGetRuleContext(0, DocStringContext);
2654
- }
2655
- constructor(parent, invokingState) {
2656
- super(parent, invokingState);
2657
- }
2658
- // @Override
2659
- get ruleIndex() { return GherkinParser.RULE_andStep; }
2660
- // @Override
2661
- accept(visitor) {
2662
- if (visitor.visitAndStep) {
2663
- return visitor.visitAndStep(this);
2664
- }
2665
- else {
2666
- return visitor.visitChildren(this);
2667
- }
2668
- }
2669
- }
2670
- exports.AndStepContext = AndStepContext;
2671
- class ButStepContext extends ParserRuleContext_1.ParserRuleContext {
2672
- BUT() { return this.getToken(GherkinParser.BUT, 0); }
2673
- multilineText() {
2674
- return this.getRuleContext(0, MultilineTextContext);
2675
- }
2676
- thenTags() {
2677
- return this.tryGetRuleContext(0, ThenTagsContext);
2678
- }
2679
- NEWLINE(i) {
2680
- if (i === undefined) {
2681
- return this.getTokens(GherkinParser.NEWLINE);
2682
- }
2683
- else {
2684
- return this.getToken(GherkinParser.NEWLINE, i);
2685
- }
2686
- }
2687
- docString() {
2688
- return this.tryGetRuleContext(0, DocStringContext);
2689
- }
2690
- constructor(parent, invokingState) {
2691
- super(parent, invokingState);
2692
- }
2693
- // @Override
2694
- get ruleIndex() { return GherkinParser.RULE_butStep; }
2695
- // @Override
2696
- accept(visitor) {
2697
- if (visitor.visitButStep) {
2698
- return visitor.visitButStep(this);
2699
- }
2700
- else {
2701
- return visitor.visitChildren(this);
2702
- }
2703
- }
2704
- }
2705
- exports.ButStepContext = ButStepContext;
2706
- class DocStringContext extends ParserRuleContext_1.ParserRuleContext {
2707
- DOC_STRING() { return this.getToken(GherkinParser.DOC_STRING, 0); }
2708
- constructor(parent, invokingState) {
2709
- super(parent, invokingState);
2710
- }
2711
- // @Override
2712
- get ruleIndex() { return GherkinParser.RULE_docString; }
2713
- // @Override
2714
- accept(visitor) {
2715
- if (visitor.visitDocString) {
2716
- return visitor.visitDocString(this);
2717
- }
2718
- else {
2719
- return visitor.visitChildren(this);
2720
- }
2721
- }
2722
- }
2723
- exports.DocStringContext = DocStringContext;
2724
- class TagsContext extends ParserRuleContext_1.ParserRuleContext {
2725
- NEWLINE(i) {
2726
- if (i === undefined) {
2727
- return this.getTokens(GherkinParser.NEWLINE);
2728
- }
2729
- else {
2730
- return this.getToken(GherkinParser.NEWLINE, i);
2731
- }
2732
- }
2733
- ONLY_TAG(i) {
2734
- if (i === undefined) {
2735
- return this.getTokens(GherkinParser.ONLY_TAG);
2736
- }
2737
- else {
2738
- return this.getToken(GherkinParser.ONLY_TAG, i);
2739
- }
2740
- }
2741
- SKIP_TAG(i) {
2742
- if (i === undefined) {
2743
- return this.getTokens(GherkinParser.SKIP_TAG);
2744
- }
2745
- else {
2746
- return this.getToken(GherkinParser.SKIP_TAG, i);
2747
- }
2748
- }
2749
- TAG(i) {
2750
- if (i === undefined) {
2751
- return this.getTokens(GherkinParser.TAG);
2752
- }
2753
- else {
2754
- return this.getToken(GherkinParser.TAG, i);
2755
- }
2756
- }
2757
- constructor(parent, invokingState) {
2758
- super(parent, invokingState);
2759
- }
2760
- // @Override
2761
- get ruleIndex() { return GherkinParser.RULE_tags; }
2762
- // @Override
2763
- accept(visitor) {
2764
- if (visitor.visitTags) {
2765
- return visitor.visitTags(this);
2766
- }
2767
- else {
2768
- return visitor.visitChildren(this);
2769
- }
2770
- }
2771
- }
2772
- exports.TagsContext = TagsContext;
2773
- class ThenTagsContext extends ParserRuleContext_1.ParserRuleContext {
2774
- NEWLINE(i) {
2775
- if (i === undefined) {
2776
- return this.getTokens(GherkinParser.NEWLINE);
2777
- }
2778
- else {
2779
- return this.getToken(GherkinParser.NEWLINE, i);
2780
- }
2781
- }
2782
- ONLY_TAG(i) {
2783
- if (i === undefined) {
2784
- return this.getTokens(GherkinParser.ONLY_TAG);
2785
- }
2786
- else {
2787
- return this.getToken(GherkinParser.ONLY_TAG, i);
2788
- }
2789
- }
2790
- SKIP_TAG(i) {
2791
- if (i === undefined) {
2792
- return this.getTokens(GherkinParser.SKIP_TAG);
2793
- }
2794
- else {
2795
- return this.getToken(GherkinParser.SKIP_TAG, i);
2796
- }
2797
- }
2798
- FAIL_TAG(i) {
2799
- if (i === undefined) {
2800
- return this.getTokens(GherkinParser.FAIL_TAG);
2801
- }
2802
- else {
2803
- return this.getToken(GherkinParser.FAIL_TAG, i);
2804
- }
2805
- }
2806
- TODO_TAG(i) {
2807
- if (i === undefined) {
2808
- return this.getTokens(GherkinParser.TODO_TAG);
2809
- }
2810
- else {
2811
- return this.getToken(GherkinParser.TODO_TAG, i);
2812
- }
2813
- }
2814
- TAG(i) {
2815
- if (i === undefined) {
2816
- return this.getTokens(GherkinParser.TAG);
2817
- }
2818
- else {
2819
- return this.getToken(GherkinParser.TAG, i);
2820
- }
2821
- }
2822
- constructor(parent, invokingState) {
2823
- super(parent, invokingState);
2824
- }
2825
- // @Override
2826
- get ruleIndex() { return GherkinParser.RULE_thenTags; }
2827
- // @Override
2828
- accept(visitor) {
2829
- if (visitor.visitThenTags) {
2830
- return visitor.visitThenTags(this);
2831
- }
2832
- else {
2833
- return visitor.visitChildren(this);
2834
- }
2835
- }
2836
- }
2837
- exports.ThenTagsContext = ThenTagsContext;
2838
- class ContentTextContext extends ParserRuleContext_1.ParserRuleContext {
2839
- TEXT_CHARACTER(i) {
2840
- if (i === undefined) {
2841
- return this.getTokens(GherkinParser.TEXT_CHARACTER);
2842
- }
2843
- else {
2844
- return this.getToken(GherkinParser.TEXT_CHARACTER, i);
2845
- }
2846
- }
2847
- constructor(parent, invokingState) {
2848
- super(parent, invokingState);
2849
- }
2850
- // @Override
2851
- get ruleIndex() { return GherkinParser.RULE_contentText; }
2852
- // @Override
2853
- accept(visitor) {
2854
- if (visitor.visitContentText) {
2855
- return visitor.visitContentText(this);
2856
- }
2857
- else {
2858
- return visitor.visitChildren(this);
2859
- }
2860
- }
2861
- }
2862
- exports.ContentTextContext = ContentTextContext;
2863
- class MultilineTextContext extends ParserRuleContext_1.ParserRuleContext {
2864
- TEXT_CHARACTER(i) {
2865
- if (i === undefined) {
2866
- return this.getTokens(GherkinParser.TEXT_CHARACTER);
2867
- }
2868
- else {
2869
- return this.getToken(GherkinParser.TEXT_CHARACTER, i);
2870
- }
2871
- }
2872
- NEWLINE(i) {
2873
- if (i === undefined) {
2874
- return this.getTokens(GherkinParser.NEWLINE);
2875
- }
2876
- else {
2877
- return this.getToken(GherkinParser.NEWLINE, i);
2878
- }
2879
- }
2880
- constructor(parent, invokingState) {
2881
- super(parent, invokingState);
2882
- }
2883
- // @Override
2884
- get ruleIndex() { return GherkinParser.RULE_multilineText; }
2885
- // @Override
2886
- accept(visitor) {
2887
- if (visitor.visitMultilineText) {
2888
- return visitor.visitMultilineText(this);
2889
- }
2890
- else {
2891
- return visitor.visitChildren(this);
2892
- }
2893
- }
2894
- }
2895
- exports.MultilineTextContext = MultilineTextContext;
2896
- //# sourceMappingURL=GherkinParser.js.map