pickle-jar 1.1.0 → 1.3.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 (20) hide show
  1. package/README.md +3 -1
  2. package/dist/src/feature-file-visitor.d.ts +4 -3
  3. package/dist/src/feature-file-visitor.js +79 -52
  4. package/dist/src/feature-file-visitor.js.map +1 -1
  5. package/dist/src/grammar/GherkinLexer.d.ts +8 -6
  6. package/dist/src/grammar/GherkinLexer.js +157 -150
  7. package/dist/src/grammar/GherkinLexer.js.map +1 -1
  8. package/dist/src/grammar/GherkinParser.d.ts +85 -26
  9. package/dist/src/grammar/GherkinParser.js +1495 -445
  10. package/dist/src/grammar/GherkinParser.js.map +1 -1
  11. package/dist/src/grammar/GherkinParserVisitor.d.ts +14 -0
  12. package/dist/src/index.d.ts +1 -0
  13. package/dist/src/index.js +1 -0
  14. package/dist/src/index.js.map +1 -1
  15. package/dist/src/jest-error-listener.d.ts +8 -0
  16. package/dist/src/jest-error-listener.js +22 -0
  17. package/dist/src/jest-error-listener.js.map +1 -0
  18. package/dist/src/test-runner.js +18 -8
  19. package/dist/src/test-runner.js.map +1 -1
  20. package/package.json +1 -1
package/dist/src/grammar/GherkinParser.js CHANGED
@@ -2,7 +2,7 @@
2
2
  // @ts-nocheck
3
3
  // Generated from ./src/grammar/GherkinParser.g4 by ANTLR 4.9.0-SNAPSHOT
4
4
  Object.defineProperty(exports, "__esModule", { value: true });
5
- exports.ContentTextContext = 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;
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
6
  const tslib_1 = require("tslib");
7
7
  const ATN_1 = require("antlr4ts/atn/ATN");
8
8
  const ATNDeserializer_1 = require("antlr4ts/atn/ATNDeserializer");
@@ -41,22 +41,41 @@ class GherkinParser extends Parser_1.Parser {
41
41
  this.enterRule(_localctx, 0, GherkinParser.RULE_featureFile);
42
42
  let _la;
43
43
  try {
44
+ let _alt;
44
45
  this.enterOuterAlt(_localctx, 1);
45
46
  {
46
- this.state = 43;
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;
47
64
  this._errHandler.sync(this);
48
65
  _la = this._input.LA(1);
49
- while (_la === GherkinParser.FEATURE) {
66
+ while (_la === GherkinParser.NEWLINE) {
50
67
  {
51
68
  {
52
- this.state = 40;
53
- this.feature();
69
+ this.state = 50;
70
+ this.match(GherkinParser.NEWLINE);
54
71
  }
55
72
  }
56
- this.state = 45;
73
+ this.state = 55;
57
74
  this._errHandler.sync(this);
58
75
  _la = this._input.LA(1);
59
76
  }
77
+ this.state = 56;
78
+ this.match(GherkinParser.EOF);
60
79
  }
61
80
  }
62
81
  catch (re) {
@@ -80,58 +99,75 @@ class GherkinParser extends Parser_1.Parser {
80
99
  this.enterRule(_localctx, 2, GherkinParser.RULE_feature);
81
100
  let _la;
82
101
  try {
102
+ let _alt;
83
103
  this.enterOuterAlt(_localctx, 1);
84
104
  {
85
- this.state = 46;
105
+ this.state = 59;
106
+ this._errHandler.sync(this);
107
+ _la = this._input.LA(1);
108
+ if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG) | (1 << GherkinParser.NEWLINE))) !== 0)) {
109
+ {
110
+ this.state = 58;
111
+ this.tags();
112
+ }
113
+ }
114
+ this.state = 61;
86
115
  this.match(GherkinParser.FEATURE);
87
- this.state = 47;
88
- this.contentText();
89
- this.state = 58;
116
+ this.state = 62;
117
+ this.multilineText();
118
+ this.state = 64;
90
119
  this._errHandler.sync(this);
91
- switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
120
+ switch (this.interpreter.adaptivePredict(this._input, 3, this._ctx)) {
92
121
  case 1:
93
122
  {
94
- this.state = 49;
95
- this._errHandler.sync(this);
96
- _la = this._input.LA(1);
97
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.BACKGROUND) | (1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
98
- {
99
- this.state = 48;
100
- this.background();
101
- }
102
- }
123
+ this.state = 63;
124
+ this.background();
103
125
  }
104
126
  break;
105
- case 2:
127
+ }
128
+ this.state = 70;
129
+ this._errHandler.sync(this);
130
+ _alt = this.interpreter.adaptivePredict(this._input, 5, this._ctx);
131
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
132
+ if (_alt === 1) {
106
133
  {
107
- this.state = 55;
134
+ this.state = 68;
108
135
  this._errHandler.sync(this);
109
- _la = this._input.LA(1);
110
- while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.SCENARIO) | (1 << GherkinParser.SCENARIO_OUTLINE) | (1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
111
- {
112
- this.state = 53;
113
- this._errHandler.sync(this);
114
- switch (this.interpreter.adaptivePredict(this._input, 2, this._ctx)) {
115
- case 1:
116
- {
117
- this.state = 51;
118
- this.scenario();
119
- }
120
- break;
121
- case 2:
122
- {
123
- this.state = 52;
124
- this.scenarioOutline();
125
- }
126
- break;
136
+ switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
137
+ case 1:
138
+ {
139
+ this.state = 66;
140
+ this.scenario();
127
141
  }
128
- }
129
- this.state = 57;
130
- this._errHandler.sync(this);
131
- _la = this._input.LA(1);
142
+ break;
143
+ case 2:
144
+ {
145
+ this.state = 67;
146
+ this.scenarioOutline();
147
+ }
148
+ break;
132
149
  }
133
150
  }
134
- break;
151
+ }
152
+ this.state = 72;
153
+ this._errHandler.sync(this);
154
+ _alt = this.interpreter.adaptivePredict(this._input, 5, this._ctx);
155
+ }
156
+ this.state = 76;
157
+ this._errHandler.sync(this);
158
+ _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
159
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
160
+ if (_alt === 1) {
161
+ {
162
+ {
163
+ this.state = 73;
164
+ this.match(GherkinParser.NEWLINE);
165
+ }
166
+ }
167
+ }
168
+ this.state = 78;
169
+ this._errHandler.sync(this);
170
+ _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
135
171
  }
136
172
  }
137
173
  }
@@ -159,62 +195,51 @@ class GherkinParser extends Parser_1.Parser {
159
195
  let _alt;
160
196
  this.enterOuterAlt(_localctx, 1);
161
197
  {
162
- this.state = 61;
198
+ this.state = 80;
199
+ this._errHandler.sync(this);
200
+ switch (this.interpreter.adaptivePredict(this._input, 7, this._ctx)) {
201
+ case 1:
202
+ {
203
+ this.state = 79;
204
+ this.tags();
205
+ }
206
+ break;
207
+ }
208
+ this.state = 85;
163
209
  this._errHandler.sync(this);
164
210
  _la = this._input.LA(1);
165
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
211
+ while (_la === GherkinParser.NEWLINE) {
166
212
  {
167
- this.state = 60;
168
- this.tags();
213
+ {
214
+ this.state = 82;
215
+ this.match(GherkinParser.NEWLINE);
216
+ }
169
217
  }
218
+ this.state = 87;
219
+ this._errHandler.sync(this);
220
+ _la = this._input.LA(1);
170
221
  }
171
- this.state = 63;
222
+ this.state = 88;
172
223
  this.match(GherkinParser.BACKGROUND);
173
- this.state = 64;
174
- this.contentText();
175
- this.state = 65;
224
+ this.state = 89;
225
+ this.multilineText();
226
+ this.state = 90;
176
227
  this.givenStep();
177
- this.state = 69;
228
+ this.state = 94;
178
229
  this._errHandler.sync(this);
179
- _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
230
+ _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
180
231
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
181
232
  if (_alt === 1) {
182
233
  {
183
234
  {
184
- this.state = 66;
235
+ this.state = 91;
185
236
  this.andGivenStep();
186
237
  }
187
238
  }
188
239
  }
189
- this.state = 71;
190
- this._errHandler.sync(this);
191
- _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
192
- }
193
- this.state = 76;
194
- this._errHandler.sync(this);
195
- _la = this._input.LA(1);
196
- while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.SCENARIO) | (1 << GherkinParser.SCENARIO_OUTLINE) | (1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
197
- {
198
- this.state = 74;
199
- this._errHandler.sync(this);
200
- switch (this.interpreter.adaptivePredict(this._input, 7, this._ctx)) {
201
- case 1:
202
- {
203
- this.state = 72;
204
- this.scenario();
205
- }
206
- break;
207
- case 2:
208
- {
209
- this.state = 73;
210
- this.scenarioOutline();
211
- }
212
- break;
213
- }
214
- }
215
- this.state = 78;
240
+ this.state = 96;
216
241
  this._errHandler.sync(this);
217
- _la = this._input.LA(1);
242
+ _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
218
243
  }
219
244
  }
220
245
  }
@@ -241,20 +266,35 @@ class GherkinParser extends Parser_1.Parser {
241
266
  try {
242
267
  this.enterOuterAlt(_localctx, 1);
243
268
  {
244
- this.state = 80;
269
+ this.state = 98;
270
+ this._errHandler.sync(this);
271
+ switch (this.interpreter.adaptivePredict(this._input, 10, this._ctx)) {
272
+ case 1:
273
+ {
274
+ this.state = 97;
275
+ this.tags();
276
+ }
277
+ break;
278
+ }
279
+ this.state = 103;
245
280
  this._errHandler.sync(this);
246
281
  _la = this._input.LA(1);
247
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
282
+ while (_la === GherkinParser.NEWLINE) {
248
283
  {
249
- this.state = 79;
250
- this.tags();
284
+ {
285
+ this.state = 100;
286
+ this.match(GherkinParser.NEWLINE);
287
+ }
251
288
  }
289
+ this.state = 105;
290
+ this._errHandler.sync(this);
291
+ _la = this._input.LA(1);
252
292
  }
253
- this.state = 82;
293
+ this.state = 106;
254
294
  this.match(GherkinParser.SCENARIO);
255
- this.state = 83;
256
- this.contentText();
257
- this.state = 84;
295
+ this.state = 107;
296
+ this.multilineText();
297
+ this.state = 108;
258
298
  this.step();
259
299
  }
260
300
  }
@@ -281,22 +321,37 @@ class GherkinParser extends Parser_1.Parser {
281
321
  try {
282
322
  this.enterOuterAlt(_localctx, 1);
283
323
  {
284
- this.state = 87;
324
+ this.state = 111;
325
+ this._errHandler.sync(this);
326
+ switch (this.interpreter.adaptivePredict(this._input, 12, this._ctx)) {
327
+ case 1:
328
+ {
329
+ this.state = 110;
330
+ this.tags();
331
+ }
332
+ break;
333
+ }
334
+ this.state = 116;
285
335
  this._errHandler.sync(this);
286
336
  _la = this._input.LA(1);
287
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
337
+ while (_la === GherkinParser.NEWLINE) {
288
338
  {
289
- this.state = 86;
290
- this.tags();
339
+ {
340
+ this.state = 113;
341
+ this.match(GherkinParser.NEWLINE);
342
+ }
291
343
  }
344
+ this.state = 118;
345
+ this._errHandler.sync(this);
346
+ _la = this._input.LA(1);
292
347
  }
293
- this.state = 89;
348
+ this.state = 119;
294
349
  this.match(GherkinParser.SCENARIO_OUTLINE);
295
- this.state = 90;
296
- this.contentText();
297
- this.state = 91;
350
+ this.state = 120;
351
+ this.multilineText();
352
+ this.state = 121;
298
353
  this.step();
299
- this.state = 92;
354
+ this.state = 122;
300
355
  this.examplesBlock();
301
356
  }
302
357
  }
@@ -323,21 +378,49 @@ class GherkinParser extends Parser_1.Parser {
323
378
  try {
324
379
  this.enterOuterAlt(_localctx, 1);
325
380
  {
326
- this.state = 94;
381
+ this.state = 127;
382
+ this._errHandler.sync(this);
383
+ _la = this._input.LA(1);
384
+ while (_la === GherkinParser.NEWLINE) {
385
+ {
386
+ {
387
+ this.state = 124;
388
+ this.match(GherkinParser.NEWLINE);
389
+ }
390
+ }
391
+ this.state = 129;
392
+ this._errHandler.sync(this);
393
+ _la = this._input.LA(1);
394
+ }
395
+ this.state = 130;
327
396
  this.match(GherkinParser.EXAMPLES);
328
- this.state = 95;
397
+ this.state = 132;
398
+ this._errHandler.sync(this);
399
+ _la = this._input.LA(1);
400
+ do {
401
+ {
402
+ {
403
+ this.state = 131;
404
+ this.match(GherkinParser.NEWLINE);
405
+ }
406
+ }
407
+ this.state = 134;
408
+ this._errHandler.sync(this);
409
+ _la = this._input.LA(1);
410
+ } while (_la === GherkinParser.NEWLINE);
411
+ this.state = 136;
329
412
  this.tableHeader();
330
- this.state = 97;
413
+ this.state = 138;
331
414
  this._errHandler.sync(this);
332
415
  _la = this._input.LA(1);
333
416
  do {
334
417
  {
335
418
  {
336
- this.state = 96;
419
+ this.state = 137;
337
420
  this.tableRow();
338
421
  }
339
422
  }
340
- this.state = 99;
423
+ this.state = 140;
341
424
  this._errHandler.sync(this);
342
425
  _la = this._input.LA(1);
343
426
  } while (_la === GherkinParser.PIPE);
@@ -365,7 +448,7 @@ class GherkinParser extends Parser_1.Parser {
365
448
  try {
366
449
  this.enterOuterAlt(_localctx, 1);
367
450
  {
368
- this.state = 101;
451
+ this.state = 142;
369
452
  this.tableRow();
370
453
  }
371
454
  }
@@ -388,59 +471,36 @@ class GherkinParser extends Parser_1.Parser {
388
471
  tableRow() {
389
472
  let _localctx = new TableRowContext(this._ctx, this.state);
390
473
  this.enterRule(_localctx, 14, GherkinParser.RULE_tableRow);
391
- let _la;
392
474
  try {
393
475
  let _alt;
394
476
  this.enterOuterAlt(_localctx, 1);
395
477
  {
396
- this.state = 103;
478
+ this.state = 144;
397
479
  this.match(GherkinParser.PIPE);
398
- this.state = 105;
480
+ this.state = 145;
481
+ this.cell();
482
+ this.state = 150;
399
483
  this._errHandler.sync(this);
400
- _la = this._input.LA(1);
401
- do {
402
- {
403
- {
404
- this.state = 104;
405
- this.cell();
406
- }
407
- }
408
- this.state = 107;
409
- this._errHandler.sync(this);
410
- _la = this._input.LA(1);
411
- } while (_la === GherkinParser.TEXT_CHARACTER);
412
- this.state = 117;
413
- this._errHandler.sync(this);
414
- _alt = this.interpreter.adaptivePredict(this._input, 14, this._ctx);
484
+ _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
415
485
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
416
486
  if (_alt === 1) {
417
487
  {
418
488
  {
419
- this.state = 109;
489
+ this.state = 146;
420
490
  this.match(GherkinParser.PIPE);
421
- this.state = 111;
422
- this._errHandler.sync(this);
423
- _la = this._input.LA(1);
424
- do {
425
- {
426
- {
427
- this.state = 110;
428
- this.cell();
429
- }
430
- }
431
- this.state = 113;
432
- this._errHandler.sync(this);
433
- _la = this._input.LA(1);
434
- } while (_la === GherkinParser.TEXT_CHARACTER);
491
+ this.state = 147;
492
+ this.cell();
435
493
  }
436
494
  }
437
495
  }
438
- this.state = 119;
496
+ this.state = 152;
439
497
  this._errHandler.sync(this);
440
- _alt = this.interpreter.adaptivePredict(this._input, 14, this._ctx);
498
+ _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
441
499
  }
442
- this.state = 120;
500
+ this.state = 153;
443
501
  this.match(GherkinParser.PIPE);
502
+ this.state = 154;
503
+ this.match(GherkinParser.NEWLINE);
444
504
  }
445
505
  }
446
506
  catch (re) {
@@ -462,11 +522,19 @@ class GherkinParser extends Parser_1.Parser {
462
522
  cell() {
463
523
  let _localctx = new CellContext(this._ctx, this.state);
464
524
  this.enterRule(_localctx, 16, GherkinParser.RULE_cell);
525
+ let _la;
465
526
  try {
466
527
  this.enterOuterAlt(_localctx, 1);
467
528
  {
468
- this.state = 122;
469
- this.contentText();
529
+ this.state = 157;
530
+ this._errHandler.sync(this);
531
+ _la = this._input.LA(1);
532
+ if (_la === GherkinParser.TEXT_CHARACTER) {
533
+ {
534
+ this.state = 156;
535
+ this.contentText();
536
+ }
537
+ }
470
538
  }
471
539
  }
472
540
  catch (re) {
@@ -492,75 +560,75 @@ class GherkinParser extends Parser_1.Parser {
492
560
  let _alt;
493
561
  this.enterOuterAlt(_localctx, 1);
494
562
  {
495
- this.state = 124;
563
+ this.state = 159;
496
564
  this.givenStep();
497
- this.state = 128;
565
+ this.state = 163;
498
566
  this._errHandler.sync(this);
499
- _alt = this.interpreter.adaptivePredict(this._input, 15, this._ctx);
567
+ _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
500
568
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
501
569
  if (_alt === 1) {
502
570
  {
503
571
  {
504
- this.state = 125;
572
+ this.state = 160;
505
573
  this.andGivenStep();
506
574
  }
507
575
  }
508
576
  }
509
- this.state = 130;
577
+ this.state = 165;
510
578
  this._errHandler.sync(this);
511
- _alt = this.interpreter.adaptivePredict(this._input, 15, this._ctx);
579
+ _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
512
580
  }
513
- this.state = 131;
581
+ this.state = 166;
514
582
  this.whenStep();
515
- this.state = 135;
583
+ this.state = 170;
516
584
  this._errHandler.sync(this);
517
- _alt = this.interpreter.adaptivePredict(this._input, 16, this._ctx);
585
+ _alt = this.interpreter.adaptivePredict(this._input, 20, this._ctx);
518
586
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
519
587
  if (_alt === 1) {
520
588
  {
521
589
  {
522
- this.state = 132;
590
+ this.state = 167;
523
591
  this.andWhenStep();
524
592
  }
525
593
  }
526
594
  }
527
- this.state = 137;
595
+ this.state = 172;
528
596
  this._errHandler.sync(this);
529
- _alt = this.interpreter.adaptivePredict(this._input, 16, this._ctx);
597
+ _alt = this.interpreter.adaptivePredict(this._input, 20, this._ctx);
530
598
  }
531
- this.state = 138;
599
+ this.state = 173;
532
600
  this.thenStep();
533
- this.state = 142;
601
+ this.state = 177;
534
602
  this._errHandler.sync(this);
535
- _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
603
+ _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
536
604
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
537
605
  if (_alt === 1) {
538
606
  {
539
607
  {
540
- this.state = 139;
608
+ this.state = 174;
541
609
  this.andStep();
542
610
  }
543
611
  }
544
612
  }
545
- this.state = 144;
613
+ this.state = 179;
546
614
  this._errHandler.sync(this);
547
- _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
615
+ _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
548
616
  }
549
- this.state = 148;
617
+ this.state = 183;
550
618
  this._errHandler.sync(this);
551
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
619
+ _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
552
620
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
553
621
  if (_alt === 1) {
554
622
  {
555
623
  {
556
- this.state = 145;
624
+ this.state = 180;
557
625
  this.butStep();
558
626
  }
559
627
  }
560
628
  }
561
- this.state = 150;
629
+ this.state = 185;
562
630
  this._errHandler.sync(this);
563
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
631
+ _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
564
632
  }
565
633
  }
566
634
  }
@@ -585,29 +653,100 @@ class GherkinParser extends Parser_1.Parser {
585
653
  this.enterRule(_localctx, 20, GherkinParser.RULE_givenStep);
586
654
  let _la;
587
655
  try {
656
+ let _alt;
588
657
  this.enterOuterAlt(_localctx, 1);
589
658
  {
590
- this.state = 152;
659
+ this.state = 187;
660
+ this._errHandler.sync(this);
661
+ switch (this.interpreter.adaptivePredict(this._input, 23, this._ctx)) {
662
+ case 1:
663
+ {
664
+ this.state = 186;
665
+ this.tags();
666
+ }
667
+ break;
668
+ }
669
+ this.state = 192;
591
670
  this._errHandler.sync(this);
592
671
  _la = this._input.LA(1);
593
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
672
+ while (_la === GherkinParser.NEWLINE) {
594
673
  {
595
- this.state = 151;
596
- this.tags();
674
+ {
675
+ this.state = 189;
676
+ this.match(GherkinParser.NEWLINE);
677
+ }
597
678
  }
679
+ this.state = 194;
680
+ this._errHandler.sync(this);
681
+ _la = this._input.LA(1);
598
682
  }
599
- this.state = 154;
683
+ this.state = 195;
600
684
  this.match(GherkinParser.GIVEN);
601
- this.state = 155;
602
- this.contentText();
603
- this.state = 157;
685
+ this.state = 196;
686
+ this.multilineText();
687
+ this.state = 211;
604
688
  this._errHandler.sync(this);
605
- _la = this._input.LA(1);
606
- if (_la === GherkinParser.DOC_STRING) {
607
- {
608
- this.state = 156;
609
- this.docString();
610
- }
689
+ switch (this.interpreter.adaptivePredict(this._input, 28, this._ctx)) {
690
+ case 1:
691
+ {
692
+ this.state = 204;
693
+ this._errHandler.sync(this);
694
+ switch (this.interpreter.adaptivePredict(this._input, 26, this._ctx)) {
695
+ case 1:
696
+ {
697
+ this.state = 197;
698
+ this.match(GherkinParser.NEWLINE);
699
+ this.state = 198;
700
+ this.docString();
701
+ this.state = 200;
702
+ this._errHandler.sync(this);
703
+ _alt = 1;
704
+ do {
705
+ switch (_alt) {
706
+ case 1:
707
+ {
708
+ {
709
+ this.state = 199;
710
+ this.match(GherkinParser.NEWLINE);
711
+ }
712
+ }
713
+ break;
714
+ default:
715
+ throw new NoViableAltException_1.NoViableAltException(this);
716
+ }
717
+ this.state = 202;
718
+ this._errHandler.sync(this);
719
+ _alt = this.interpreter.adaptivePredict(this._input, 25, this._ctx);
720
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
721
+ }
722
+ break;
723
+ }
724
+ }
725
+ break;
726
+ case 2:
727
+ {
728
+ this.state = 207;
729
+ this._errHandler.sync(this);
730
+ _alt = 1;
731
+ do {
732
+ switch (_alt) {
733
+ case 1:
734
+ {
735
+ {
736
+ this.state = 206;
737
+ this.match(GherkinParser.NEWLINE);
738
+ }
739
+ }
740
+ break;
741
+ default:
742
+ throw new NoViableAltException_1.NoViableAltException(this);
743
+ }
744
+ this.state = 209;
745
+ this._errHandler.sync(this);
746
+ _alt = this.interpreter.adaptivePredict(this._input, 27, this._ctx);
747
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
748
+ }
749
+ break;
611
750
  }
612
751
  }
613
752
  }
@@ -632,29 +771,100 @@ class GherkinParser extends Parser_1.Parser {
632
771
  this.enterRule(_localctx, 22, GherkinParser.RULE_andGivenStep);
633
772
  let _la;
634
773
  try {
774
+ let _alt;
635
775
  this.enterOuterAlt(_localctx, 1);
636
776
  {
637
- this.state = 160;
777
+ this.state = 214;
778
+ this._errHandler.sync(this);
779
+ switch (this.interpreter.adaptivePredict(this._input, 29, this._ctx)) {
780
+ case 1:
781
+ {
782
+ this.state = 213;
783
+ this.tags();
784
+ }
785
+ break;
786
+ }
787
+ this.state = 219;
638
788
  this._errHandler.sync(this);
639
789
  _la = this._input.LA(1);
640
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
790
+ while (_la === GherkinParser.NEWLINE) {
641
791
  {
642
- this.state = 159;
643
- this.tags();
792
+ {
793
+ this.state = 216;
794
+ this.match(GherkinParser.NEWLINE);
795
+ }
644
796
  }
797
+ this.state = 221;
798
+ this._errHandler.sync(this);
799
+ _la = this._input.LA(1);
645
800
  }
646
- this.state = 162;
801
+ this.state = 222;
647
802
  this.match(GherkinParser.AND_GIVEN);
648
- this.state = 163;
649
- this.contentText();
650
- this.state = 165;
803
+ this.state = 223;
804
+ this.multilineText();
805
+ this.state = 238;
651
806
  this._errHandler.sync(this);
652
- _la = this._input.LA(1);
653
- if (_la === GherkinParser.DOC_STRING) {
654
- {
655
- this.state = 164;
656
- this.docString();
657
- }
807
+ switch (this.interpreter.adaptivePredict(this._input, 34, this._ctx)) {
808
+ case 1:
809
+ {
810
+ this.state = 231;
811
+ this._errHandler.sync(this);
812
+ switch (this.interpreter.adaptivePredict(this._input, 32, this._ctx)) {
813
+ case 1:
814
+ {
815
+ this.state = 224;
816
+ this.match(GherkinParser.NEWLINE);
817
+ this.state = 225;
818
+ this.docString();
819
+ this.state = 227;
820
+ this._errHandler.sync(this);
821
+ _alt = 1;
822
+ do {
823
+ switch (_alt) {
824
+ case 1:
825
+ {
826
+ {
827
+ this.state = 226;
828
+ this.match(GherkinParser.NEWLINE);
829
+ }
830
+ }
831
+ break;
832
+ default:
833
+ throw new NoViableAltException_1.NoViableAltException(this);
834
+ }
835
+ this.state = 229;
836
+ this._errHandler.sync(this);
837
+ _alt = this.interpreter.adaptivePredict(this._input, 31, this._ctx);
838
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
839
+ }
840
+ break;
841
+ }
842
+ }
843
+ break;
844
+ case 2:
845
+ {
846
+ this.state = 234;
847
+ this._errHandler.sync(this);
848
+ _alt = 1;
849
+ do {
850
+ switch (_alt) {
851
+ case 1:
852
+ {
853
+ {
854
+ this.state = 233;
855
+ this.match(GherkinParser.NEWLINE);
856
+ }
857
+ }
858
+ break;
859
+ default:
860
+ throw new NoViableAltException_1.NoViableAltException(this);
861
+ }
862
+ this.state = 236;
863
+ this._errHandler.sync(this);
864
+ _alt = this.interpreter.adaptivePredict(this._input, 33, this._ctx);
865
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
866
+ }
867
+ break;
658
868
  }
659
869
  }
660
870
  }
@@ -679,29 +889,100 @@ class GherkinParser extends Parser_1.Parser {
679
889
  this.enterRule(_localctx, 24, GherkinParser.RULE_whenStep);
680
890
  let _la;
681
891
  try {
892
+ let _alt;
682
893
  this.enterOuterAlt(_localctx, 1);
683
894
  {
684
- this.state = 168;
895
+ this.state = 241;
896
+ this._errHandler.sync(this);
897
+ switch (this.interpreter.adaptivePredict(this._input, 35, this._ctx)) {
898
+ case 1:
899
+ {
900
+ this.state = 240;
901
+ this.tags();
902
+ }
903
+ break;
904
+ }
905
+ this.state = 246;
685
906
  this._errHandler.sync(this);
686
907
  _la = this._input.LA(1);
687
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
908
+ while (_la === GherkinParser.NEWLINE) {
688
909
  {
689
- this.state = 167;
690
- this.tags();
910
+ {
911
+ this.state = 243;
912
+ this.match(GherkinParser.NEWLINE);
913
+ }
691
914
  }
915
+ this.state = 248;
916
+ this._errHandler.sync(this);
917
+ _la = this._input.LA(1);
692
918
  }
693
- this.state = 170;
919
+ this.state = 249;
694
920
  this.match(GherkinParser.WHEN);
695
- this.state = 171;
696
- this.contentText();
697
- this.state = 173;
921
+ this.state = 250;
922
+ this.multilineText();
923
+ this.state = 265;
698
924
  this._errHandler.sync(this);
699
- _la = this._input.LA(1);
700
- if (_la === GherkinParser.DOC_STRING) {
701
- {
702
- this.state = 172;
703
- this.docString();
704
- }
925
+ switch (this.interpreter.adaptivePredict(this._input, 40, this._ctx)) {
926
+ case 1:
927
+ {
928
+ this.state = 258;
929
+ this._errHandler.sync(this);
930
+ switch (this.interpreter.adaptivePredict(this._input, 38, this._ctx)) {
931
+ case 1:
932
+ {
933
+ this.state = 251;
934
+ this.match(GherkinParser.NEWLINE);
935
+ this.state = 252;
936
+ this.docString();
937
+ this.state = 254;
938
+ this._errHandler.sync(this);
939
+ _alt = 1;
940
+ do {
941
+ switch (_alt) {
942
+ case 1:
943
+ {
944
+ {
945
+ this.state = 253;
946
+ this.match(GherkinParser.NEWLINE);
947
+ }
948
+ }
949
+ break;
950
+ default:
951
+ throw new NoViableAltException_1.NoViableAltException(this);
952
+ }
953
+ this.state = 256;
954
+ this._errHandler.sync(this);
955
+ _alt = this.interpreter.adaptivePredict(this._input, 37, this._ctx);
956
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
957
+ }
958
+ break;
959
+ }
960
+ }
961
+ break;
962
+ case 2:
963
+ {
964
+ this.state = 261;
965
+ this._errHandler.sync(this);
966
+ _alt = 1;
967
+ do {
968
+ switch (_alt) {
969
+ case 1:
970
+ {
971
+ {
972
+ this.state = 260;
973
+ this.match(GherkinParser.NEWLINE);
974
+ }
975
+ }
976
+ break;
977
+ default:
978
+ throw new NoViableAltException_1.NoViableAltException(this);
979
+ }
980
+ this.state = 263;
981
+ this._errHandler.sync(this);
982
+ _alt = this.interpreter.adaptivePredict(this._input, 39, this._ctx);
983
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
984
+ }
985
+ break;
705
986
  }
706
987
  }
707
988
  }
@@ -726,29 +1007,100 @@ class GherkinParser extends Parser_1.Parser {
726
1007
  this.enterRule(_localctx, 26, GherkinParser.RULE_andWhenStep);
727
1008
  let _la;
728
1009
  try {
1010
+ let _alt;
729
1011
  this.enterOuterAlt(_localctx, 1);
730
1012
  {
731
- this.state = 176;
1013
+ this.state = 268;
1014
+ this._errHandler.sync(this);
1015
+ switch (this.interpreter.adaptivePredict(this._input, 41, this._ctx)) {
1016
+ case 1:
1017
+ {
1018
+ this.state = 267;
1019
+ this.tags();
1020
+ }
1021
+ break;
1022
+ }
1023
+ this.state = 273;
732
1024
  this._errHandler.sync(this);
733
1025
  _la = this._input.LA(1);
734
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1026
+ while (_la === GherkinParser.NEWLINE) {
735
1027
  {
736
- this.state = 175;
737
- this.tags();
1028
+ {
1029
+ this.state = 270;
1030
+ this.match(GherkinParser.NEWLINE);
1031
+ }
738
1032
  }
1033
+ this.state = 275;
1034
+ this._errHandler.sync(this);
1035
+ _la = this._input.LA(1);
739
1036
  }
740
- this.state = 178;
1037
+ this.state = 276;
741
1038
  this.match(GherkinParser.AND_WHEN);
742
- this.state = 179;
743
- this.contentText();
744
- this.state = 181;
1039
+ this.state = 277;
1040
+ this.multilineText();
1041
+ this.state = 292;
745
1042
  this._errHandler.sync(this);
746
- _la = this._input.LA(1);
747
- if (_la === GherkinParser.DOC_STRING) {
748
- {
749
- this.state = 180;
750
- this.docString();
751
- }
1043
+ switch (this.interpreter.adaptivePredict(this._input, 46, this._ctx)) {
1044
+ case 1:
1045
+ {
1046
+ this.state = 285;
1047
+ this._errHandler.sync(this);
1048
+ switch (this.interpreter.adaptivePredict(this._input, 44, this._ctx)) {
1049
+ case 1:
1050
+ {
1051
+ this.state = 278;
1052
+ this.match(GherkinParser.NEWLINE);
1053
+ this.state = 279;
1054
+ this.docString();
1055
+ this.state = 281;
1056
+ this._errHandler.sync(this);
1057
+ _alt = 1;
1058
+ do {
1059
+ switch (_alt) {
1060
+ case 1:
1061
+ {
1062
+ {
1063
+ this.state = 280;
1064
+ this.match(GherkinParser.NEWLINE);
1065
+ }
1066
+ }
1067
+ break;
1068
+ default:
1069
+ throw new NoViableAltException_1.NoViableAltException(this);
1070
+ }
1071
+ this.state = 283;
1072
+ this._errHandler.sync(this);
1073
+ _alt = this.interpreter.adaptivePredict(this._input, 43, this._ctx);
1074
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1075
+ }
1076
+ break;
1077
+ }
1078
+ }
1079
+ break;
1080
+ case 2:
1081
+ {
1082
+ this.state = 288;
1083
+ this._errHandler.sync(this);
1084
+ _alt = 1;
1085
+ do {
1086
+ switch (_alt) {
1087
+ case 1:
1088
+ {
1089
+ {
1090
+ this.state = 287;
1091
+ this.match(GherkinParser.NEWLINE);
1092
+ }
1093
+ }
1094
+ break;
1095
+ default:
1096
+ throw new NoViableAltException_1.NoViableAltException(this);
1097
+ }
1098
+ this.state = 290;
1099
+ this._errHandler.sync(this);
1100
+ _alt = this.interpreter.adaptivePredict(this._input, 45, this._ctx);
1101
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1102
+ }
1103
+ break;
752
1104
  }
753
1105
  }
754
1106
  }
@@ -773,29 +1125,100 @@ class GherkinParser extends Parser_1.Parser {
773
1125
  this.enterRule(_localctx, 28, GherkinParser.RULE_thenStep);
774
1126
  let _la;
775
1127
  try {
1128
+ let _alt;
776
1129
  this.enterOuterAlt(_localctx, 1);
777
1130
  {
778
- this.state = 184;
1131
+ this.state = 295;
1132
+ this._errHandler.sync(this);
1133
+ switch (this.interpreter.adaptivePredict(this._input, 47, this._ctx)) {
1134
+ case 1:
1135
+ {
1136
+ this.state = 294;
1137
+ this.thenTags();
1138
+ }
1139
+ break;
1140
+ }
1141
+ this.state = 300;
779
1142
  this._errHandler.sync(this);
780
1143
  _la = this._input.LA(1);
781
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1144
+ while (_la === GherkinParser.NEWLINE) {
782
1145
  {
783
- this.state = 183;
784
- this.tags();
1146
+ {
1147
+ this.state = 297;
1148
+ this.match(GherkinParser.NEWLINE);
1149
+ }
785
1150
  }
1151
+ this.state = 302;
1152
+ this._errHandler.sync(this);
1153
+ _la = this._input.LA(1);
786
1154
  }
787
- this.state = 186;
1155
+ this.state = 303;
788
1156
  this.match(GherkinParser.THEN);
789
- this.state = 187;
790
- this.contentText();
791
- this.state = 189;
1157
+ this.state = 304;
1158
+ this.multilineText();
1159
+ this.state = 319;
792
1160
  this._errHandler.sync(this);
793
- _la = this._input.LA(1);
794
- if (_la === GherkinParser.DOC_STRING) {
795
- {
796
- this.state = 188;
797
- this.docString();
798
- }
1161
+ switch (this.interpreter.adaptivePredict(this._input, 52, this._ctx)) {
1162
+ case 1:
1163
+ {
1164
+ this.state = 312;
1165
+ this._errHandler.sync(this);
1166
+ switch (this.interpreter.adaptivePredict(this._input, 50, this._ctx)) {
1167
+ case 1:
1168
+ {
1169
+ this.state = 305;
1170
+ this.match(GherkinParser.NEWLINE);
1171
+ this.state = 306;
1172
+ this.docString();
1173
+ this.state = 308;
1174
+ this._errHandler.sync(this);
1175
+ _alt = 1;
1176
+ do {
1177
+ switch (_alt) {
1178
+ case 1:
1179
+ {
1180
+ {
1181
+ this.state = 307;
1182
+ this.match(GherkinParser.NEWLINE);
1183
+ }
1184
+ }
1185
+ break;
1186
+ default:
1187
+ throw new NoViableAltException_1.NoViableAltException(this);
1188
+ }
1189
+ this.state = 310;
1190
+ this._errHandler.sync(this);
1191
+ _alt = this.interpreter.adaptivePredict(this._input, 49, this._ctx);
1192
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1193
+ }
1194
+ break;
1195
+ }
1196
+ }
1197
+ break;
1198
+ case 2:
1199
+ {
1200
+ this.state = 315;
1201
+ this._errHandler.sync(this);
1202
+ _alt = 1;
1203
+ do {
1204
+ switch (_alt) {
1205
+ case 1:
1206
+ {
1207
+ {
1208
+ this.state = 314;
1209
+ this.match(GherkinParser.NEWLINE);
1210
+ }
1211
+ }
1212
+ break;
1213
+ default:
1214
+ throw new NoViableAltException_1.NoViableAltException(this);
1215
+ }
1216
+ this.state = 317;
1217
+ this._errHandler.sync(this);
1218
+ _alt = this.interpreter.adaptivePredict(this._input, 51, this._ctx);
1219
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1220
+ }
1221
+ break;
799
1222
  }
800
1223
  }
801
1224
  }
@@ -820,29 +1243,100 @@ class GherkinParser extends Parser_1.Parser {
820
1243
  this.enterRule(_localctx, 30, GherkinParser.RULE_andStep);
821
1244
  let _la;
822
1245
  try {
1246
+ let _alt;
823
1247
  this.enterOuterAlt(_localctx, 1);
824
1248
  {
825
- this.state = 192;
1249
+ this.state = 322;
1250
+ this._errHandler.sync(this);
1251
+ switch (this.interpreter.adaptivePredict(this._input, 53, this._ctx)) {
1252
+ case 1:
1253
+ {
1254
+ this.state = 321;
1255
+ this.thenTags();
1256
+ }
1257
+ break;
1258
+ }
1259
+ this.state = 327;
826
1260
  this._errHandler.sync(this);
827
1261
  _la = this._input.LA(1);
828
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1262
+ while (_la === GherkinParser.NEWLINE) {
829
1263
  {
830
- this.state = 191;
831
- this.tags();
1264
+ {
1265
+ this.state = 324;
1266
+ this.match(GherkinParser.NEWLINE);
1267
+ }
832
1268
  }
1269
+ this.state = 329;
1270
+ this._errHandler.sync(this);
1271
+ _la = this._input.LA(1);
833
1272
  }
834
- this.state = 194;
1273
+ this.state = 330;
835
1274
  this.match(GherkinParser.AND);
836
- this.state = 195;
837
- this.contentText();
838
- this.state = 197;
1275
+ this.state = 331;
1276
+ this.multilineText();
1277
+ this.state = 346;
839
1278
  this._errHandler.sync(this);
840
- _la = this._input.LA(1);
841
- if (_la === GherkinParser.DOC_STRING) {
842
- {
843
- this.state = 196;
844
- this.docString();
845
- }
1279
+ switch (this.interpreter.adaptivePredict(this._input, 58, this._ctx)) {
1280
+ case 1:
1281
+ {
1282
+ this.state = 339;
1283
+ this._errHandler.sync(this);
1284
+ switch (this.interpreter.adaptivePredict(this._input, 56, this._ctx)) {
1285
+ case 1:
1286
+ {
1287
+ this.state = 332;
1288
+ this.match(GherkinParser.NEWLINE);
1289
+ this.state = 333;
1290
+ this.docString();
1291
+ this.state = 335;
1292
+ this._errHandler.sync(this);
1293
+ _alt = 1;
1294
+ do {
1295
+ switch (_alt) {
1296
+ case 1:
1297
+ {
1298
+ {
1299
+ this.state = 334;
1300
+ this.match(GherkinParser.NEWLINE);
1301
+ }
1302
+ }
1303
+ break;
1304
+ default:
1305
+ throw new NoViableAltException_1.NoViableAltException(this);
1306
+ }
1307
+ this.state = 337;
1308
+ this._errHandler.sync(this);
1309
+ _alt = this.interpreter.adaptivePredict(this._input, 55, this._ctx);
1310
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1311
+ }
1312
+ break;
1313
+ }
1314
+ }
1315
+ break;
1316
+ case 2:
1317
+ {
1318
+ this.state = 342;
1319
+ this._errHandler.sync(this);
1320
+ _alt = 1;
1321
+ do {
1322
+ switch (_alt) {
1323
+ case 1:
1324
+ {
1325
+ {
1326
+ this.state = 341;
1327
+ this.match(GherkinParser.NEWLINE);
1328
+ }
1329
+ }
1330
+ break;
1331
+ default:
1332
+ throw new NoViableAltException_1.NoViableAltException(this);
1333
+ }
1334
+ this.state = 344;
1335
+ this._errHandler.sync(this);
1336
+ _alt = this.interpreter.adaptivePredict(this._input, 57, this._ctx);
1337
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1338
+ }
1339
+ break;
846
1340
  }
847
1341
  }
848
1342
  }
@@ -867,30 +1361,207 @@ class GherkinParser extends Parser_1.Parser {
867
1361
  this.enterRule(_localctx, 32, GherkinParser.RULE_butStep);
868
1362
  let _la;
869
1363
  try {
1364
+ let _alt;
870
1365
  this.enterOuterAlt(_localctx, 1);
871
1366
  {
872
- this.state = 200;
1367
+ this.state = 349;
1368
+ this._errHandler.sync(this);
1369
+ switch (this.interpreter.adaptivePredict(this._input, 59, this._ctx)) {
1370
+ case 1:
1371
+ {
1372
+ this.state = 348;
1373
+ this.thenTags();
1374
+ }
1375
+ break;
1376
+ }
1377
+ this.state = 354;
873
1378
  this._errHandler.sync(this);
874
1379
  _la = this._input.LA(1);
875
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1380
+ while (_la === GherkinParser.NEWLINE) {
876
1381
  {
877
- this.state = 199;
878
- this.tags();
1382
+ {
1383
+ this.state = 351;
1384
+ this.match(GherkinParser.NEWLINE);
1385
+ }
879
1386
  }
1387
+ this.state = 356;
1388
+ this._errHandler.sync(this);
1389
+ _la = this._input.LA(1);
880
1390
  }
881
- this.state = 202;
1391
+ this.state = 357;
882
1392
  this.match(GherkinParser.BUT);
883
- this.state = 203;
884
- this.contentText();
885
- this.state = 205;
1393
+ this.state = 358;
1394
+ this.multilineText();
1395
+ this.state = 373;
1396
+ this._errHandler.sync(this);
1397
+ switch (this.interpreter.adaptivePredict(this._input, 64, this._ctx)) {
1398
+ case 1:
1399
+ {
1400
+ this.state = 366;
1401
+ this._errHandler.sync(this);
1402
+ switch (this.interpreter.adaptivePredict(this._input, 62, this._ctx)) {
1403
+ case 1:
1404
+ {
1405
+ this.state = 359;
1406
+ this.match(GherkinParser.NEWLINE);
1407
+ this.state = 360;
1408
+ this.docString();
1409
+ this.state = 362;
1410
+ this._errHandler.sync(this);
1411
+ _alt = 1;
1412
+ do {
1413
+ switch (_alt) {
1414
+ case 1:
1415
+ {
1416
+ {
1417
+ this.state = 361;
1418
+ this.match(GherkinParser.NEWLINE);
1419
+ }
1420
+ }
1421
+ break;
1422
+ default:
1423
+ throw new NoViableAltException_1.NoViableAltException(this);
1424
+ }
1425
+ this.state = 364;
1426
+ this._errHandler.sync(this);
1427
+ _alt = this.interpreter.adaptivePredict(this._input, 61, this._ctx);
1428
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1429
+ }
1430
+ break;
1431
+ }
1432
+ }
1433
+ break;
1434
+ case 2:
1435
+ {
1436
+ this.state = 369;
1437
+ this._errHandler.sync(this);
1438
+ _alt = 1;
1439
+ do {
1440
+ switch (_alt) {
1441
+ case 1:
1442
+ {
1443
+ {
1444
+ this.state = 368;
1445
+ this.match(GherkinParser.NEWLINE);
1446
+ }
1447
+ }
1448
+ break;
1449
+ default:
1450
+ throw new NoViableAltException_1.NoViableAltException(this);
1451
+ }
1452
+ this.state = 371;
1453
+ this._errHandler.sync(this);
1454
+ _alt = this.interpreter.adaptivePredict(this._input, 63, this._ctx);
1455
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1456
+ }
1457
+ break;
1458
+ }
1459
+ }
1460
+ }
1461
+ catch (re) {
1462
+ if (re instanceof RecognitionException_1.RecognitionException) {
1463
+ _localctx.exception = re;
1464
+ this._errHandler.reportError(this, re);
1465
+ this._errHandler.recover(this, re);
1466
+ }
1467
+ else {
1468
+ throw re;
1469
+ }
1470
+ }
1471
+ finally {
1472
+ this.exitRule();
1473
+ }
1474
+ return _localctx;
1475
+ }
1476
+ // @RuleVersion(0)
1477
+ docString() {
1478
+ let _localctx = new DocStringContext(this._ctx, this.state);
1479
+ this.enterRule(_localctx, 34, GherkinParser.RULE_docString);
1480
+ try {
1481
+ this.enterOuterAlt(_localctx, 1);
1482
+ {
1483
+ this.state = 375;
1484
+ this.match(GherkinParser.DOC_STRING);
1485
+ }
1486
+ }
1487
+ catch (re) {
1488
+ if (re instanceof RecognitionException_1.RecognitionException) {
1489
+ _localctx.exception = re;
1490
+ this._errHandler.reportError(this, re);
1491
+ this._errHandler.recover(this, re);
1492
+ }
1493
+ else {
1494
+ throw re;
1495
+ }
1496
+ }
1497
+ finally {
1498
+ this.exitRule();
1499
+ }
1500
+ return _localctx;
1501
+ }
1502
+ // @RuleVersion(0)
1503
+ tags() {
1504
+ let _localctx = new TagsContext(this._ctx, this.state);
1505
+ this.enterRule(_localctx, 36, GherkinParser.RULE_tags);
1506
+ let _la;
1507
+ try {
1508
+ let _alt;
1509
+ this.enterOuterAlt(_localctx, 1);
1510
+ {
1511
+ this.state = 380;
886
1512
  this._errHandler.sync(this);
887
1513
  _la = this._input.LA(1);
888
- if (_la === GherkinParser.DOC_STRING) {
1514
+ while (_la === GherkinParser.NEWLINE) {
889
1515
  {
890
- this.state = 204;
891
- this.docString();
1516
+ {
1517
+ this.state = 377;
1518
+ this.match(GherkinParser.NEWLINE);
1519
+ }
1520
+ }
1521
+ this.state = 382;
1522
+ this._errHandler.sync(this);
1523
+ _la = this._input.LA(1);
1524
+ }
1525
+ this.state = 390;
1526
+ this._errHandler.sync(this);
1527
+ _la = this._input.LA(1);
1528
+ do {
1529
+ {
1530
+ {
1531
+ this.state = 383;
1532
+ _la = this._input.LA(1);
1533
+ if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
1534
+ this._errHandler.recoverInline(this);
1535
+ }
1536
+ else {
1537
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1538
+ this.matchedEOF = true;
1539
+ }
1540
+ this._errHandler.reportMatch(this);
1541
+ this.consume();
1542
+ }
1543
+ this.state = 387;
1544
+ this._errHandler.sync(this);
1545
+ _alt = this.interpreter.adaptivePredict(this._input, 66, this._ctx);
1546
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1547
+ if (_alt === 1) {
1548
+ {
1549
+ {
1550
+ this.state = 384;
1551
+ this.match(GherkinParser.NEWLINE);
1552
+ }
1553
+ }
1554
+ }
1555
+ this.state = 389;
1556
+ this._errHandler.sync(this);
1557
+ _alt = this.interpreter.adaptivePredict(this._input, 66, this._ctx);
1558
+ }
1559
+ }
892
1560
  }
893
- }
1561
+ this.state = 392;
1562
+ this._errHandler.sync(this);
1563
+ _la = this._input.LA(1);
1564
+ } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0));
894
1565
  }
895
1566
  }
896
1567
  catch (re) {
@@ -909,14 +1580,68 @@ class GherkinParser extends Parser_1.Parser {
909
1580
  return _localctx;
910
1581
  }
911
1582
  // @RuleVersion(0)
912
- docString() {
913
- let _localctx = new DocStringContext(this._ctx, this.state);
914
- this.enterRule(_localctx, 34, GherkinParser.RULE_docString);
1583
+ thenTags() {
1584
+ let _localctx = new ThenTagsContext(this._ctx, this.state);
1585
+ this.enterRule(_localctx, 38, GherkinParser.RULE_thenTags);
1586
+ let _la;
915
1587
  try {
1588
+ let _alt;
916
1589
  this.enterOuterAlt(_localctx, 1);
917
1590
  {
918
- this.state = 207;
919
- this.match(GherkinParser.DOC_STRING);
1591
+ this.state = 397;
1592
+ this._errHandler.sync(this);
1593
+ _la = this._input.LA(1);
1594
+ while (_la === GherkinParser.NEWLINE) {
1595
+ {
1596
+ {
1597
+ this.state = 394;
1598
+ this.match(GherkinParser.NEWLINE);
1599
+ }
1600
+ }
1601
+ this.state = 399;
1602
+ this._errHandler.sync(this);
1603
+ _la = this._input.LA(1);
1604
+ }
1605
+ this.state = 407;
1606
+ this._errHandler.sync(this);
1607
+ _la = this._input.LA(1);
1608
+ do {
1609
+ {
1610
+ {
1611
+ this.state = 400;
1612
+ _la = this._input.LA(1);
1613
+ 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))) {
1614
+ this._errHandler.recoverInline(this);
1615
+ }
1616
+ else {
1617
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1618
+ this.matchedEOF = true;
1619
+ }
1620
+ this._errHandler.reportMatch(this);
1621
+ this.consume();
1622
+ }
1623
+ this.state = 404;
1624
+ this._errHandler.sync(this);
1625
+ _alt = this.interpreter.adaptivePredict(this._input, 69, this._ctx);
1626
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1627
+ if (_alt === 1) {
1628
+ {
1629
+ {
1630
+ this.state = 401;
1631
+ this.match(GherkinParser.NEWLINE);
1632
+ }
1633
+ }
1634
+ }
1635
+ this.state = 406;
1636
+ this._errHandler.sync(this);
1637
+ _alt = this.interpreter.adaptivePredict(this._input, 69, this._ctx);
1638
+ }
1639
+ }
1640
+ }
1641
+ this.state = 409;
1642
+ this._errHandler.sync(this);
1643
+ _la = this._input.LA(1);
1644
+ } 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));
920
1645
  }
921
1646
  }
922
1647
  catch (re) {
@@ -935,37 +1660,27 @@ class GherkinParser extends Parser_1.Parser {
935
1660
  return _localctx;
936
1661
  }
937
1662
  // @RuleVersion(0)
938
- tags() {
939
- let _localctx = new TagsContext(this._ctx, this.state);
940
- this.enterRule(_localctx, 36, GherkinParser.RULE_tags);
1663
+ contentText() {
1664
+ let _localctx = new ContentTextContext(this._ctx, this.state);
1665
+ this.enterRule(_localctx, 40, GherkinParser.RULE_contentText);
941
1666
  let _la;
942
1667
  try {
943
1668
  this.enterOuterAlt(_localctx, 1);
944
1669
  {
945
- this.state = 210;
1670
+ this.state = 412;
946
1671
  this._errHandler.sync(this);
947
1672
  _la = this._input.LA(1);
948
1673
  do {
949
1674
  {
950
1675
  {
951
- this.state = 209;
952
- _la = this._input.LA(1);
953
- if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
954
- this._errHandler.recoverInline(this);
955
- }
956
- else {
957
- if (this._input.LA(1) === Token_1.Token.EOF) {
958
- this.matchedEOF = true;
959
- }
960
- this._errHandler.reportMatch(this);
961
- this.consume();
962
- }
1676
+ this.state = 411;
1677
+ this.match(GherkinParser.TEXT_CHARACTER);
963
1678
  }
964
1679
  }
965
- this.state = 212;
1680
+ this.state = 414;
966
1681
  this._errHandler.sync(this);
967
1682
  _la = this._input.LA(1);
968
- } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0));
1683
+ } while (_la === GherkinParser.TEXT_CHARACTER);
969
1684
  }
970
1685
  }
971
1686
  catch (re) {
@@ -984,14 +1699,15 @@ class GherkinParser extends Parser_1.Parser {
984
1699
  return _localctx;
985
1700
  }
986
1701
  // @RuleVersion(0)
987
- contentText() {
988
- let _localctx = new ContentTextContext(this._ctx, this.state);
989
- this.enterRule(_localctx, 38, GherkinParser.RULE_contentText);
1702
+ multilineText() {
1703
+ let _localctx = new MultilineTextContext(this._ctx, this.state);
1704
+ this.enterRule(_localctx, 42, GherkinParser.RULE_multilineText);
1705
+ let _la;
990
1706
  try {
991
1707
  let _alt;
992
1708
  this.enterOuterAlt(_localctx, 1);
993
1709
  {
994
- this.state = 215;
1710
+ this.state = 417;
995
1711
  this._errHandler.sync(this);
996
1712
  _alt = 1;
997
1713
  do {
@@ -999,17 +1715,27 @@ class GherkinParser extends Parser_1.Parser {
999
1715
  case 1:
1000
1716
  {
1001
1717
  {
1002
- this.state = 214;
1003
- this.match(GherkinParser.TEXT_CHARACTER);
1718
+ this.state = 416;
1719
+ _la = this._input.LA(1);
1720
+ if (!(_la === GherkinParser.TEXT_CHARACTER || _la === GherkinParser.NEWLINE)) {
1721
+ this._errHandler.recoverInline(this);
1722
+ }
1723
+ else {
1724
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1725
+ this.matchedEOF = true;
1726
+ }
1727
+ this._errHandler.reportMatch(this);
1728
+ this.consume();
1729
+ }
1004
1730
  }
1005
1731
  }
1006
1732
  break;
1007
1733
  default:
1008
1734
  throw new NoViableAltException_1.NoViableAltException(this);
1009
1735
  }
1010
- this.state = 217;
1736
+ this.state = 419;
1011
1737
  this._errHandler.sync(this);
1012
- _alt = this.interpreter.adaptivePredict(this._input, 34, this._ctx);
1738
+ _alt = this.interpreter.adaptivePredict(this._input, 72, this._ctx);
1013
1739
  } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1014
1740
  }
1015
1741
  }
@@ -1051,12 +1777,14 @@ GherkinParser.BACKGROUND = 12;
1051
1777
  GherkinParser.PIPE = 13;
1052
1778
  GherkinParser.ONLY_TAG = 14;
1053
1779
  GherkinParser.SKIP_TAG = 15;
1054
- GherkinParser.TAG = 16;
1055
- GherkinParser.COMMENT = 17;
1056
- GherkinParser.TEXT_CHARACTER = 18;
1057
- GherkinParser.WS = 19;
1058
- GherkinParser.WSS = 20;
1059
- GherkinParser.DOC_STRING = 21;
1780
+ GherkinParser.TODO_TAG = 16;
1781
+ GherkinParser.FAIL_TAG = 17;
1782
+ GherkinParser.TAG = 18;
1783
+ GherkinParser.COMMENT = 19;
1784
+ GherkinParser.TEXT_CHARACTER = 20;
1785
+ GherkinParser.NEWLINE = 21;
1786
+ GherkinParser.WSS = 22;
1787
+ GherkinParser.DOC_STRING = 23;
1060
1788
  GherkinParser.RULE_featureFile = 0;
1061
1789
  GherkinParser.RULE_feature = 1;
1062
1790
  GherkinParser.RULE_background = 2;
@@ -1076,123 +1804,247 @@ GherkinParser.RULE_andStep = 15;
1076
1804
  GherkinParser.RULE_butStep = 16;
1077
1805
  GherkinParser.RULE_docString = 17;
1078
1806
  GherkinParser.RULE_tags = 18;
1079
- GherkinParser.RULE_contentText = 19;
1807
+ GherkinParser.RULE_thenTags = 19;
1808
+ GherkinParser.RULE_contentText = 20;
1809
+ GherkinParser.RULE_multilineText = 21;
1080
1810
  // tslint:disable:no-trailing-whitespace
1081
1811
  GherkinParser.ruleNames = [
1082
1812
  "featureFile", "feature", "background", "scenario", "scenarioOutline",
1083
1813
  "examplesBlock", "tableHeader", "tableRow", "cell", "step", "givenStep",
1084
1814
  "andGivenStep", "whenStep", "andWhenStep", "thenStep", "andStep", "butStep",
1085
- "docString", "tags", "contentText",
1815
+ "docString", "tags", "thenTags", "contentText", "multilineText",
1086
1816
  ];
1087
1817
  GherkinParser._LITERAL_NAMES = [
1088
1818
  undefined, undefined, undefined, undefined, undefined, undefined, undefined,
1089
1819
  undefined, undefined, undefined, undefined, undefined, undefined, "'|'",
1090
- "'@only'", "'@skip'",
1820
+ "'@only'", "'@skip'", "'@todo'", "'@fail'",
1091
1821
  ];
1092
1822
  GherkinParser._SYMBOLIC_NAMES = [
1093
1823
  undefined, "FEATURE", "SCENARIO", "SCENARIO_OUTLINE", "GIVEN", "AND_GIVEN",
1094
1824
  "WHEN", "AND_WHEN", "THEN", "AND", "BUT", "EXAMPLES", "BACKGROUND", "PIPE",
1095
- "ONLY_TAG", "SKIP_TAG", "TAG", "COMMENT", "TEXT_CHARACTER", "WS", "WSS",
1096
- "DOC_STRING",
1825
+ "ONLY_TAG", "SKIP_TAG", "TODO_TAG", "FAIL_TAG", "TAG", "COMMENT", "TEXT_CHARACTER",
1826
+ "NEWLINE", "WSS", "DOC_STRING",
1097
1827
  ];
1098
1828
  GherkinParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(GherkinParser._LITERAL_NAMES, GherkinParser._SYMBOLIC_NAMES, []);
1099
- GherkinParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x17\xDE\x04\x02" +
1100
- "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
1101
- "\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\x04" +
1102
- "\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
1103
- "\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x03\x02\x07\x02,\n\x02\f\x02\x0E" +
1104
- "\x02/\v\x02\x03\x03\x03\x03\x03\x03\x05\x034\n\x03\x03\x03\x03\x03\x07" +
1105
- "\x038\n\x03\f\x03\x0E\x03;\v\x03\x05\x03=\n\x03\x03\x04\x05\x04@\n\x04" +
1106
- "\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04F\n\x04\f\x04\x0E\x04I\v\x04\x03" +
1107
- "\x04\x03\x04\x07\x04M\n\x04\f\x04\x0E\x04P\v\x04\x03\x05\x05\x05S\n\x05" +
1108
- "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x05\x06Z\n\x06\x03\x06\x03\x06" +
1109
- "\x03\x06\x03\x06\x03\x06\x03\x07\x03\x07\x03\x07\x06\x07d\n\x07\r\x07" +
1110
- "\x0E\x07e\x03\b\x03\b\x03\t\x03\t\x06\tl\n\t\r\t\x0E\tm\x03\t\x03\t\x06" +
1111
- "\tr\n\t\r\t\x0E\ts\x07\tv\n\t\f\t\x0E\ty\v\t\x03\t\x03\t\x03\n\x03\n\x03" +
1112
- "\v\x03\v\x07\v\x81\n\v\f\v\x0E\v\x84\v\v\x03\v\x03\v\x07\v\x88\n\v\f\v" +
1113
- "\x0E\v\x8B\v\v\x03\v\x03\v\x07\v\x8F\n\v\f\v\x0E\v\x92\v\v\x03\v\x07\v" +
1114
- "\x95\n\v\f\v\x0E\v\x98\v\v\x03\f\x05\f\x9B\n\f\x03\f\x03\f\x03\f\x05\f" +
1115
- "\xA0\n\f\x03\r\x05\r\xA3\n\r\x03\r\x03\r\x03\r\x05\r\xA8\n\r\x03\x0E\x05" +
1116
- "\x0E\xAB\n\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\xB0\n\x0E\x03\x0F\x05\x0F" +
1117
- "\xB3\n\x0F\x03\x0F\x03\x0F\x03\x0F\x05\x0F\xB8\n\x0F\x03\x10\x05\x10\xBB" +
1118
- "\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\xC0\n\x10\x03\x11\x05\x11\xC3\n" +
1119
- "\x11\x03\x11\x03\x11\x03\x11\x05\x11\xC8\n\x11\x03\x12\x05\x12\xCB\n\x12" +
1120
- "\x03\x12\x03\x12\x03\x12\x05\x12\xD0\n\x12\x03\x13\x03\x13\x03\x14\x06" +
1121
- "\x14\xD5\n\x14\r\x14\x0E\x14\xD6\x03\x15\x06\x15\xDA\n\x15\r\x15\x0E\x15" +
1122
- "\xDB\x03\x15\x02\x02\x02\x16\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02" +
1123
- "\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02" +
1124
- " \x02\"\x02$\x02&\x02(\x02\x02\x03\x03\x02\x10\x12\x02\xEC\x02-\x03\x02" +
1125
- "\x02\x02\x040\x03\x02\x02\x02\x06?\x03\x02\x02\x02\bR\x03\x02\x02\x02" +
1126
- "\nY\x03\x02\x02\x02\f`\x03\x02\x02\x02\x0Eg\x03\x02\x02\x02\x10i\x03\x02" +
1127
- "\x02\x02\x12|\x03\x02\x02\x02\x14~\x03\x02\x02\x02\x16\x9A\x03\x02\x02" +
1128
- "\x02\x18\xA2\x03\x02\x02\x02\x1A\xAA\x03\x02\x02\x02\x1C\xB2\x03\x02\x02" +
1129
- "\x02\x1E\xBA\x03\x02\x02\x02 \xC2\x03\x02\x02\x02\"\xCA\x03\x02\x02\x02" +
1130
- "$\xD1\x03\x02\x02\x02&\xD4\x03\x02\x02\x02(\xD9\x03\x02\x02\x02*,\x05" +
1131
- "\x04\x03\x02+*\x03\x02\x02\x02,/\x03\x02\x02\x02-+\x03\x02\x02\x02-.\x03" +
1132
- "\x02\x02\x02.\x03\x03\x02\x02\x02/-\x03\x02\x02\x0201\x07\x03\x02\x02" +
1133
- "1<\x05(\x15\x0224\x05\x06\x04\x0232\x03\x02\x02\x0234\x03\x02\x02\x02" +
1134
- "4=\x03\x02\x02\x0258\x05\b\x05\x0268\x05\n\x06\x0275\x03\x02\x02\x027" +
1135
- "6\x03\x02\x02\x028;\x03\x02\x02\x0297\x03\x02\x02\x029:\x03\x02\x02\x02" +
1136
- ":=\x03\x02\x02\x02;9\x03\x02\x02\x02<3\x03\x02\x02\x02<9\x03\x02\x02\x02" +
1137
- "=\x05\x03\x02\x02\x02>@\x05&\x14\x02?>\x03\x02\x02\x02?@\x03\x02\x02\x02" +
1138
- "@A\x03\x02\x02\x02AB\x07\x0E\x02\x02BC\x05(\x15\x02CG\x05\x16\f\x02DF" +
1139
- "\x05\x18\r\x02ED\x03\x02\x02\x02FI\x03\x02\x02\x02GE\x03\x02\x02\x02G" +
1140
- "H\x03\x02\x02\x02HN\x03\x02\x02\x02IG\x03\x02\x02\x02JM\x05\b\x05\x02" +
1141
- "KM\x05\n\x06\x02LJ\x03\x02\x02\x02LK\x03\x02\x02\x02MP\x03\x02\x02\x02" +
1142
- "NL\x03\x02\x02\x02NO\x03\x02\x02\x02O\x07\x03\x02\x02\x02PN\x03\x02\x02" +
1143
- "\x02QS\x05&\x14\x02RQ\x03\x02\x02\x02RS\x03\x02\x02\x02ST\x03\x02\x02" +
1144
- "\x02TU\x07\x04\x02\x02UV\x05(\x15\x02VW\x05\x14\v\x02W\t\x03\x02\x02\x02" +
1145
- "XZ\x05&\x14\x02YX\x03\x02\x02\x02YZ\x03\x02\x02\x02Z[\x03\x02\x02\x02" +
1146
- "[\\\x07\x05\x02\x02\\]\x05(\x15\x02]^\x05\x14\v\x02^_\x05\f\x07\x02_\v" +
1147
- "\x03\x02\x02\x02`a\x07\r\x02\x02ac\x05\x0E\b\x02bd\x05\x10\t\x02cb\x03" +
1148
- "\x02\x02\x02de\x03\x02\x02\x02ec\x03\x02\x02\x02ef\x03\x02\x02\x02f\r" +
1149
- "\x03\x02\x02\x02gh\x05\x10\t\x02h\x0F\x03\x02\x02\x02ik\x07\x0F\x02\x02" +
1150
- "jl\x05\x12\n\x02kj\x03\x02\x02\x02lm\x03\x02\x02\x02mk\x03\x02\x02\x02" +
1151
- "mn\x03\x02\x02\x02nw\x03\x02\x02\x02oq\x07\x0F\x02\x02pr\x05\x12\n\x02" +
1152
- "qp\x03\x02\x02\x02rs\x03\x02\x02\x02sq\x03\x02\x02\x02st\x03\x02\x02\x02" +
1153
- "tv\x03\x02\x02\x02uo\x03\x02\x02\x02vy\x03\x02\x02\x02wu\x03\x02\x02\x02" +
1154
- "wx\x03\x02\x02\x02xz\x03\x02\x02\x02yw\x03\x02\x02\x02z{\x07\x0F\x02\x02" +
1155
- "{\x11\x03\x02\x02\x02|}\x05(\x15\x02}\x13\x03\x02\x02\x02~\x82\x05\x16" +
1156
- "\f\x02\x7F\x81\x05\x18\r\x02\x80\x7F\x03\x02\x02\x02\x81\x84\x03\x02\x02" +
1157
- "\x02\x82\x80\x03\x02\x02\x02\x82\x83\x03\x02\x02\x02\x83\x85\x03\x02\x02" +
1158
- "\x02\x84\x82\x03\x02\x02\x02\x85\x89\x05\x1A\x0E\x02\x86\x88\x05\x1C\x0F" +
1159
- "\x02\x87\x86\x03\x02\x02\x02\x88\x8B\x03\x02\x02\x02\x89\x87\x03\x02\x02" +
1160
- "\x02\x89\x8A\x03\x02\x02\x02\x8A\x8C\x03\x02\x02\x02\x8B\x89\x03\x02\x02" +
1161
- "\x02\x8C\x90\x05\x1E\x10\x02\x8D\x8F\x05 \x11\x02\x8E\x8D\x03\x02\x02" +
1162
- "\x02\x8F\x92\x03\x02\x02\x02\x90\x8E\x03\x02\x02\x02\x90\x91\x03\x02\x02" +
1163
- "\x02\x91\x96\x03\x02\x02\x02\x92\x90\x03\x02\x02\x02\x93\x95\x05\"\x12" +
1164
- "\x02\x94\x93\x03\x02\x02\x02\x95\x98\x03\x02\x02\x02\x96\x94\x03\x02\x02" +
1165
- "\x02\x96\x97\x03\x02\x02\x02\x97\x15\x03\x02\x02\x02\x98\x96\x03\x02\x02" +
1166
- "\x02\x99\x9B\x05&\x14\x02\x9A\x99\x03\x02\x02\x02\x9A\x9B\x03\x02\x02" +
1167
- "\x02\x9B\x9C\x03\x02\x02\x02\x9C\x9D\x07\x06\x02\x02\x9D\x9F\x05(\x15" +
1168
- "\x02\x9E\xA0\x05$\x13\x02\x9F\x9E\x03\x02\x02\x02\x9F\xA0\x03\x02\x02" +
1169
- "\x02\xA0\x17\x03\x02\x02\x02\xA1\xA3\x05&\x14\x02\xA2\xA1\x03\x02\x02" +
1170
- "\x02\xA2\xA3\x03\x02\x02\x02\xA3\xA4\x03\x02\x02\x02\xA4\xA5\x07\x07\x02" +
1171
- "\x02\xA5\xA7\x05(\x15\x02\xA6\xA8\x05$\x13\x02\xA7\xA6\x03\x02\x02\x02" +
1172
- "\xA7\xA8\x03\x02\x02\x02\xA8\x19\x03\x02\x02\x02\xA9\xAB\x05&\x14\x02" +
1173
- "\xAA\xA9\x03\x02\x02\x02\xAA\xAB\x03\x02\x02\x02\xAB\xAC\x03\x02\x02\x02" +
1174
- "\xAC\xAD\x07\b\x02\x02\xAD\xAF\x05(\x15\x02\xAE\xB0\x05$\x13\x02\xAF\xAE" +
1175
- "\x03\x02\x02\x02\xAF\xB0\x03\x02\x02\x02\xB0\x1B\x03\x02\x02\x02\xB1\xB3" +
1176
- "\x05&\x14\x02\xB2\xB1\x03\x02\x02\x02\xB2\xB3\x03\x02\x02\x02\xB3\xB4" +
1177
- "\x03\x02\x02\x02\xB4\xB5\x07\t\x02\x02\xB5\xB7\x05(\x15\x02\xB6\xB8\x05" +
1178
- "$\x13\x02\xB7\xB6\x03\x02\x02\x02\xB7\xB8\x03\x02\x02\x02\xB8\x1D\x03" +
1179
- "\x02\x02\x02\xB9\xBB\x05&\x14\x02\xBA\xB9\x03\x02\x02\x02\xBA\xBB\x03" +
1180
- "\x02\x02\x02\xBB\xBC\x03\x02\x02\x02\xBC\xBD\x07\n\x02\x02\xBD\xBF\x05" +
1181
- "(\x15\x02\xBE\xC0\x05$\x13\x02\xBF\xBE\x03\x02\x02\x02\xBF\xC0\x03\x02" +
1182
- "\x02\x02\xC0\x1F\x03\x02\x02\x02\xC1\xC3\x05&\x14\x02\xC2\xC1\x03\x02" +
1183
- "\x02\x02\xC2\xC3\x03\x02\x02\x02\xC3\xC4\x03\x02\x02\x02\xC4\xC5\x07\v" +
1184
- "\x02\x02\xC5\xC7\x05(\x15\x02\xC6\xC8\x05$\x13\x02\xC7\xC6\x03\x02\x02" +
1185
- "\x02\xC7\xC8\x03\x02\x02\x02\xC8!\x03\x02\x02\x02\xC9\xCB\x05&\x14\x02" +
1186
- "\xCA\xC9\x03\x02\x02\x02\xCA\xCB\x03\x02\x02\x02\xCB\xCC\x03\x02\x02\x02" +
1187
- "\xCC\xCD\x07\f\x02\x02\xCD\xCF\x05(\x15\x02\xCE\xD0\x05$\x13\x02\xCF\xCE" +
1188
- "\x03\x02\x02\x02\xCF\xD0\x03\x02\x02\x02\xD0#\x03\x02\x02\x02\xD1\xD2" +
1189
- "\x07\x17\x02\x02\xD2%\x03\x02\x02\x02\xD3\xD5\t\x02\x02\x02\xD4\xD3\x03" +
1190
- "\x02\x02\x02\xD5\xD6\x03\x02\x02\x02\xD6\xD4\x03\x02\x02\x02\xD6\xD7\x03" +
1191
- "\x02\x02\x02\xD7\'\x03\x02\x02\x02\xD8\xDA\x07\x14\x02\x02\xD9\xD8\x03" +
1192
- "\x02\x02\x02\xDA\xDB\x03\x02\x02\x02\xDB\xD9\x03\x02\x02\x02\xDB\xDC\x03" +
1193
- "\x02\x02\x02\xDC)\x03\x02\x02\x02%-379<?GLNRYemsw\x82\x89\x90\x96\x9A" +
1194
- "\x9F\xA2\xA7\xAA\xAF\xB2\xB7\xBA\xBF\xC2\xC7\xCA\xCF\xD6\xDB";
1829
+ GherkinParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x19\u01A8\x04" +
1830
+ "\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
1831
+ "\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" +
1832
+ "\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
1833
+ "\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
1834
+ "\x03\x02\x07\x020\n\x02\f\x02\x0E\x023\v\x02\x03\x02\x07\x026\n\x02\f" +
1835
+ "\x02\x0E\x029\v\x02\x03\x02\x03\x02\x03\x03\x05\x03>\n\x03\x03\x03\x03" +
1836
+ "\x03\x03\x03\x05\x03C\n\x03\x03\x03\x03\x03\x07\x03G\n\x03\f\x03\x0E\x03" +
1837
+ "J\v\x03\x03\x03\x07\x03M\n\x03\f\x03\x0E\x03P\v\x03\x03\x04\x05\x04S\n" +
1838
+ "\x04\x03\x04\x07\x04V\n\x04\f\x04\x0E\x04Y\v\x04\x03\x04\x03\x04\x03\x04" +
1839
+ "\x03\x04\x07\x04_\n\x04\f\x04\x0E\x04b\v\x04\x03\x05\x05\x05e\n\x05\x03" +
1840
+ "\x05\x07\x05h\n\x05\f\x05\x0E\x05k\v\x05\x03\x05\x03\x05\x03\x05\x03\x05" +
1841
+ "\x03\x06\x05\x06r\n\x06\x03\x06\x07\x06u\n\x06\f\x06\x0E\x06x\v\x06\x03" +
1842
+ "\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x07\x07\x07\x80\n\x07\f\x07\x0E" +
1843
+ "\x07\x83\v\x07\x03\x07\x03\x07\x06\x07\x87\n\x07\r\x07\x0E\x07\x88\x03" +
1844
+ "\x07\x03\x07\x06\x07\x8D\n\x07\r\x07\x0E\x07\x8E\x03\b\x03\b\x03\t\x03" +
1845
+ "\t\x03\t\x03\t\x07\t\x97\n\t\f\t\x0E\t\x9A\v\t\x03\t\x03\t\x03\t\x03\n" +
1846
+ "\x05\n\xA0\n\n\x03\v\x03\v\x07\v\xA4\n\v\f\v\x0E\v\xA7\v\v\x03\v\x03\v" +
1847
+ "\x07\v\xAB\n\v\f\v\x0E\v\xAE\v\v\x03\v\x03\v\x07\v\xB2\n\v\f\v\x0E\v\xB5" +
1848
+ "\v\v\x03\v\x07\v\xB8\n\v\f\v\x0E\v\xBB\v\v\x03\f\x05\f\xBE\n\f\x03\f\x07" +
1849
+ "\f\xC1\n\f\f\f\x0E\f\xC4\v\f\x03\f\x03\f\x03\f\x03\f\x03\f\x06\f\xCB\n" +
1850
+ "\f\r\f\x0E\f\xCC\x05\f\xCF\n\f\x03\f\x06\f\xD2\n\f\r\f\x0E\f\xD3\x05\f" +
1851
+ "\xD6\n\f\x03\r\x05\r\xD9\n\r\x03\r\x07\r\xDC\n\r\f\r\x0E\r\xDF\v\r\x03" +
1852
+ "\r\x03\r\x03\r\x03\r\x03\r\x06\r\xE6\n\r\r\r\x0E\r\xE7\x05\r\xEA\n\r\x03" +
1853
+ "\r\x06\r\xED\n\r\r\r\x0E\r\xEE\x05\r\xF1\n\r\x03\x0E\x05\x0E\xF4\n\x0E" +
1854
+ "\x03\x0E\x07\x0E\xF7\n\x0E\f\x0E\x0E\x0E\xFA\v\x0E\x03\x0E\x03\x0E\x03" +
1855
+ "\x0E\x03\x0E\x03\x0E\x06\x0E\u0101\n\x0E\r\x0E\x0E\x0E\u0102\x05\x0E\u0105" +
1856
+ "\n\x0E\x03\x0E\x06\x0E\u0108\n\x0E\r\x0E\x0E\x0E\u0109\x05\x0E\u010C\n" +
1857
+ "\x0E\x03\x0F\x05\x0F\u010F\n\x0F\x03\x0F\x07\x0F\u0112\n\x0F\f\x0F\x0E" +
1858
+ "\x0F\u0115\v\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x06\x0F\u011C" +
1859
+ "\n\x0F\r\x0F\x0E\x0F\u011D\x05\x0F\u0120\n\x0F\x03\x0F\x06\x0F\u0123\n" +
1860
+ "\x0F\r\x0F\x0E\x0F\u0124\x05\x0F\u0127\n\x0F\x03\x10\x05\x10\u012A\n\x10" +
1861
+ "\x03\x10\x07\x10\u012D\n\x10\f\x10\x0E\x10\u0130\v\x10\x03\x10\x03\x10" +
1862
+ "\x03\x10\x03\x10\x03\x10\x06\x10\u0137\n\x10\r\x10\x0E\x10\u0138\x05\x10" +
1863
+ "\u013B\n\x10\x03\x10\x06\x10\u013E\n\x10\r\x10\x0E\x10\u013F\x05\x10\u0142" +
1864
+ "\n\x10\x03\x11\x05\x11\u0145\n\x11\x03\x11\x07\x11\u0148\n\x11\f\x11\x0E" +
1865
+ "\x11\u014B\v\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x06\x11\u0152" +
1866
+ "\n\x11\r\x11\x0E\x11\u0153\x05\x11\u0156\n\x11\x03\x11\x06\x11\u0159\n" +
1867
+ "\x11\r\x11\x0E\x11\u015A\x05\x11\u015D\n\x11\x03\x12\x05\x12\u0160\n\x12" +
1868
+ "\x03\x12\x07\x12\u0163\n\x12\f\x12\x0E\x12\u0166\v\x12\x03\x12\x03\x12" +
1869
+ "\x03\x12\x03\x12\x03\x12\x06\x12\u016D\n\x12\r\x12\x0E\x12\u016E\x05\x12" +
1870
+ "\u0171\n\x12\x03\x12\x06\x12\u0174\n\x12\r\x12\x0E\x12\u0175\x05\x12\u0178" +
1871
+ "\n\x12\x03\x13\x03\x13\x03\x14\x07\x14\u017D\n\x14\f\x14\x0E\x14\u0180" +
1872
+ "\v\x14\x03\x14\x03\x14\x07\x14\u0184\n\x14\f\x14\x0E\x14\u0187\v\x14\x06" +
1873
+ "\x14\u0189\n\x14\r\x14\x0E\x14\u018A\x03\x15\x07\x15\u018E\n\x15\f\x15" +
1874
+ "\x0E\x15\u0191\v\x15\x03\x15\x03\x15\x07\x15\u0195\n\x15\f\x15\x0E\x15" +
1875
+ "\u0198\v\x15\x06\x15\u019A\n\x15\r\x15\x0E\x15\u019B\x03\x16\x06\x16\u019F" +
1876
+ "\n\x16\r\x16\x0E\x16\u01A0\x03\x17\x06\x17\u01A4\n\x17\r\x17\x0E\x17\u01A5" +
1877
+ "\x03\x17\x02\x02\x02\x18\x02\x02\x04\x02\x06\x02\b\x02\n\x02\f\x02\x0E" +
1878
+ "\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02\x1E\x02 " +
1879
+ "\x02\"\x02$\x02&\x02(\x02*\x02,\x02\x02\x05\x04\x02\x10\x11\x14\x14\x03" +
1880
+ "\x02\x10\x14\x03\x02\x16\x17\x02\u01DA\x021\x03\x02\x02\x02\x04=\x03\x02" +
1881
+ "\x02\x02\x06R\x03\x02\x02\x02\bd\x03\x02\x02\x02\nq\x03\x02\x02\x02\f" +
1882
+ "\x81\x03\x02\x02\x02\x0E\x90\x03\x02\x02\x02\x10\x92\x03\x02\x02\x02\x12" +
1883
+ "\x9F\x03\x02\x02\x02\x14\xA1\x03\x02\x02\x02\x16\xBD\x03\x02\x02\x02\x18" +
1884
+ "\xD8\x03\x02\x02\x02\x1A\xF3\x03\x02\x02\x02\x1C\u010E\x03\x02\x02\x02" +
1885
+ "\x1E\u0129\x03\x02\x02\x02 \u0144\x03\x02\x02\x02\"\u015F\x03\x02\x02" +
1886
+ "\x02$\u0179\x03\x02\x02\x02&\u017E\x03\x02\x02\x02(\u018F\x03\x02\x02" +
1887
+ "\x02*\u019E\x03\x02\x02\x02,\u01A3\x03\x02\x02\x02.0\x05\x04\x03\x02/" +
1888
+ ".\x03\x02\x02\x0203\x03\x02\x02\x021/\x03\x02\x02\x0212\x03\x02\x02\x02" +
1889
+ "27\x03\x02\x02\x0231\x03\x02\x02\x0246\x07\x17\x02\x0254\x03\x02\x02\x02" +
1890
+ "69\x03\x02\x02\x0275\x03\x02\x02\x0278\x03\x02\x02\x028:\x03\x02\x02\x02" +
1891
+ "97\x03\x02\x02\x02:;\x07\x02\x02\x03;\x03\x03\x02\x02\x02<>\x05&\x14\x02" +
1892
+ "=<\x03\x02\x02\x02=>\x03\x02\x02\x02>?\x03\x02\x02\x02?@\x07\x03\x02\x02" +
1893
+ "@B\x05,\x17\x02AC\x05\x06\x04\x02BA\x03\x02\x02\x02BC\x03\x02\x02\x02" +
1894
+ "CH\x03\x02\x02\x02DG\x05\b\x05\x02EG\x05\n\x06\x02FD\x03\x02\x02\x02F" +
1895
+ "E\x03\x02\x02\x02GJ\x03\x02\x02\x02HF\x03\x02\x02\x02HI\x03\x02\x02\x02" +
1896
+ "IN\x03\x02\x02\x02JH\x03\x02\x02\x02KM\x07\x17\x02\x02LK\x03\x02\x02\x02" +
1897
+ "MP\x03\x02\x02\x02NL\x03\x02\x02\x02NO\x03\x02\x02\x02O\x05\x03\x02\x02" +
1898
+ "\x02PN\x03\x02\x02\x02QS\x05&\x14\x02RQ\x03\x02\x02\x02RS\x03\x02\x02" +
1899
+ "\x02SW\x03\x02\x02\x02TV\x07\x17\x02\x02UT\x03\x02\x02\x02VY\x03\x02\x02" +
1900
+ "\x02WU\x03\x02\x02\x02WX\x03\x02\x02\x02XZ\x03\x02\x02\x02YW\x03\x02\x02" +
1901
+ "\x02Z[\x07\x0E\x02\x02[\\\x05,\x17\x02\\`\x05\x16\f\x02]_\x05\x18\r\x02" +
1902
+ "^]\x03\x02\x02\x02_b\x03\x02\x02\x02`^\x03\x02\x02\x02`a\x03\x02\x02\x02" +
1903
+ "a\x07\x03\x02\x02\x02b`\x03\x02\x02\x02ce\x05&\x14\x02dc\x03\x02\x02\x02" +
1904
+ "de\x03\x02\x02\x02ei\x03\x02\x02\x02fh\x07\x17\x02\x02gf\x03\x02\x02\x02" +
1905
+ "hk\x03\x02\x02\x02ig\x03\x02\x02\x02ij\x03\x02\x02\x02jl\x03\x02\x02\x02" +
1906
+ "ki\x03\x02\x02\x02lm\x07\x04\x02\x02mn\x05,\x17\x02no\x05\x14\v\x02o\t" +
1907
+ "\x03\x02\x02\x02pr\x05&\x14\x02qp\x03\x02\x02\x02qr\x03\x02\x02\x02rv" +
1908
+ "\x03\x02\x02\x02su\x07\x17\x02\x02ts\x03\x02\x02\x02ux\x03\x02\x02\x02" +
1909
+ "vt\x03\x02\x02\x02vw\x03\x02\x02\x02wy\x03\x02\x02\x02xv\x03\x02\x02\x02" +
1910
+ "yz\x07\x05\x02\x02z{\x05,\x17\x02{|\x05\x14\v\x02|}\x05\f\x07\x02}\v\x03" +
1911
+ "\x02\x02\x02~\x80\x07\x17\x02\x02\x7F~\x03\x02\x02\x02\x80\x83\x03\x02" +
1912
+ "\x02\x02\x81\x7F\x03\x02\x02\x02\x81\x82\x03\x02\x02\x02\x82\x84\x03\x02" +
1913
+ "\x02\x02\x83\x81\x03\x02\x02\x02\x84\x86\x07\r\x02\x02\x85\x87\x07\x17" +
1914
+ "\x02\x02\x86\x85\x03\x02\x02\x02\x87\x88\x03\x02\x02\x02\x88\x86\x03\x02" +
1915
+ "\x02\x02\x88\x89\x03\x02\x02\x02\x89\x8A\x03\x02\x02\x02\x8A\x8C\x05\x0E" +
1916
+ "\b\x02\x8B\x8D\x05\x10\t\x02\x8C\x8B\x03\x02\x02\x02\x8D\x8E\x03\x02\x02" +
1917
+ "\x02\x8E\x8C\x03\x02\x02\x02\x8E\x8F\x03\x02\x02\x02\x8F\r\x03\x02\x02" +
1918
+ "\x02\x90\x91\x05\x10\t\x02\x91\x0F\x03\x02\x02\x02\x92\x93\x07\x0F\x02" +
1919
+ "\x02\x93\x98\x05\x12\n\x02\x94\x95\x07\x0F\x02\x02\x95\x97\x05\x12\n\x02" +
1920
+ "\x96\x94\x03\x02\x02\x02\x97\x9A\x03\x02\x02\x02\x98\x96\x03\x02\x02\x02" +
1921
+ "\x98\x99\x03\x02\x02\x02\x99\x9B\x03\x02\x02\x02\x9A\x98\x03\x02\x02\x02" +
1922
+ "\x9B\x9C\x07\x0F\x02\x02\x9C\x9D\x07\x17\x02\x02\x9D\x11\x03\x02\x02\x02" +
1923
+ "\x9E\xA0\x05*\x16\x02\x9F\x9E\x03\x02\x02\x02\x9F\xA0\x03\x02\x02\x02" +
1924
+ "\xA0\x13\x03\x02\x02\x02\xA1\xA5\x05\x16\f\x02\xA2\xA4\x05\x18\r\x02\xA3" +
1925
+ "\xA2\x03\x02\x02\x02\xA4\xA7\x03\x02\x02\x02\xA5\xA3\x03\x02\x02\x02\xA5" +
1926
+ "\xA6\x03\x02\x02\x02\xA6\xA8\x03\x02\x02\x02\xA7\xA5\x03\x02\x02\x02\xA8" +
1927
+ "\xAC\x05\x1A\x0E\x02\xA9\xAB\x05\x1C\x0F\x02\xAA\xA9\x03\x02\x02\x02\xAB" +
1928
+ "\xAE\x03\x02\x02\x02\xAC\xAA\x03\x02\x02\x02\xAC\xAD\x03\x02\x02\x02\xAD" +
1929
+ "\xAF\x03\x02\x02\x02\xAE\xAC\x03\x02\x02\x02\xAF\xB3\x05\x1E\x10\x02\xB0" +
1930
+ "\xB2\x05 \x11\x02\xB1\xB0\x03\x02\x02\x02\xB2\xB5\x03\x02\x02\x02\xB3" +
1931
+ "\xB1\x03\x02\x02\x02\xB3\xB4\x03\x02\x02\x02\xB4\xB9\x03\x02\x02\x02\xB5" +
1932
+ "\xB3\x03\x02\x02\x02\xB6\xB8\x05\"\x12\x02\xB7\xB6\x03\x02\x02\x02\xB8" +
1933
+ "\xBB\x03\x02\x02\x02\xB9\xB7\x03\x02\x02\x02\xB9\xBA\x03\x02\x02\x02\xBA" +
1934
+ "\x15\x03\x02\x02\x02\xBB\xB9\x03\x02\x02\x02\xBC\xBE\x05&\x14\x02\xBD" +
1935
+ "\xBC\x03\x02\x02\x02\xBD\xBE\x03\x02\x02\x02\xBE\xC2\x03\x02\x02\x02\xBF" +
1936
+ "\xC1\x07\x17\x02\x02\xC0\xBF\x03\x02\x02\x02\xC1\xC4\x03\x02\x02\x02\xC2" +
1937
+ "\xC0\x03\x02\x02\x02\xC2\xC3\x03\x02\x02\x02\xC3\xC5\x03\x02\x02\x02\xC4" +
1938
+ "\xC2\x03\x02\x02\x02\xC5\xC6\x07\x06\x02\x02\xC6\xD5\x05,\x17\x02\xC7" +
1939
+ "\xC8\x07\x17\x02\x02\xC8\xCA\x05$\x13\x02\xC9\xCB\x07\x17\x02\x02\xCA" +
1940
+ "\xC9\x03\x02\x02\x02\xCB\xCC\x03\x02\x02\x02\xCC\xCA\x03\x02\x02\x02\xCC" +
1941
+ "\xCD\x03\x02\x02\x02\xCD\xCF\x03\x02\x02\x02\xCE\xC7\x03\x02\x02\x02\xCE" +
1942
+ "\xCF\x03\x02\x02\x02\xCF\xD6\x03\x02\x02\x02\xD0\xD2\x07\x17\x02\x02\xD1" +
1943
+ "\xD0\x03\x02\x02\x02\xD2\xD3\x03\x02\x02\x02\xD3\xD1\x03\x02\x02\x02\xD3" +
1944
+ "\xD4\x03\x02\x02\x02\xD4\xD6\x03\x02\x02\x02\xD5\xCE\x03\x02\x02\x02\xD5" +
1945
+ "\xD1\x03\x02\x02\x02\xD6\x17\x03\x02\x02\x02\xD7\xD9\x05&\x14\x02\xD8" +
1946
+ "\xD7\x03\x02\x02\x02\xD8\xD9\x03\x02\x02\x02\xD9\xDD\x03\x02\x02\x02\xDA" +
1947
+ "\xDC\x07\x17\x02\x02\xDB\xDA\x03\x02\x02\x02\xDC\xDF\x03\x02\x02\x02\xDD" +
1948
+ "\xDB\x03\x02\x02\x02\xDD\xDE\x03\x02\x02\x02\xDE\xE0\x03\x02\x02\x02\xDF" +
1949
+ "\xDD\x03\x02\x02\x02\xE0\xE1\x07\x07\x02\x02\xE1\xF0\x05,\x17\x02\xE2" +
1950
+ "\xE3\x07\x17\x02\x02\xE3\xE5\x05$\x13\x02\xE4\xE6\x07\x17\x02\x02\xE5" +
1951
+ "\xE4\x03\x02\x02\x02\xE6\xE7\x03\x02\x02\x02\xE7\xE5\x03\x02\x02\x02\xE7" +
1952
+ "\xE8\x03\x02\x02\x02\xE8\xEA\x03\x02\x02\x02\xE9\xE2\x03\x02\x02\x02\xE9" +
1953
+ "\xEA\x03\x02\x02\x02\xEA\xF1\x03\x02\x02\x02\xEB\xED\x07\x17\x02\x02\xEC" +
1954
+ "\xEB\x03\x02\x02\x02\xED\xEE\x03\x02\x02\x02\xEE\xEC\x03\x02\x02\x02\xEE" +
1955
+ "\xEF\x03\x02\x02\x02\xEF\xF1\x03\x02\x02\x02\xF0\xE9\x03\x02\x02\x02\xF0" +
1956
+ "\xEC\x03\x02\x02\x02\xF1\x19\x03\x02\x02\x02\xF2\xF4\x05&\x14\x02\xF3" +
1957
+ "\xF2\x03\x02\x02\x02\xF3\xF4\x03\x02\x02\x02\xF4\xF8\x03\x02\x02\x02\xF5" +
1958
+ "\xF7\x07\x17\x02\x02\xF6\xF5\x03\x02\x02\x02\xF7\xFA\x03\x02\x02\x02\xF8" +
1959
+ "\xF6\x03\x02\x02\x02\xF8\xF9\x03\x02\x02\x02\xF9\xFB\x03\x02\x02\x02\xFA" +
1960
+ "\xF8\x03\x02\x02\x02\xFB\xFC\x07\b\x02\x02\xFC\u010B\x05,\x17\x02\xFD" +
1961
+ "\xFE\x07\x17\x02\x02\xFE\u0100\x05$\x13\x02\xFF\u0101\x07\x17\x02\x02" +
1962
+ "\u0100\xFF\x03\x02\x02\x02\u0101\u0102\x03\x02\x02\x02\u0102\u0100\x03" +
1963
+ "\x02\x02\x02\u0102\u0103\x03\x02\x02\x02\u0103\u0105\x03\x02\x02\x02\u0104" +
1964
+ "\xFD\x03\x02\x02\x02\u0104\u0105\x03\x02\x02\x02\u0105\u010C\x03\x02\x02" +
1965
+ "\x02\u0106\u0108\x07\x17\x02\x02\u0107\u0106\x03\x02\x02\x02\u0108\u0109" +
1966
+ "\x03\x02\x02\x02\u0109\u0107\x03\x02\x02\x02\u0109\u010A\x03\x02\x02\x02" +
1967
+ "\u010A\u010C\x03\x02\x02\x02\u010B\u0104\x03\x02\x02\x02\u010B\u0107\x03" +
1968
+ "\x02\x02\x02\u010C\x1B\x03\x02\x02\x02\u010D\u010F\x05&\x14\x02\u010E" +
1969
+ "\u010D\x03\x02\x02\x02\u010E\u010F\x03\x02\x02\x02\u010F\u0113\x03\x02" +
1970
+ "\x02\x02\u0110\u0112\x07\x17\x02\x02\u0111\u0110\x03\x02\x02\x02\u0112" +
1971
+ "\u0115\x03\x02\x02\x02\u0113\u0111\x03\x02\x02\x02\u0113\u0114\x03\x02" +
1972
+ "\x02\x02\u0114\u0116\x03\x02\x02\x02\u0115\u0113\x03\x02\x02\x02\u0116" +
1973
+ "\u0117\x07\t\x02\x02\u0117\u0126\x05,\x17\x02\u0118\u0119\x07\x17\x02" +
1974
+ "\x02\u0119\u011B\x05$\x13\x02\u011A\u011C\x07\x17\x02\x02\u011B\u011A" +
1975
+ "\x03\x02\x02\x02\u011C\u011D\x03\x02\x02\x02\u011D\u011B\x03\x02\x02\x02" +
1976
+ "\u011D\u011E\x03\x02\x02\x02\u011E\u0120\x03\x02\x02\x02\u011F\u0118\x03" +
1977
+ "\x02\x02\x02\u011F\u0120\x03\x02\x02\x02\u0120\u0127\x03\x02\x02\x02\u0121" +
1978
+ "\u0123\x07\x17\x02\x02\u0122\u0121\x03\x02\x02\x02\u0123\u0124\x03\x02" +
1979
+ "\x02\x02\u0124\u0122\x03\x02\x02\x02\u0124\u0125\x03\x02\x02\x02\u0125" +
1980
+ "\u0127\x03\x02\x02\x02\u0126\u011F\x03\x02\x02\x02\u0126\u0122\x03\x02" +
1981
+ "\x02\x02\u0127\x1D\x03\x02\x02\x02\u0128\u012A\x05(\x15\x02\u0129\u0128" +
1982
+ "\x03\x02\x02\x02\u0129\u012A\x03\x02\x02\x02\u012A\u012E\x03\x02\x02\x02" +
1983
+ "\u012B\u012D\x07\x17\x02\x02\u012C\u012B\x03\x02\x02\x02\u012D\u0130\x03" +
1984
+ "\x02\x02\x02\u012E\u012C\x03\x02\x02\x02\u012E\u012F\x03\x02\x02\x02\u012F" +
1985
+ "\u0131\x03\x02\x02\x02\u0130\u012E\x03\x02\x02\x02\u0131\u0132\x07\n\x02" +
1986
+ "\x02\u0132\u0141\x05,\x17\x02\u0133\u0134\x07\x17\x02\x02\u0134\u0136" +
1987
+ "\x05$\x13\x02\u0135\u0137\x07\x17\x02\x02\u0136\u0135\x03\x02\x02\x02" +
1988
+ "\u0137\u0138\x03\x02\x02\x02\u0138\u0136\x03\x02\x02\x02\u0138\u0139\x03" +
1989
+ "\x02\x02\x02\u0139\u013B\x03\x02\x02\x02\u013A\u0133\x03\x02\x02\x02\u013A" +
1990
+ "\u013B\x03\x02\x02\x02\u013B\u0142\x03\x02\x02\x02\u013C\u013E\x07\x17" +
1991
+ "\x02\x02\u013D\u013C\x03\x02\x02\x02\u013E\u013F\x03\x02\x02\x02\u013F" +
1992
+ "\u013D\x03\x02\x02\x02\u013F\u0140\x03\x02\x02\x02\u0140\u0142\x03\x02" +
1993
+ "\x02\x02\u0141\u013A\x03\x02\x02\x02\u0141\u013D\x03\x02\x02\x02\u0142" +
1994
+ "\x1F\x03\x02\x02\x02\u0143\u0145\x05(\x15\x02\u0144\u0143\x03\x02\x02" +
1995
+ "\x02\u0144\u0145\x03\x02\x02\x02\u0145\u0149\x03\x02\x02\x02\u0146\u0148" +
1996
+ "\x07\x17\x02\x02\u0147\u0146\x03\x02\x02\x02\u0148\u014B\x03\x02\x02\x02" +
1997
+ "\u0149\u0147\x03\x02\x02\x02\u0149\u014A\x03\x02\x02\x02\u014A\u014C\x03" +
1998
+ "\x02\x02\x02\u014B\u0149\x03\x02\x02\x02\u014C\u014D\x07\v\x02\x02\u014D" +
1999
+ "\u015C\x05,\x17\x02\u014E\u014F\x07\x17\x02\x02\u014F\u0151\x05$\x13\x02" +
2000
+ "\u0150\u0152\x07\x17\x02\x02\u0151\u0150\x03\x02\x02\x02\u0152\u0153\x03" +
2001
+ "\x02\x02\x02\u0153\u0151\x03\x02\x02\x02\u0153\u0154\x03\x02\x02\x02\u0154" +
2002
+ "\u0156\x03\x02\x02\x02\u0155\u014E\x03\x02\x02\x02\u0155\u0156\x03\x02" +
2003
+ "\x02\x02\u0156\u015D\x03\x02\x02\x02\u0157\u0159\x07\x17\x02\x02\u0158" +
2004
+ "\u0157\x03\x02\x02\x02\u0159\u015A\x03\x02\x02\x02\u015A\u0158\x03\x02" +
2005
+ "\x02\x02\u015A\u015B\x03\x02\x02\x02\u015B\u015D\x03\x02\x02\x02\u015C" +
2006
+ "\u0155\x03\x02\x02\x02\u015C\u0158\x03\x02\x02\x02\u015D!\x03\x02\x02" +
2007
+ "\x02\u015E\u0160\x05(\x15\x02\u015F\u015E\x03\x02\x02\x02\u015F\u0160" +
2008
+ "\x03\x02\x02\x02\u0160\u0164\x03\x02\x02\x02\u0161\u0163\x07\x17\x02\x02" +
2009
+ "\u0162\u0161\x03\x02\x02\x02\u0163\u0166\x03\x02\x02\x02\u0164\u0162\x03" +
2010
+ "\x02\x02\x02\u0164\u0165\x03\x02\x02\x02\u0165\u0167\x03\x02\x02\x02\u0166" +
2011
+ "\u0164\x03\x02\x02\x02\u0167\u0168\x07\f\x02\x02\u0168\u0177\x05,\x17" +
2012
+ "\x02\u0169\u016A\x07\x17\x02\x02\u016A\u016C\x05$\x13\x02\u016B\u016D" +
2013
+ "\x07\x17\x02\x02\u016C\u016B\x03\x02\x02\x02\u016D\u016E\x03\x02\x02\x02" +
2014
+ "\u016E\u016C\x03\x02\x02\x02\u016E\u016F\x03\x02\x02\x02\u016F\u0171\x03" +
2015
+ "\x02\x02\x02\u0170\u0169\x03\x02\x02\x02\u0170\u0171\x03\x02\x02\x02\u0171" +
2016
+ "\u0178\x03\x02\x02\x02\u0172\u0174\x07\x17\x02\x02\u0173\u0172\x03\x02" +
2017
+ "\x02\x02\u0174\u0175\x03\x02\x02\x02\u0175\u0173\x03\x02\x02\x02\u0175" +
2018
+ "\u0176\x03\x02\x02\x02\u0176\u0178\x03\x02\x02\x02\u0177\u0170\x03\x02" +
2019
+ "\x02\x02\u0177\u0173\x03\x02\x02\x02\u0178#\x03\x02\x02\x02\u0179\u017A" +
2020
+ "\x07\x19\x02\x02\u017A%\x03\x02\x02\x02\u017B\u017D\x07\x17\x02\x02\u017C" +
2021
+ "\u017B\x03\x02\x02\x02\u017D\u0180\x03\x02\x02\x02\u017E\u017C\x03\x02" +
2022
+ "\x02\x02\u017E\u017F\x03\x02\x02\x02\u017F\u0188\x03\x02\x02\x02\u0180" +
2023
+ "\u017E\x03\x02\x02\x02\u0181\u0185\t\x02\x02\x02\u0182\u0184\x07\x17\x02" +
2024
+ "\x02\u0183\u0182\x03\x02\x02\x02\u0184\u0187\x03\x02\x02\x02\u0185\u0183" +
2025
+ "\x03\x02\x02\x02\u0185\u0186\x03\x02\x02\x02\u0186\u0189\x03\x02\x02\x02" +
2026
+ "\u0187\u0185\x03\x02\x02\x02\u0188\u0181\x03\x02\x02\x02\u0189\u018A\x03" +
2027
+ "\x02\x02\x02\u018A\u0188\x03\x02\x02\x02\u018A\u018B\x03\x02\x02\x02\u018B" +
2028
+ "\'\x03\x02\x02\x02\u018C\u018E\x07\x17\x02\x02\u018D\u018C\x03\x02\x02" +
2029
+ "\x02\u018E\u0191\x03\x02\x02\x02\u018F\u018D\x03\x02\x02\x02\u018F\u0190" +
2030
+ "\x03\x02\x02\x02\u0190\u0199\x03\x02\x02\x02\u0191\u018F\x03\x02\x02\x02" +
2031
+ "\u0192\u0196\t\x03\x02\x02\u0193\u0195\x07\x17\x02\x02\u0194\u0193\x03" +
2032
+ "\x02\x02\x02\u0195\u0198\x03\x02\x02\x02\u0196\u0194\x03\x02\x02\x02\u0196" +
2033
+ "\u0197\x03\x02\x02\x02\u0197\u019A\x03\x02\x02\x02\u0198\u0196\x03\x02" +
2034
+ "\x02\x02\u0199\u0192\x03\x02\x02\x02\u019A\u019B\x03\x02\x02\x02\u019B" +
2035
+ "\u0199\x03\x02\x02\x02\u019B\u019C\x03\x02\x02\x02\u019C)\x03\x02\x02" +
2036
+ "\x02\u019D\u019F\x07\x16\x02\x02\u019E\u019D\x03\x02\x02\x02\u019F\u01A0" +
2037
+ "\x03\x02\x02\x02\u01A0\u019E\x03\x02\x02\x02\u01A0\u01A1\x03\x02\x02\x02" +
2038
+ "\u01A1+\x03\x02\x02\x02\u01A2\u01A4\t\x04\x02\x02\u01A3\u01A2\x03\x02" +
2039
+ "\x02\x02\u01A4\u01A5\x03\x02\x02\x02\u01A5\u01A3\x03\x02\x02\x02\u01A5" +
2040
+ "\u01A6\x03\x02\x02\x02\u01A6-\x03\x02\x02\x02K17=BFHNRW`diqv\x81\x88\x8E" +
2041
+ "\x98\x9F\xA5\xAC\xB3\xB9\xBD\xC2\xCC\xCE\xD3\xD5\xD8\xDD\xE7\xE9\xEE\xF0" +
2042
+ "\xF3\xF8\u0102\u0104\u0109\u010B\u010E\u0113\u011D\u011F\u0124\u0126\u0129" +
2043
+ "\u012E\u0138\u013A\u013F\u0141\u0144\u0149\u0153\u0155\u015A\u015C\u015F" +
2044
+ "\u0164\u016E\u0170\u0175\u0177\u017E\u0185\u018A\u018F\u0196\u019B\u01A0" +
2045
+ "\u01A5";
1195
2046
  class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
2047
+ EOF() { return this.getToken(GherkinParser.EOF, 0); }
1196
2048
  feature(i) {
1197
2049
  if (i === undefined) {
1198
2050
  return this.getRuleContexts(FeatureContext);
@@ -1201,6 +2053,14 @@ class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
1201
2053
  return this.getRuleContext(i, FeatureContext);
1202
2054
  }
1203
2055
  }
2056
+ NEWLINE(i) {
2057
+ if (i === undefined) {
2058
+ return this.getTokens(GherkinParser.NEWLINE);
2059
+ }
2060
+ else {
2061
+ return this.getToken(GherkinParser.NEWLINE, i);
2062
+ }
2063
+ }
1204
2064
  constructor(parent, invokingState) {
1205
2065
  super(parent, invokingState);
1206
2066
  }
@@ -1219,8 +2079,11 @@ class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
1219
2079
  exports.FeatureFileContext = FeatureFileContext;
1220
2080
  class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
1221
2081
  FEATURE() { return this.getToken(GherkinParser.FEATURE, 0); }
1222
- contentText() {
1223
- return this.getRuleContext(0, ContentTextContext);
2082
+ multilineText() {
2083
+ return this.getRuleContext(0, MultilineTextContext);
2084
+ }
2085
+ tags() {
2086
+ return this.tryGetRuleContext(0, TagsContext);
1224
2087
  }
1225
2088
  background() {
1226
2089
  return this.tryGetRuleContext(0, BackgroundContext);
@@ -1241,6 +2104,14 @@ class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
1241
2104
  return this.getRuleContext(i, ScenarioOutlineContext);
1242
2105
  }
1243
2106
  }
2107
+ NEWLINE(i) {
2108
+ if (i === undefined) {
2109
+ return this.getTokens(GherkinParser.NEWLINE);
2110
+ }
2111
+ else {
2112
+ return this.getToken(GherkinParser.NEWLINE, i);
2113
+ }
2114
+ }
1244
2115
  constructor(parent, invokingState) {
1245
2116
  super(parent, invokingState);
1246
2117
  }
@@ -1259,8 +2130,8 @@ class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
1259
2130
  exports.FeatureContext = FeatureContext;
1260
2131
  class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1261
2132
  BACKGROUND() { return this.getToken(GherkinParser.BACKGROUND, 0); }
1262
- contentText() {
1263
- return this.getRuleContext(0, ContentTextContext);
2133
+ multilineText() {
2134
+ return this.getRuleContext(0, MultilineTextContext);
1264
2135
  }
1265
2136
  givenStep() {
1266
2137
  return this.getRuleContext(0, GivenStepContext);
@@ -1268,28 +2139,20 @@ class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1268
2139
  tags() {
1269
2140
  return this.tryGetRuleContext(0, TagsContext);
1270
2141
  }
1271
- andGivenStep(i) {
1272
- if (i === undefined) {
1273
- return this.getRuleContexts(AndGivenStepContext);
1274
- }
1275
- else {
1276
- return this.getRuleContext(i, AndGivenStepContext);
1277
- }
1278
- }
1279
- scenario(i) {
2142
+ NEWLINE(i) {
1280
2143
  if (i === undefined) {
1281
- return this.getRuleContexts(ScenarioContext);
2144
+ return this.getTokens(GherkinParser.NEWLINE);
1282
2145
  }
1283
2146
  else {
1284
- return this.getRuleContext(i, ScenarioContext);
2147
+ return this.getToken(GherkinParser.NEWLINE, i);
1285
2148
  }
1286
2149
  }
1287
- scenarioOutline(i) {
2150
+ andGivenStep(i) {
1288
2151
  if (i === undefined) {
1289
- return this.getRuleContexts(ScenarioOutlineContext);
2152
+ return this.getRuleContexts(AndGivenStepContext);
1290
2153
  }
1291
2154
  else {
1292
- return this.getRuleContext(i, ScenarioOutlineContext);
2155
+ return this.getRuleContext(i, AndGivenStepContext);
1293
2156
  }
1294
2157
  }
1295
2158
  constructor(parent, invokingState) {
@@ -1310,8 +2173,8 @@ class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1310
2173
  exports.BackgroundContext = BackgroundContext;
1311
2174
  class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1312
2175
  SCENARIO() { return this.getToken(GherkinParser.SCENARIO, 0); }
1313
- contentText() {
1314
- return this.getRuleContext(0, ContentTextContext);
2176
+ multilineText() {
2177
+ return this.getRuleContext(0, MultilineTextContext);
1315
2178
  }
1316
2179
  step() {
1317
2180
  return this.getRuleContext(0, StepContext);
@@ -1319,6 +2182,14 @@ class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1319
2182
  tags() {
1320
2183
  return this.tryGetRuleContext(0, TagsContext);
1321
2184
  }
2185
+ NEWLINE(i) {
2186
+ if (i === undefined) {
2187
+ return this.getTokens(GherkinParser.NEWLINE);
2188
+ }
2189
+ else {
2190
+ return this.getToken(GherkinParser.NEWLINE, i);
2191
+ }
2192
+ }
1322
2193
  constructor(parent, invokingState) {
1323
2194
  super(parent, invokingState);
1324
2195
  }
@@ -1337,8 +2208,8 @@ class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1337
2208
  exports.ScenarioContext = ScenarioContext;
1338
2209
  class ScenarioOutlineContext extends ParserRuleContext_1.ParserRuleContext {
1339
2210
  SCENARIO_OUTLINE() { return this.getToken(GherkinParser.SCENARIO_OUTLINE, 0); }
1340
- contentText() {
1341
- return this.getRuleContext(0, ContentTextContext);
2211
+ multilineText() {
2212
+ return this.getRuleContext(0, MultilineTextContext);
1342
2213
  }
1343
2214
  step() {
1344
2215
  return this.getRuleContext(0, StepContext);
@@ -1349,6 +2220,14 @@ class ScenarioOutlineContext extends ParserRuleContext_1.ParserRuleContext {
1349
2220
  tags() {
1350
2221
  return this.tryGetRuleContext(0, TagsContext);
1351
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
+ }
1352
2231
  constructor(parent, invokingState) {
1353
2232
  super(parent, invokingState);
1354
2233
  }
@@ -1370,6 +2249,14 @@ class ExamplesBlockContext extends ParserRuleContext_1.ParserRuleContext {
1370
2249
  tableHeader() {
1371
2250
  return this.getRuleContext(0, TableHeaderContext);
1372
2251
  }
2252
+ NEWLINE(i) {
2253
+ if (i === undefined) {
2254
+ return this.getTokens(GherkinParser.NEWLINE);
2255
+ }
2256
+ else {
2257
+ return this.getToken(GherkinParser.NEWLINE, i);
2258
+ }
2259
+ }
1373
2260
  tableRow(i) {
1374
2261
  if (i === undefined) {
1375
2262
  return this.getRuleContexts(TableRowContext);
@@ -1431,6 +2318,7 @@ class TableRowContext extends ParserRuleContext_1.ParserRuleContext {
1431
2318
  return this.getRuleContext(i, CellContext);
1432
2319
  }
1433
2320
  }
2321
+ NEWLINE() { return this.getToken(GherkinParser.NEWLINE, 0); }
1434
2322
  constructor(parent, invokingState) {
1435
2323
  super(parent, invokingState);
1436
2324
  }
@@ -1449,7 +2337,7 @@ class TableRowContext extends ParserRuleContext_1.ParserRuleContext {
1449
2337
  exports.TableRowContext = TableRowContext;
1450
2338
  class CellContext extends ParserRuleContext_1.ParserRuleContext {
1451
2339
  contentText() {
1452
- return this.getRuleContext(0, ContentTextContext);
2340
+ return this.tryGetRuleContext(0, ContentTextContext);
1453
2341
  }
1454
2342
  constructor(parent, invokingState) {
1455
2343
  super(parent, invokingState);
@@ -1527,12 +2415,20 @@ class StepContext extends ParserRuleContext_1.ParserRuleContext {
1527
2415
  exports.StepContext = StepContext;
1528
2416
  class GivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1529
2417
  GIVEN() { return this.getToken(GherkinParser.GIVEN, 0); }
1530
- contentText() {
1531
- return this.getRuleContext(0, ContentTextContext);
2418
+ multilineText() {
2419
+ return this.getRuleContext(0, MultilineTextContext);
1532
2420
  }
1533
2421
  tags() {
1534
2422
  return this.tryGetRuleContext(0, TagsContext);
1535
2423
  }
2424
+ NEWLINE(i) {
2425
+ if (i === undefined) {
2426
+ return this.getTokens(GherkinParser.NEWLINE);
2427
+ }
2428
+ else {
2429
+ return this.getToken(GherkinParser.NEWLINE, i);
2430
+ }
2431
+ }
1536
2432
  docString() {
1537
2433
  return this.tryGetRuleContext(0, DocStringContext);
1538
2434
  }
@@ -1554,12 +2450,20 @@ class GivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1554
2450
  exports.GivenStepContext = GivenStepContext;
1555
2451
  class AndGivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1556
2452
  AND_GIVEN() { return this.getToken(GherkinParser.AND_GIVEN, 0); }
1557
- contentText() {
1558
- return this.getRuleContext(0, ContentTextContext);
2453
+ multilineText() {
2454
+ return this.getRuleContext(0, MultilineTextContext);
1559
2455
  }
1560
2456
  tags() {
1561
2457
  return this.tryGetRuleContext(0, TagsContext);
1562
2458
  }
2459
+ NEWLINE(i) {
2460
+ if (i === undefined) {
2461
+ return this.getTokens(GherkinParser.NEWLINE);
2462
+ }
2463
+ else {
2464
+ return this.getToken(GherkinParser.NEWLINE, i);
2465
+ }
2466
+ }
1563
2467
  docString() {
1564
2468
  return this.tryGetRuleContext(0, DocStringContext);
1565
2469
  }
@@ -1581,12 +2485,20 @@ class AndGivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1581
2485
  exports.AndGivenStepContext = AndGivenStepContext;
1582
2486
  class WhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1583
2487
  WHEN() { return this.getToken(GherkinParser.WHEN, 0); }
1584
- contentText() {
1585
- return this.getRuleContext(0, ContentTextContext);
2488
+ multilineText() {
2489
+ return this.getRuleContext(0, MultilineTextContext);
1586
2490
  }
1587
2491
  tags() {
1588
2492
  return this.tryGetRuleContext(0, TagsContext);
1589
2493
  }
2494
+ NEWLINE(i) {
2495
+ if (i === undefined) {
2496
+ return this.getTokens(GherkinParser.NEWLINE);
2497
+ }
2498
+ else {
2499
+ return this.getToken(GherkinParser.NEWLINE, i);
2500
+ }
2501
+ }
1590
2502
  docString() {
1591
2503
  return this.tryGetRuleContext(0, DocStringContext);
1592
2504
  }
@@ -1608,12 +2520,20 @@ class WhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1608
2520
  exports.WhenStepContext = WhenStepContext;
1609
2521
  class AndWhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1610
2522
  AND_WHEN() { return this.getToken(GherkinParser.AND_WHEN, 0); }
1611
- contentText() {
1612
- return this.getRuleContext(0, ContentTextContext);
2523
+ multilineText() {
2524
+ return this.getRuleContext(0, MultilineTextContext);
1613
2525
  }
1614
2526
  tags() {
1615
2527
  return this.tryGetRuleContext(0, TagsContext);
1616
2528
  }
2529
+ NEWLINE(i) {
2530
+ if (i === undefined) {
2531
+ return this.getTokens(GherkinParser.NEWLINE);
2532
+ }
2533
+ else {
2534
+ return this.getToken(GherkinParser.NEWLINE, i);
2535
+ }
2536
+ }
1617
2537
  docString() {
1618
2538
  return this.tryGetRuleContext(0, DocStringContext);
1619
2539
  }
@@ -1635,11 +2555,19 @@ class AndWhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1635
2555
  exports.AndWhenStepContext = AndWhenStepContext;
1636
2556
  class ThenStepContext extends ParserRuleContext_1.ParserRuleContext {
1637
2557
  THEN() { return this.getToken(GherkinParser.THEN, 0); }
1638
- contentText() {
1639
- return this.getRuleContext(0, ContentTextContext);
2558
+ multilineText() {
2559
+ return this.getRuleContext(0, MultilineTextContext);
1640
2560
  }
1641
- tags() {
1642
- return this.tryGetRuleContext(0, TagsContext);
2561
+ thenTags() {
2562
+ return this.tryGetRuleContext(0, ThenTagsContext);
2563
+ }
2564
+ NEWLINE(i) {
2565
+ if (i === undefined) {
2566
+ return this.getTokens(GherkinParser.NEWLINE);
2567
+ }
2568
+ else {
2569
+ return this.getToken(GherkinParser.NEWLINE, i);
2570
+ }
1643
2571
  }
1644
2572
  docString() {
1645
2573
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1662,11 +2590,19 @@ class ThenStepContext extends ParserRuleContext_1.ParserRuleContext {
1662
2590
  exports.ThenStepContext = ThenStepContext;
1663
2591
  class AndStepContext extends ParserRuleContext_1.ParserRuleContext {
1664
2592
  AND() { return this.getToken(GherkinParser.AND, 0); }
1665
- contentText() {
1666
- return this.getRuleContext(0, ContentTextContext);
2593
+ multilineText() {
2594
+ return this.getRuleContext(0, MultilineTextContext);
1667
2595
  }
1668
- tags() {
1669
- return this.tryGetRuleContext(0, TagsContext);
2596
+ thenTags() {
2597
+ return this.tryGetRuleContext(0, ThenTagsContext);
2598
+ }
2599
+ NEWLINE(i) {
2600
+ if (i === undefined) {
2601
+ return this.getTokens(GherkinParser.NEWLINE);
2602
+ }
2603
+ else {
2604
+ return this.getToken(GherkinParser.NEWLINE, i);
2605
+ }
1670
2606
  }
1671
2607
  docString() {
1672
2608
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1689,11 +2625,19 @@ class AndStepContext extends ParserRuleContext_1.ParserRuleContext {
1689
2625
  exports.AndStepContext = AndStepContext;
1690
2626
  class ButStepContext extends ParserRuleContext_1.ParserRuleContext {
1691
2627
  BUT() { return this.getToken(GherkinParser.BUT, 0); }
1692
- contentText() {
1693
- return this.getRuleContext(0, ContentTextContext);
2628
+ multilineText() {
2629
+ return this.getRuleContext(0, MultilineTextContext);
1694
2630
  }
1695
- tags() {
1696
- return this.tryGetRuleContext(0, TagsContext);
2631
+ thenTags() {
2632
+ return this.tryGetRuleContext(0, ThenTagsContext);
2633
+ }
2634
+ NEWLINE(i) {
2635
+ if (i === undefined) {
2636
+ return this.getTokens(GherkinParser.NEWLINE);
2637
+ }
2638
+ else {
2639
+ return this.getToken(GherkinParser.NEWLINE, i);
2640
+ }
1697
2641
  }
1698
2642
  docString() {
1699
2643
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1733,6 +2677,14 @@ class DocStringContext extends ParserRuleContext_1.ParserRuleContext {
1733
2677
  }
1734
2678
  exports.DocStringContext = DocStringContext;
1735
2679
  class TagsContext extends ParserRuleContext_1.ParserRuleContext {
2680
+ NEWLINE(i) {
2681
+ if (i === undefined) {
2682
+ return this.getTokens(GherkinParser.NEWLINE);
2683
+ }
2684
+ else {
2685
+ return this.getToken(GherkinParser.NEWLINE, i);
2686
+ }
2687
+ }
1736
2688
  ONLY_TAG(i) {
1737
2689
  if (i === undefined) {
1738
2690
  return this.getTokens(GherkinParser.ONLY_TAG);
@@ -1773,6 +2725,71 @@ class TagsContext extends ParserRuleContext_1.ParserRuleContext {
1773
2725
  }
1774
2726
  }
1775
2727
  exports.TagsContext = TagsContext;
2728
+ class ThenTagsContext extends ParserRuleContext_1.ParserRuleContext {
2729
+ NEWLINE(i) {
2730
+ if (i === undefined) {
2731
+ return this.getTokens(GherkinParser.NEWLINE);
2732
+ }
2733
+ else {
2734
+ return this.getToken(GherkinParser.NEWLINE, i);
2735
+ }
2736
+ }
2737
+ ONLY_TAG(i) {
2738
+ if (i === undefined) {
2739
+ return this.getTokens(GherkinParser.ONLY_TAG);
2740
+ }
2741
+ else {
2742
+ return this.getToken(GherkinParser.ONLY_TAG, i);
2743
+ }
2744
+ }
2745
+ SKIP_TAG(i) {
2746
+ if (i === undefined) {
2747
+ return this.getTokens(GherkinParser.SKIP_TAG);
2748
+ }
2749
+ else {
2750
+ return this.getToken(GherkinParser.SKIP_TAG, i);
2751
+ }
2752
+ }
2753
+ FAIL_TAG(i) {
2754
+ if (i === undefined) {
2755
+ return this.getTokens(GherkinParser.FAIL_TAG);
2756
+ }
2757
+ else {
2758
+ return this.getToken(GherkinParser.FAIL_TAG, i);
2759
+ }
2760
+ }
2761
+ TODO_TAG(i) {
2762
+ if (i === undefined) {
2763
+ return this.getTokens(GherkinParser.TODO_TAG);
2764
+ }
2765
+ else {
2766
+ return this.getToken(GherkinParser.TODO_TAG, i);
2767
+ }
2768
+ }
2769
+ TAG(i) {
2770
+ if (i === undefined) {
2771
+ return this.getTokens(GherkinParser.TAG);
2772
+ }
2773
+ else {
2774
+ return this.getToken(GherkinParser.TAG, i);
2775
+ }
2776
+ }
2777
+ constructor(parent, invokingState) {
2778
+ super(parent, invokingState);
2779
+ }
2780
+ // @Override
2781
+ get ruleIndex() { return GherkinParser.RULE_thenTags; }
2782
+ // @Override
2783
+ accept(visitor) {
2784
+ if (visitor.visitThenTags) {
2785
+ return visitor.visitThenTags(this);
2786
+ }
2787
+ else {
2788
+ return visitor.visitChildren(this);
2789
+ }
2790
+ }
2791
+ }
2792
+ exports.ThenTagsContext = ThenTagsContext;
1776
2793
  class ContentTextContext extends ParserRuleContext_1.ParserRuleContext {
1777
2794
  TEXT_CHARACTER(i) {
1778
2795
  if (i === undefined) {
@@ -1798,4 +2815,37 @@ class ContentTextContext extends ParserRuleContext_1.ParserRuleContext {
1798
2815
  }
1799
2816
  }
1800
2817
  exports.ContentTextContext = ContentTextContext;
2818
+ class MultilineTextContext extends ParserRuleContext_1.ParserRuleContext {
2819
+ TEXT_CHARACTER(i) {
2820
+ if (i === undefined) {
2821
+ return this.getTokens(GherkinParser.TEXT_CHARACTER);
2822
+ }
2823
+ else {
2824
+ return this.getToken(GherkinParser.TEXT_CHARACTER, i);
2825
+ }
2826
+ }
2827
+ NEWLINE(i) {
2828
+ if (i === undefined) {
2829
+ return this.getTokens(GherkinParser.NEWLINE);
2830
+ }
2831
+ else {
2832
+ return this.getToken(GherkinParser.NEWLINE, i);
2833
+ }
2834
+ }
2835
+ constructor(parent, invokingState) {
2836
+ super(parent, invokingState);
2837
+ }
2838
+ // @Override
2839
+ get ruleIndex() { return GherkinParser.RULE_multilineText; }
2840
+ // @Override
2841
+ accept(visitor) {
2842
+ if (visitor.visitMultilineText) {
2843
+ return visitor.visitMultilineText(this);
2844
+ }
2845
+ else {
2846
+ return visitor.visitChildren(this);
2847
+ }
2848
+ }
2849
+ }
2850
+ exports.MultilineTextContext = MultilineTextContext;
1801
2851
  //# sourceMappingURL=GherkinParser.js.map