pickle-jar 1.2.0 → 1.3.1

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 +75 -56
  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 +1528 -453
  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) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.FEATURE) | (1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
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) {
@@ -83,68 +102,87 @@ class GherkinParser extends Parser_1.Parser {
83
102
  let _alt;
84
103
  this.enterOuterAlt(_localctx, 1);
85
104
  {
86
- this.state = 47;
105
+ this.state = 59;
106
+ this._errHandler.sync(this);
107
+ switch (this.interpreter.adaptivePredict(this._input, 2, this._ctx)) {
108
+ case 1:
109
+ {
110
+ this.state = 58;
111
+ this.tags();
112
+ }
113
+ break;
114
+ }
115
+ this.state = 64;
87
116
  this._errHandler.sync(this);
88
117
  _la = this._input.LA(1);
89
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
118
+ while (_la === GherkinParser.NEWLINE) {
90
119
  {
91
- this.state = 46;
92
- this.tags();
120
+ {
121
+ this.state = 61;
122
+ this.match(GherkinParser.NEWLINE);
123
+ }
93
124
  }
125
+ this.state = 66;
126
+ this._errHandler.sync(this);
127
+ _la = this._input.LA(1);
94
128
  }
95
- this.state = 49;
129
+ this.state = 67;
96
130
  this.match(GherkinParser.FEATURE);
97
- this.state = 50;
98
- this.contentText();
99
- this.state = 61;
131
+ this.state = 68;
132
+ this.multilineText();
133
+ this.state = 70;
100
134
  this._errHandler.sync(this);
101
- switch (this.interpreter.adaptivePredict(this._input, 5, this._ctx)) {
135
+ switch (this.interpreter.adaptivePredict(this._input, 4, this._ctx)) {
102
136
  case 1:
103
137
  {
104
- this.state = 52;
138
+ this.state = 69;
139
+ this.background();
140
+ }
141
+ break;
142
+ }
143
+ this.state = 76;
144
+ this._errHandler.sync(this);
145
+ _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
146
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
147
+ if (_alt === 1) {
148
+ {
149
+ this.state = 74;
105
150
  this._errHandler.sync(this);
106
- switch (this.interpreter.adaptivePredict(this._input, 2, this._ctx)) {
151
+ switch (this.interpreter.adaptivePredict(this._input, 5, this._ctx)) {
107
152
  case 1:
108
153
  {
109
- this.state = 51;
110
- this.background();
154
+ this.state = 72;
155
+ this.scenario();
156
+ }
157
+ break;
158
+ case 2:
159
+ {
160
+ this.state = 73;
161
+ this.scenarioOutline();
111
162
  }
112
163
  break;
113
164
  }
114
165
  }
115
- break;
116
- case 2:
166
+ }
167
+ this.state = 78;
168
+ this._errHandler.sync(this);
169
+ _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx);
170
+ }
171
+ this.state = 82;
172
+ this._errHandler.sync(this);
173
+ _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
174
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
175
+ if (_alt === 1) {
117
176
  {
118
- this.state = 58;
119
- this._errHandler.sync(this);
120
- _alt = this.interpreter.adaptivePredict(this._input, 4, this._ctx);
121
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
122
- if (_alt === 1) {
123
- {
124
- this.state = 56;
125
- this._errHandler.sync(this);
126
- switch (this.interpreter.adaptivePredict(this._input, 3, this._ctx)) {
127
- case 1:
128
- {
129
- this.state = 54;
130
- this.scenario();
131
- }
132
- break;
133
- case 2:
134
- {
135
- this.state = 55;
136
- this.scenarioOutline();
137
- }
138
- break;
139
- }
140
- }
141
- }
142
- this.state = 60;
143
- this._errHandler.sync(this);
144
- _alt = this.interpreter.adaptivePredict(this._input, 4, this._ctx);
177
+ {
178
+ this.state = 79;
179
+ this.match(GherkinParser.NEWLINE);
145
180
  }
146
181
  }
147
- break;
182
+ }
183
+ this.state = 84;
184
+ this._errHandler.sync(this);
185
+ _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
148
186
  }
149
187
  }
150
188
  }
@@ -172,64 +210,51 @@ class GherkinParser extends Parser_1.Parser {
172
210
  let _alt;
173
211
  this.enterOuterAlt(_localctx, 1);
174
212
  {
175
- this.state = 64;
213
+ this.state = 86;
214
+ this._errHandler.sync(this);
215
+ switch (this.interpreter.adaptivePredict(this._input, 8, this._ctx)) {
216
+ case 1:
217
+ {
218
+ this.state = 85;
219
+ this.tags();
220
+ }
221
+ break;
222
+ }
223
+ this.state = 91;
176
224
  this._errHandler.sync(this);
177
225
  _la = this._input.LA(1);
178
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
226
+ while (_la === GherkinParser.NEWLINE) {
179
227
  {
180
- this.state = 63;
181
- this.tags();
228
+ {
229
+ this.state = 88;
230
+ this.match(GherkinParser.NEWLINE);
231
+ }
182
232
  }
233
+ this.state = 93;
234
+ this._errHandler.sync(this);
235
+ _la = this._input.LA(1);
183
236
  }
184
- this.state = 66;
237
+ this.state = 94;
185
238
  this.match(GherkinParser.BACKGROUND);
186
- this.state = 67;
187
- this.contentText();
188
- this.state = 68;
239
+ this.state = 95;
240
+ this.multilineText();
241
+ this.state = 96;
189
242
  this.givenStep();
190
- this.state = 72;
243
+ this.state = 100;
191
244
  this._errHandler.sync(this);
192
- _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
245
+ _alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
193
246
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
194
247
  if (_alt === 1) {
195
248
  {
196
249
  {
197
- this.state = 69;
250
+ this.state = 97;
198
251
  this.andGivenStep();
199
252
  }
200
253
  }
201
254
  }
202
- this.state = 74;
203
- this._errHandler.sync(this);
204
- _alt = this.interpreter.adaptivePredict(this._input, 7, this._ctx);
205
- }
206
- this.state = 79;
207
- this._errHandler.sync(this);
208
- _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
209
- while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
210
- if (_alt === 1) {
211
- {
212
- this.state = 77;
213
- this._errHandler.sync(this);
214
- switch (this.interpreter.adaptivePredict(this._input, 8, this._ctx)) {
215
- case 1:
216
- {
217
- this.state = 75;
218
- this.scenario();
219
- }
220
- break;
221
- case 2:
222
- {
223
- this.state = 76;
224
- this.scenarioOutline();
225
- }
226
- break;
227
- }
228
- }
229
- }
230
- this.state = 81;
255
+ this.state = 102;
231
256
  this._errHandler.sync(this);
232
- _alt = this.interpreter.adaptivePredict(this._input, 9, this._ctx);
257
+ _alt = this.interpreter.adaptivePredict(this._input, 10, this._ctx);
233
258
  }
234
259
  }
235
260
  }
@@ -256,20 +281,35 @@ class GherkinParser extends Parser_1.Parser {
256
281
  try {
257
282
  this.enterOuterAlt(_localctx, 1);
258
283
  {
259
- this.state = 83;
284
+ this.state = 104;
285
+ this._errHandler.sync(this);
286
+ switch (this.interpreter.adaptivePredict(this._input, 11, this._ctx)) {
287
+ case 1:
288
+ {
289
+ this.state = 103;
290
+ this.tags();
291
+ }
292
+ break;
293
+ }
294
+ this.state = 109;
260
295
  this._errHandler.sync(this);
261
296
  _la = this._input.LA(1);
262
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
297
+ while (_la === GherkinParser.NEWLINE) {
263
298
  {
264
- this.state = 82;
265
- this.tags();
299
+ {
300
+ this.state = 106;
301
+ this.match(GherkinParser.NEWLINE);
302
+ }
266
303
  }
304
+ this.state = 111;
305
+ this._errHandler.sync(this);
306
+ _la = this._input.LA(1);
267
307
  }
268
- this.state = 85;
308
+ this.state = 112;
269
309
  this.match(GherkinParser.SCENARIO);
270
- this.state = 86;
271
- this.contentText();
272
- this.state = 87;
310
+ this.state = 113;
311
+ this.multilineText();
312
+ this.state = 114;
273
313
  this.step();
274
314
  }
275
315
  }
@@ -296,22 +336,37 @@ class GherkinParser extends Parser_1.Parser {
296
336
  try {
297
337
  this.enterOuterAlt(_localctx, 1);
298
338
  {
299
- this.state = 90;
339
+ this.state = 117;
340
+ this._errHandler.sync(this);
341
+ switch (this.interpreter.adaptivePredict(this._input, 13, this._ctx)) {
342
+ case 1:
343
+ {
344
+ this.state = 116;
345
+ this.tags();
346
+ }
347
+ break;
348
+ }
349
+ this.state = 122;
300
350
  this._errHandler.sync(this);
301
351
  _la = this._input.LA(1);
302
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
352
+ while (_la === GherkinParser.NEWLINE) {
303
353
  {
304
- this.state = 89;
305
- this.tags();
354
+ {
355
+ this.state = 119;
356
+ this.match(GherkinParser.NEWLINE);
357
+ }
306
358
  }
359
+ this.state = 124;
360
+ this._errHandler.sync(this);
361
+ _la = this._input.LA(1);
307
362
  }
308
- this.state = 92;
363
+ this.state = 125;
309
364
  this.match(GherkinParser.SCENARIO_OUTLINE);
310
- this.state = 93;
311
- this.contentText();
312
- this.state = 94;
365
+ this.state = 126;
366
+ this.multilineText();
367
+ this.state = 127;
313
368
  this.step();
314
- this.state = 95;
369
+ this.state = 128;
315
370
  this.examplesBlock();
316
371
  }
317
372
  }
@@ -338,21 +393,49 @@ class GherkinParser extends Parser_1.Parser {
338
393
  try {
339
394
  this.enterOuterAlt(_localctx, 1);
340
395
  {
341
- this.state = 97;
396
+ this.state = 133;
397
+ this._errHandler.sync(this);
398
+ _la = this._input.LA(1);
399
+ while (_la === GherkinParser.NEWLINE) {
400
+ {
401
+ {
402
+ this.state = 130;
403
+ this.match(GherkinParser.NEWLINE);
404
+ }
405
+ }
406
+ this.state = 135;
407
+ this._errHandler.sync(this);
408
+ _la = this._input.LA(1);
409
+ }
410
+ this.state = 136;
342
411
  this.match(GherkinParser.EXAMPLES);
343
- this.state = 98;
412
+ this.state = 138;
413
+ this._errHandler.sync(this);
414
+ _la = this._input.LA(1);
415
+ do {
416
+ {
417
+ {
418
+ this.state = 137;
419
+ this.match(GherkinParser.NEWLINE);
420
+ }
421
+ }
422
+ this.state = 140;
423
+ this._errHandler.sync(this);
424
+ _la = this._input.LA(1);
425
+ } while (_la === GherkinParser.NEWLINE);
426
+ this.state = 142;
344
427
  this.tableHeader();
345
- this.state = 100;
428
+ this.state = 144;
346
429
  this._errHandler.sync(this);
347
430
  _la = this._input.LA(1);
348
431
  do {
349
432
  {
350
433
  {
351
- this.state = 99;
434
+ this.state = 143;
352
435
  this.tableRow();
353
436
  }
354
437
  }
355
- this.state = 102;
438
+ this.state = 146;
356
439
  this._errHandler.sync(this);
357
440
  _la = this._input.LA(1);
358
441
  } while (_la === GherkinParser.PIPE);
@@ -380,7 +463,7 @@ class GherkinParser extends Parser_1.Parser {
380
463
  try {
381
464
  this.enterOuterAlt(_localctx, 1);
382
465
  {
383
- this.state = 104;
466
+ this.state = 148;
384
467
  this.tableRow();
385
468
  }
386
469
  }
@@ -403,59 +486,54 @@ class GherkinParser extends Parser_1.Parser {
403
486
  tableRow() {
404
487
  let _localctx = new TableRowContext(this._ctx, this.state);
405
488
  this.enterRule(_localctx, 14, GherkinParser.RULE_tableRow);
406
- let _la;
407
489
  try {
408
490
  let _alt;
409
491
  this.enterOuterAlt(_localctx, 1);
410
492
  {
411
- this.state = 106;
493
+ this.state = 150;
412
494
  this.match(GherkinParser.PIPE);
413
- this.state = 108;
414
- this._errHandler.sync(this);
415
- _la = this._input.LA(1);
416
- do {
417
- {
418
- {
419
- this.state = 107;
420
- this.cell();
421
- }
422
- }
423
- this.state = 110;
424
- this._errHandler.sync(this);
425
- _la = this._input.LA(1);
426
- } while (_la === GherkinParser.TEXT_CHARACTER);
427
- this.state = 120;
495
+ this.state = 151;
496
+ this.cell();
497
+ this.state = 156;
428
498
  this._errHandler.sync(this);
429
- _alt = this.interpreter.adaptivePredict(this._input, 15, this._ctx);
499
+ _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
430
500
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
431
501
  if (_alt === 1) {
432
502
  {
433
503
  {
434
- this.state = 112;
504
+ this.state = 152;
435
505
  this.match(GherkinParser.PIPE);
436
- this.state = 114;
437
- this._errHandler.sync(this);
438
- _la = this._input.LA(1);
439
- do {
440
- {
441
- {
442
- this.state = 113;
443
- this.cell();
444
- }
445
- }
446
- this.state = 116;
447
- this._errHandler.sync(this);
448
- _la = this._input.LA(1);
449
- } while (_la === GherkinParser.TEXT_CHARACTER);
506
+ this.state = 153;
507
+ this.cell();
450
508
  }
451
509
  }
452
510
  }
453
- this.state = 122;
511
+ this.state = 158;
454
512
  this._errHandler.sync(this);
455
- _alt = this.interpreter.adaptivePredict(this._input, 15, this._ctx);
513
+ _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
456
514
  }
457
- this.state = 123;
515
+ this.state = 159;
458
516
  this.match(GherkinParser.PIPE);
517
+ this.state = 161;
518
+ this._errHandler.sync(this);
519
+ _alt = 1;
520
+ do {
521
+ switch (_alt) {
522
+ case 1:
523
+ {
524
+ {
525
+ this.state = 160;
526
+ this.match(GherkinParser.NEWLINE);
527
+ }
528
+ }
529
+ break;
530
+ default:
531
+ throw new NoViableAltException_1.NoViableAltException(this);
532
+ }
533
+ this.state = 163;
534
+ this._errHandler.sync(this);
535
+ _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
536
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
459
537
  }
460
538
  }
461
539
  catch (re) {
@@ -477,11 +555,19 @@ class GherkinParser extends Parser_1.Parser {
477
555
  cell() {
478
556
  let _localctx = new CellContext(this._ctx, this.state);
479
557
  this.enterRule(_localctx, 16, GherkinParser.RULE_cell);
558
+ let _la;
480
559
  try {
481
560
  this.enterOuterAlt(_localctx, 1);
482
561
  {
483
- this.state = 125;
484
- this.contentText();
562
+ this.state = 166;
563
+ this._errHandler.sync(this);
564
+ _la = this._input.LA(1);
565
+ if (_la === GherkinParser.TEXT_CHARACTER) {
566
+ {
567
+ this.state = 165;
568
+ this.contentText();
569
+ }
570
+ }
485
571
  }
486
572
  }
487
573
  catch (re) {
@@ -507,75 +593,75 @@ class GherkinParser extends Parser_1.Parser {
507
593
  let _alt;
508
594
  this.enterOuterAlt(_localctx, 1);
509
595
  {
510
- this.state = 127;
596
+ this.state = 168;
511
597
  this.givenStep();
512
- this.state = 131;
598
+ this.state = 172;
513
599
  this._errHandler.sync(this);
514
- _alt = this.interpreter.adaptivePredict(this._input, 16, this._ctx);
600
+ _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
515
601
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
516
602
  if (_alt === 1) {
517
603
  {
518
604
  {
519
- this.state = 128;
605
+ this.state = 169;
520
606
  this.andGivenStep();
521
607
  }
522
608
  }
523
609
  }
524
- this.state = 133;
610
+ this.state = 174;
525
611
  this._errHandler.sync(this);
526
- _alt = this.interpreter.adaptivePredict(this._input, 16, this._ctx);
612
+ _alt = this.interpreter.adaptivePredict(this._input, 21, this._ctx);
527
613
  }
528
- this.state = 134;
614
+ this.state = 175;
529
615
  this.whenStep();
530
- this.state = 138;
616
+ this.state = 179;
531
617
  this._errHandler.sync(this);
532
- _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
618
+ _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
533
619
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
534
620
  if (_alt === 1) {
535
621
  {
536
622
  {
537
- this.state = 135;
623
+ this.state = 176;
538
624
  this.andWhenStep();
539
625
  }
540
626
  }
541
627
  }
542
- this.state = 140;
628
+ this.state = 181;
543
629
  this._errHandler.sync(this);
544
- _alt = this.interpreter.adaptivePredict(this._input, 17, this._ctx);
630
+ _alt = this.interpreter.adaptivePredict(this._input, 22, this._ctx);
545
631
  }
546
- this.state = 141;
632
+ this.state = 182;
547
633
  this.thenStep();
548
- this.state = 145;
634
+ this.state = 186;
549
635
  this._errHandler.sync(this);
550
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
636
+ _alt = this.interpreter.adaptivePredict(this._input, 23, this._ctx);
551
637
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
552
638
  if (_alt === 1) {
553
639
  {
554
640
  {
555
- this.state = 142;
641
+ this.state = 183;
556
642
  this.andStep();
557
643
  }
558
644
  }
559
645
  }
560
- this.state = 147;
646
+ this.state = 188;
561
647
  this._errHandler.sync(this);
562
- _alt = this.interpreter.adaptivePredict(this._input, 18, this._ctx);
648
+ _alt = this.interpreter.adaptivePredict(this._input, 23, this._ctx);
563
649
  }
564
- this.state = 151;
650
+ this.state = 192;
565
651
  this._errHandler.sync(this);
566
- _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
652
+ _alt = this.interpreter.adaptivePredict(this._input, 24, this._ctx);
567
653
  while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
568
654
  if (_alt === 1) {
569
655
  {
570
656
  {
571
- this.state = 148;
657
+ this.state = 189;
572
658
  this.butStep();
573
659
  }
574
660
  }
575
661
  }
576
- this.state = 153;
662
+ this.state = 194;
577
663
  this._errHandler.sync(this);
578
- _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx);
664
+ _alt = this.interpreter.adaptivePredict(this._input, 24, this._ctx);
579
665
  }
580
666
  }
581
667
  }
@@ -600,29 +686,100 @@ class GherkinParser extends Parser_1.Parser {
600
686
  this.enterRule(_localctx, 20, GherkinParser.RULE_givenStep);
601
687
  let _la;
602
688
  try {
689
+ let _alt;
603
690
  this.enterOuterAlt(_localctx, 1);
604
691
  {
605
- this.state = 155;
692
+ this.state = 196;
693
+ this._errHandler.sync(this);
694
+ switch (this.interpreter.adaptivePredict(this._input, 25, this._ctx)) {
695
+ case 1:
696
+ {
697
+ this.state = 195;
698
+ this.tags();
699
+ }
700
+ break;
701
+ }
702
+ this.state = 201;
606
703
  this._errHandler.sync(this);
607
704
  _la = this._input.LA(1);
608
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
705
+ while (_la === GherkinParser.NEWLINE) {
609
706
  {
610
- this.state = 154;
611
- this.tags();
707
+ {
708
+ this.state = 198;
709
+ this.match(GherkinParser.NEWLINE);
710
+ }
612
711
  }
712
+ this.state = 203;
713
+ this._errHandler.sync(this);
714
+ _la = this._input.LA(1);
613
715
  }
614
- this.state = 157;
716
+ this.state = 204;
615
717
  this.match(GherkinParser.GIVEN);
616
- this.state = 158;
617
- this.contentText();
618
- this.state = 160;
718
+ this.state = 205;
719
+ this.multilineText();
720
+ this.state = 220;
619
721
  this._errHandler.sync(this);
620
- _la = this._input.LA(1);
621
- if (_la === GherkinParser.DOC_STRING) {
622
- {
623
- this.state = 159;
624
- this.docString();
625
- }
722
+ switch (this.interpreter.adaptivePredict(this._input, 30, this._ctx)) {
723
+ case 1:
724
+ {
725
+ this.state = 213;
726
+ this._errHandler.sync(this);
727
+ switch (this.interpreter.adaptivePredict(this._input, 28, this._ctx)) {
728
+ case 1:
729
+ {
730
+ this.state = 206;
731
+ this.match(GherkinParser.NEWLINE);
732
+ this.state = 207;
733
+ this.docString();
734
+ this.state = 209;
735
+ this._errHandler.sync(this);
736
+ _alt = 1;
737
+ do {
738
+ switch (_alt) {
739
+ case 1:
740
+ {
741
+ {
742
+ this.state = 208;
743
+ this.match(GherkinParser.NEWLINE);
744
+ }
745
+ }
746
+ break;
747
+ default:
748
+ throw new NoViableAltException_1.NoViableAltException(this);
749
+ }
750
+ this.state = 211;
751
+ this._errHandler.sync(this);
752
+ _alt = this.interpreter.adaptivePredict(this._input, 27, this._ctx);
753
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
754
+ }
755
+ break;
756
+ }
757
+ }
758
+ break;
759
+ case 2:
760
+ {
761
+ this.state = 216;
762
+ this._errHandler.sync(this);
763
+ _alt = 1;
764
+ do {
765
+ switch (_alt) {
766
+ case 1:
767
+ {
768
+ {
769
+ this.state = 215;
770
+ this.match(GherkinParser.NEWLINE);
771
+ }
772
+ }
773
+ break;
774
+ default:
775
+ throw new NoViableAltException_1.NoViableAltException(this);
776
+ }
777
+ this.state = 218;
778
+ this._errHandler.sync(this);
779
+ _alt = this.interpreter.adaptivePredict(this._input, 29, this._ctx);
780
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
781
+ }
782
+ break;
626
783
  }
627
784
  }
628
785
  }
@@ -647,29 +804,100 @@ class GherkinParser extends Parser_1.Parser {
647
804
  this.enterRule(_localctx, 22, GherkinParser.RULE_andGivenStep);
648
805
  let _la;
649
806
  try {
807
+ let _alt;
650
808
  this.enterOuterAlt(_localctx, 1);
651
809
  {
652
- this.state = 163;
810
+ this.state = 223;
811
+ this._errHandler.sync(this);
812
+ switch (this.interpreter.adaptivePredict(this._input, 31, this._ctx)) {
813
+ case 1:
814
+ {
815
+ this.state = 222;
816
+ this.tags();
817
+ }
818
+ break;
819
+ }
820
+ this.state = 228;
653
821
  this._errHandler.sync(this);
654
822
  _la = this._input.LA(1);
655
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
823
+ while (_la === GherkinParser.NEWLINE) {
656
824
  {
657
- this.state = 162;
658
- this.tags();
825
+ {
826
+ this.state = 225;
827
+ this.match(GherkinParser.NEWLINE);
828
+ }
659
829
  }
830
+ this.state = 230;
831
+ this._errHandler.sync(this);
832
+ _la = this._input.LA(1);
660
833
  }
661
- this.state = 165;
834
+ this.state = 231;
662
835
  this.match(GherkinParser.AND_GIVEN);
663
- this.state = 166;
664
- this.contentText();
665
- this.state = 168;
836
+ this.state = 232;
837
+ this.multilineText();
838
+ this.state = 247;
666
839
  this._errHandler.sync(this);
667
- _la = this._input.LA(1);
668
- if (_la === GherkinParser.DOC_STRING) {
669
- {
670
- this.state = 167;
671
- this.docString();
672
- }
840
+ switch (this.interpreter.adaptivePredict(this._input, 36, this._ctx)) {
841
+ case 1:
842
+ {
843
+ this.state = 240;
844
+ this._errHandler.sync(this);
845
+ switch (this.interpreter.adaptivePredict(this._input, 34, this._ctx)) {
846
+ case 1:
847
+ {
848
+ this.state = 233;
849
+ this.match(GherkinParser.NEWLINE);
850
+ this.state = 234;
851
+ this.docString();
852
+ this.state = 236;
853
+ this._errHandler.sync(this);
854
+ _alt = 1;
855
+ do {
856
+ switch (_alt) {
857
+ case 1:
858
+ {
859
+ {
860
+ this.state = 235;
861
+ this.match(GherkinParser.NEWLINE);
862
+ }
863
+ }
864
+ break;
865
+ default:
866
+ throw new NoViableAltException_1.NoViableAltException(this);
867
+ }
868
+ this.state = 238;
869
+ this._errHandler.sync(this);
870
+ _alt = this.interpreter.adaptivePredict(this._input, 33, this._ctx);
871
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
872
+ }
873
+ break;
874
+ }
875
+ }
876
+ break;
877
+ case 2:
878
+ {
879
+ this.state = 243;
880
+ this._errHandler.sync(this);
881
+ _alt = 1;
882
+ do {
883
+ switch (_alt) {
884
+ case 1:
885
+ {
886
+ {
887
+ this.state = 242;
888
+ this.match(GherkinParser.NEWLINE);
889
+ }
890
+ }
891
+ break;
892
+ default:
893
+ throw new NoViableAltException_1.NoViableAltException(this);
894
+ }
895
+ this.state = 245;
896
+ this._errHandler.sync(this);
897
+ _alt = this.interpreter.adaptivePredict(this._input, 35, this._ctx);
898
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
899
+ }
900
+ break;
673
901
  }
674
902
  }
675
903
  }
@@ -694,29 +922,100 @@ class GherkinParser extends Parser_1.Parser {
694
922
  this.enterRule(_localctx, 24, GherkinParser.RULE_whenStep);
695
923
  let _la;
696
924
  try {
925
+ let _alt;
697
926
  this.enterOuterAlt(_localctx, 1);
698
927
  {
699
- this.state = 171;
928
+ this.state = 250;
929
+ this._errHandler.sync(this);
930
+ switch (this.interpreter.adaptivePredict(this._input, 37, this._ctx)) {
931
+ case 1:
932
+ {
933
+ this.state = 249;
934
+ this.tags();
935
+ }
936
+ break;
937
+ }
938
+ this.state = 255;
700
939
  this._errHandler.sync(this);
701
940
  _la = this._input.LA(1);
702
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
941
+ while (_la === GherkinParser.NEWLINE) {
703
942
  {
704
- this.state = 170;
705
- this.tags();
943
+ {
944
+ this.state = 252;
945
+ this.match(GherkinParser.NEWLINE);
946
+ }
706
947
  }
948
+ this.state = 257;
949
+ this._errHandler.sync(this);
950
+ _la = this._input.LA(1);
707
951
  }
708
- this.state = 173;
952
+ this.state = 258;
709
953
  this.match(GherkinParser.WHEN);
710
- this.state = 174;
711
- this.contentText();
712
- this.state = 176;
954
+ this.state = 259;
955
+ this.multilineText();
956
+ this.state = 274;
713
957
  this._errHandler.sync(this);
714
- _la = this._input.LA(1);
715
- if (_la === GherkinParser.DOC_STRING) {
716
- {
717
- this.state = 175;
718
- this.docString();
719
- }
958
+ switch (this.interpreter.adaptivePredict(this._input, 42, this._ctx)) {
959
+ case 1:
960
+ {
961
+ this.state = 267;
962
+ this._errHandler.sync(this);
963
+ switch (this.interpreter.adaptivePredict(this._input, 40, this._ctx)) {
964
+ case 1:
965
+ {
966
+ this.state = 260;
967
+ this.match(GherkinParser.NEWLINE);
968
+ this.state = 261;
969
+ this.docString();
970
+ this.state = 263;
971
+ this._errHandler.sync(this);
972
+ _alt = 1;
973
+ do {
974
+ switch (_alt) {
975
+ case 1:
976
+ {
977
+ {
978
+ this.state = 262;
979
+ this.match(GherkinParser.NEWLINE);
980
+ }
981
+ }
982
+ break;
983
+ default:
984
+ throw new NoViableAltException_1.NoViableAltException(this);
985
+ }
986
+ this.state = 265;
987
+ this._errHandler.sync(this);
988
+ _alt = this.interpreter.adaptivePredict(this._input, 39, this._ctx);
989
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
990
+ }
991
+ break;
992
+ }
993
+ }
994
+ break;
995
+ case 2:
996
+ {
997
+ this.state = 270;
998
+ this._errHandler.sync(this);
999
+ _alt = 1;
1000
+ do {
1001
+ switch (_alt) {
1002
+ case 1:
1003
+ {
1004
+ {
1005
+ this.state = 269;
1006
+ this.match(GherkinParser.NEWLINE);
1007
+ }
1008
+ }
1009
+ break;
1010
+ default:
1011
+ throw new NoViableAltException_1.NoViableAltException(this);
1012
+ }
1013
+ this.state = 272;
1014
+ this._errHandler.sync(this);
1015
+ _alt = this.interpreter.adaptivePredict(this._input, 41, this._ctx);
1016
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1017
+ }
1018
+ break;
720
1019
  }
721
1020
  }
722
1021
  }
@@ -741,29 +1040,100 @@ class GherkinParser extends Parser_1.Parser {
741
1040
  this.enterRule(_localctx, 26, GherkinParser.RULE_andWhenStep);
742
1041
  let _la;
743
1042
  try {
1043
+ let _alt;
744
1044
  this.enterOuterAlt(_localctx, 1);
745
1045
  {
746
- this.state = 179;
1046
+ this.state = 277;
1047
+ this._errHandler.sync(this);
1048
+ switch (this.interpreter.adaptivePredict(this._input, 43, this._ctx)) {
1049
+ case 1:
1050
+ {
1051
+ this.state = 276;
1052
+ this.tags();
1053
+ }
1054
+ break;
1055
+ }
1056
+ this.state = 282;
747
1057
  this._errHandler.sync(this);
748
1058
  _la = this._input.LA(1);
749
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1059
+ while (_la === GherkinParser.NEWLINE) {
750
1060
  {
751
- this.state = 178;
752
- this.tags();
1061
+ {
1062
+ this.state = 279;
1063
+ this.match(GherkinParser.NEWLINE);
1064
+ }
753
1065
  }
1066
+ this.state = 284;
1067
+ this._errHandler.sync(this);
1068
+ _la = this._input.LA(1);
754
1069
  }
755
- this.state = 181;
1070
+ this.state = 285;
756
1071
  this.match(GherkinParser.AND_WHEN);
757
- this.state = 182;
758
- this.contentText();
759
- this.state = 184;
1072
+ this.state = 286;
1073
+ this.multilineText();
1074
+ this.state = 301;
760
1075
  this._errHandler.sync(this);
761
- _la = this._input.LA(1);
762
- if (_la === GherkinParser.DOC_STRING) {
763
- {
764
- this.state = 183;
765
- this.docString();
766
- }
1076
+ switch (this.interpreter.adaptivePredict(this._input, 48, this._ctx)) {
1077
+ case 1:
1078
+ {
1079
+ this.state = 294;
1080
+ this._errHandler.sync(this);
1081
+ switch (this.interpreter.adaptivePredict(this._input, 46, this._ctx)) {
1082
+ case 1:
1083
+ {
1084
+ this.state = 287;
1085
+ this.match(GherkinParser.NEWLINE);
1086
+ this.state = 288;
1087
+ this.docString();
1088
+ this.state = 290;
1089
+ this._errHandler.sync(this);
1090
+ _alt = 1;
1091
+ do {
1092
+ switch (_alt) {
1093
+ case 1:
1094
+ {
1095
+ {
1096
+ this.state = 289;
1097
+ this.match(GherkinParser.NEWLINE);
1098
+ }
1099
+ }
1100
+ break;
1101
+ default:
1102
+ throw new NoViableAltException_1.NoViableAltException(this);
1103
+ }
1104
+ this.state = 292;
1105
+ this._errHandler.sync(this);
1106
+ _alt = this.interpreter.adaptivePredict(this._input, 45, this._ctx);
1107
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1108
+ }
1109
+ break;
1110
+ }
1111
+ }
1112
+ break;
1113
+ case 2:
1114
+ {
1115
+ this.state = 297;
1116
+ this._errHandler.sync(this);
1117
+ _alt = 1;
1118
+ do {
1119
+ switch (_alt) {
1120
+ case 1:
1121
+ {
1122
+ {
1123
+ this.state = 296;
1124
+ this.match(GherkinParser.NEWLINE);
1125
+ }
1126
+ }
1127
+ break;
1128
+ default:
1129
+ throw new NoViableAltException_1.NoViableAltException(this);
1130
+ }
1131
+ this.state = 299;
1132
+ this._errHandler.sync(this);
1133
+ _alt = this.interpreter.adaptivePredict(this._input, 47, this._ctx);
1134
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1135
+ }
1136
+ break;
767
1137
  }
768
1138
  }
769
1139
  }
@@ -788,29 +1158,100 @@ class GherkinParser extends Parser_1.Parser {
788
1158
  this.enterRule(_localctx, 28, GherkinParser.RULE_thenStep);
789
1159
  let _la;
790
1160
  try {
1161
+ let _alt;
791
1162
  this.enterOuterAlt(_localctx, 1);
792
1163
  {
793
- this.state = 187;
1164
+ this.state = 304;
1165
+ this._errHandler.sync(this);
1166
+ switch (this.interpreter.adaptivePredict(this._input, 49, this._ctx)) {
1167
+ case 1:
1168
+ {
1169
+ this.state = 303;
1170
+ this.thenTags();
1171
+ }
1172
+ break;
1173
+ }
1174
+ this.state = 309;
794
1175
  this._errHandler.sync(this);
795
1176
  _la = this._input.LA(1);
796
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1177
+ while (_la === GherkinParser.NEWLINE) {
797
1178
  {
798
- this.state = 186;
799
- this.tags();
1179
+ {
1180
+ this.state = 306;
1181
+ this.match(GherkinParser.NEWLINE);
1182
+ }
800
1183
  }
1184
+ this.state = 311;
1185
+ this._errHandler.sync(this);
1186
+ _la = this._input.LA(1);
801
1187
  }
802
- this.state = 189;
1188
+ this.state = 312;
803
1189
  this.match(GherkinParser.THEN);
804
- this.state = 190;
805
- this.contentText();
806
- this.state = 192;
1190
+ this.state = 313;
1191
+ this.multilineText();
1192
+ this.state = 328;
807
1193
  this._errHandler.sync(this);
808
- _la = this._input.LA(1);
809
- if (_la === GherkinParser.DOC_STRING) {
810
- {
811
- this.state = 191;
812
- this.docString();
813
- }
1194
+ switch (this.interpreter.adaptivePredict(this._input, 54, this._ctx)) {
1195
+ case 1:
1196
+ {
1197
+ this.state = 321;
1198
+ this._errHandler.sync(this);
1199
+ switch (this.interpreter.adaptivePredict(this._input, 52, this._ctx)) {
1200
+ case 1:
1201
+ {
1202
+ this.state = 314;
1203
+ this.match(GherkinParser.NEWLINE);
1204
+ this.state = 315;
1205
+ this.docString();
1206
+ this.state = 317;
1207
+ this._errHandler.sync(this);
1208
+ _alt = 1;
1209
+ do {
1210
+ switch (_alt) {
1211
+ case 1:
1212
+ {
1213
+ {
1214
+ this.state = 316;
1215
+ this.match(GherkinParser.NEWLINE);
1216
+ }
1217
+ }
1218
+ break;
1219
+ default:
1220
+ throw new NoViableAltException_1.NoViableAltException(this);
1221
+ }
1222
+ this.state = 319;
1223
+ this._errHandler.sync(this);
1224
+ _alt = this.interpreter.adaptivePredict(this._input, 51, this._ctx);
1225
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1226
+ }
1227
+ break;
1228
+ }
1229
+ }
1230
+ break;
1231
+ case 2:
1232
+ {
1233
+ this.state = 324;
1234
+ this._errHandler.sync(this);
1235
+ _alt = 1;
1236
+ do {
1237
+ switch (_alt) {
1238
+ case 1:
1239
+ {
1240
+ {
1241
+ this.state = 323;
1242
+ this.match(GherkinParser.NEWLINE);
1243
+ }
1244
+ }
1245
+ break;
1246
+ default:
1247
+ throw new NoViableAltException_1.NoViableAltException(this);
1248
+ }
1249
+ this.state = 326;
1250
+ this._errHandler.sync(this);
1251
+ _alt = this.interpreter.adaptivePredict(this._input, 53, this._ctx);
1252
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1253
+ }
1254
+ break;
814
1255
  }
815
1256
  }
816
1257
  }
@@ -835,29 +1276,100 @@ class GherkinParser extends Parser_1.Parser {
835
1276
  this.enterRule(_localctx, 30, GherkinParser.RULE_andStep);
836
1277
  let _la;
837
1278
  try {
1279
+ let _alt;
838
1280
  this.enterOuterAlt(_localctx, 1);
839
1281
  {
840
- this.state = 195;
1282
+ this.state = 331;
1283
+ this._errHandler.sync(this);
1284
+ switch (this.interpreter.adaptivePredict(this._input, 55, this._ctx)) {
1285
+ case 1:
1286
+ {
1287
+ this.state = 330;
1288
+ this.thenTags();
1289
+ }
1290
+ break;
1291
+ }
1292
+ this.state = 336;
841
1293
  this._errHandler.sync(this);
842
1294
  _la = this._input.LA(1);
843
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1295
+ while (_la === GherkinParser.NEWLINE) {
844
1296
  {
845
- this.state = 194;
846
- this.tags();
1297
+ {
1298
+ this.state = 333;
1299
+ this.match(GherkinParser.NEWLINE);
1300
+ }
847
1301
  }
1302
+ this.state = 338;
1303
+ this._errHandler.sync(this);
1304
+ _la = this._input.LA(1);
848
1305
  }
849
- this.state = 197;
1306
+ this.state = 339;
850
1307
  this.match(GherkinParser.AND);
851
- this.state = 198;
852
- this.contentText();
853
- this.state = 200;
1308
+ this.state = 340;
1309
+ this.multilineText();
1310
+ this.state = 355;
854
1311
  this._errHandler.sync(this);
855
- _la = this._input.LA(1);
856
- if (_la === GherkinParser.DOC_STRING) {
857
- {
858
- this.state = 199;
859
- this.docString();
860
- }
1312
+ switch (this.interpreter.adaptivePredict(this._input, 60, this._ctx)) {
1313
+ case 1:
1314
+ {
1315
+ this.state = 348;
1316
+ this._errHandler.sync(this);
1317
+ switch (this.interpreter.adaptivePredict(this._input, 58, this._ctx)) {
1318
+ case 1:
1319
+ {
1320
+ this.state = 341;
1321
+ this.match(GherkinParser.NEWLINE);
1322
+ this.state = 342;
1323
+ this.docString();
1324
+ this.state = 344;
1325
+ this._errHandler.sync(this);
1326
+ _alt = 1;
1327
+ do {
1328
+ switch (_alt) {
1329
+ case 1:
1330
+ {
1331
+ {
1332
+ this.state = 343;
1333
+ this.match(GherkinParser.NEWLINE);
1334
+ }
1335
+ }
1336
+ break;
1337
+ default:
1338
+ throw new NoViableAltException_1.NoViableAltException(this);
1339
+ }
1340
+ this.state = 346;
1341
+ this._errHandler.sync(this);
1342
+ _alt = this.interpreter.adaptivePredict(this._input, 57, this._ctx);
1343
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1344
+ }
1345
+ break;
1346
+ }
1347
+ }
1348
+ break;
1349
+ case 2:
1350
+ {
1351
+ this.state = 351;
1352
+ this._errHandler.sync(this);
1353
+ _alt = 1;
1354
+ do {
1355
+ switch (_alt) {
1356
+ case 1:
1357
+ {
1358
+ {
1359
+ this.state = 350;
1360
+ this.match(GherkinParser.NEWLINE);
1361
+ }
1362
+ }
1363
+ break;
1364
+ default:
1365
+ throw new NoViableAltException_1.NoViableAltException(this);
1366
+ }
1367
+ this.state = 353;
1368
+ this._errHandler.sync(this);
1369
+ _alt = this.interpreter.adaptivePredict(this._input, 59, this._ctx);
1370
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1371
+ }
1372
+ break;
861
1373
  }
862
1374
  }
863
1375
  }
@@ -882,30 +1394,207 @@ class GherkinParser extends Parser_1.Parser {
882
1394
  this.enterRule(_localctx, 32, GherkinParser.RULE_butStep);
883
1395
  let _la;
884
1396
  try {
1397
+ let _alt;
885
1398
  this.enterOuterAlt(_localctx, 1);
886
1399
  {
887
- this.state = 203;
1400
+ this.state = 358;
1401
+ this._errHandler.sync(this);
1402
+ switch (this.interpreter.adaptivePredict(this._input, 61, this._ctx)) {
1403
+ case 1:
1404
+ {
1405
+ this.state = 357;
1406
+ this.thenTags();
1407
+ }
1408
+ break;
1409
+ }
1410
+ this.state = 363;
888
1411
  this._errHandler.sync(this);
889
1412
  _la = this._input.LA(1);
890
- if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0)) {
1413
+ while (_la === GherkinParser.NEWLINE) {
891
1414
  {
892
- this.state = 202;
893
- this.tags();
1415
+ {
1416
+ this.state = 360;
1417
+ this.match(GherkinParser.NEWLINE);
1418
+ }
894
1419
  }
1420
+ this.state = 365;
1421
+ this._errHandler.sync(this);
1422
+ _la = this._input.LA(1);
895
1423
  }
896
- this.state = 205;
1424
+ this.state = 366;
897
1425
  this.match(GherkinParser.BUT);
898
- this.state = 206;
899
- this.contentText();
900
- this.state = 208;
1426
+ this.state = 367;
1427
+ this.multilineText();
1428
+ this.state = 382;
1429
+ this._errHandler.sync(this);
1430
+ switch (this.interpreter.adaptivePredict(this._input, 66, this._ctx)) {
1431
+ case 1:
1432
+ {
1433
+ this.state = 375;
1434
+ this._errHandler.sync(this);
1435
+ switch (this.interpreter.adaptivePredict(this._input, 64, this._ctx)) {
1436
+ case 1:
1437
+ {
1438
+ this.state = 368;
1439
+ this.match(GherkinParser.NEWLINE);
1440
+ this.state = 369;
1441
+ this.docString();
1442
+ this.state = 371;
1443
+ this._errHandler.sync(this);
1444
+ _alt = 1;
1445
+ do {
1446
+ switch (_alt) {
1447
+ case 1:
1448
+ {
1449
+ {
1450
+ this.state = 370;
1451
+ this.match(GherkinParser.NEWLINE);
1452
+ }
1453
+ }
1454
+ break;
1455
+ default:
1456
+ throw new NoViableAltException_1.NoViableAltException(this);
1457
+ }
1458
+ this.state = 373;
1459
+ this._errHandler.sync(this);
1460
+ _alt = this.interpreter.adaptivePredict(this._input, 63, this._ctx);
1461
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1462
+ }
1463
+ break;
1464
+ }
1465
+ }
1466
+ break;
1467
+ case 2:
1468
+ {
1469
+ this.state = 378;
1470
+ this._errHandler.sync(this);
1471
+ _alt = 1;
1472
+ do {
1473
+ switch (_alt) {
1474
+ case 1:
1475
+ {
1476
+ {
1477
+ this.state = 377;
1478
+ this.match(GherkinParser.NEWLINE);
1479
+ }
1480
+ }
1481
+ break;
1482
+ default:
1483
+ throw new NoViableAltException_1.NoViableAltException(this);
1484
+ }
1485
+ this.state = 380;
1486
+ this._errHandler.sync(this);
1487
+ _alt = this.interpreter.adaptivePredict(this._input, 65, this._ctx);
1488
+ } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1489
+ }
1490
+ break;
1491
+ }
1492
+ }
1493
+ }
1494
+ catch (re) {
1495
+ if (re instanceof RecognitionException_1.RecognitionException) {
1496
+ _localctx.exception = re;
1497
+ this._errHandler.reportError(this, re);
1498
+ this._errHandler.recover(this, re);
1499
+ }
1500
+ else {
1501
+ throw re;
1502
+ }
1503
+ }
1504
+ finally {
1505
+ this.exitRule();
1506
+ }
1507
+ return _localctx;
1508
+ }
1509
+ // @RuleVersion(0)
1510
+ docString() {
1511
+ let _localctx = new DocStringContext(this._ctx, this.state);
1512
+ this.enterRule(_localctx, 34, GherkinParser.RULE_docString);
1513
+ try {
1514
+ this.enterOuterAlt(_localctx, 1);
1515
+ {
1516
+ this.state = 384;
1517
+ this.match(GherkinParser.DOC_STRING);
1518
+ }
1519
+ }
1520
+ catch (re) {
1521
+ if (re instanceof RecognitionException_1.RecognitionException) {
1522
+ _localctx.exception = re;
1523
+ this._errHandler.reportError(this, re);
1524
+ this._errHandler.recover(this, re);
1525
+ }
1526
+ else {
1527
+ throw re;
1528
+ }
1529
+ }
1530
+ finally {
1531
+ this.exitRule();
1532
+ }
1533
+ return _localctx;
1534
+ }
1535
+ // @RuleVersion(0)
1536
+ tags() {
1537
+ let _localctx = new TagsContext(this._ctx, this.state);
1538
+ this.enterRule(_localctx, 36, GherkinParser.RULE_tags);
1539
+ let _la;
1540
+ try {
1541
+ let _alt;
1542
+ this.enterOuterAlt(_localctx, 1);
1543
+ {
1544
+ this.state = 389;
901
1545
  this._errHandler.sync(this);
902
1546
  _la = this._input.LA(1);
903
- if (_la === GherkinParser.DOC_STRING) {
1547
+ while (_la === GherkinParser.NEWLINE) {
904
1548
  {
905
- this.state = 207;
906
- this.docString();
1549
+ {
1550
+ this.state = 386;
1551
+ this.match(GherkinParser.NEWLINE);
1552
+ }
1553
+ }
1554
+ this.state = 391;
1555
+ this._errHandler.sync(this);
1556
+ _la = this._input.LA(1);
1557
+ }
1558
+ this.state = 399;
1559
+ this._errHandler.sync(this);
1560
+ _la = this._input.LA(1);
1561
+ do {
1562
+ {
1563
+ {
1564
+ this.state = 392;
1565
+ _la = this._input.LA(1);
1566
+ if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
1567
+ this._errHandler.recoverInline(this);
1568
+ }
1569
+ else {
1570
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1571
+ this.matchedEOF = true;
1572
+ }
1573
+ this._errHandler.reportMatch(this);
1574
+ this.consume();
1575
+ }
1576
+ this.state = 396;
1577
+ this._errHandler.sync(this);
1578
+ _alt = this.interpreter.adaptivePredict(this._input, 68, this._ctx);
1579
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1580
+ if (_alt === 1) {
1581
+ {
1582
+ {
1583
+ this.state = 393;
1584
+ this.match(GherkinParser.NEWLINE);
1585
+ }
1586
+ }
1587
+ }
1588
+ this.state = 398;
1589
+ this._errHandler.sync(this);
1590
+ _alt = this.interpreter.adaptivePredict(this._input, 68, this._ctx);
1591
+ }
1592
+ }
907
1593
  }
908
- }
1594
+ this.state = 401;
1595
+ this._errHandler.sync(this);
1596
+ _la = this._input.LA(1);
1597
+ } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0));
909
1598
  }
910
1599
  }
911
1600
  catch (re) {
@@ -924,14 +1613,68 @@ class GherkinParser extends Parser_1.Parser {
924
1613
  return _localctx;
925
1614
  }
926
1615
  // @RuleVersion(0)
927
- docString() {
928
- let _localctx = new DocStringContext(this._ctx, this.state);
929
- this.enterRule(_localctx, 34, GherkinParser.RULE_docString);
1616
+ thenTags() {
1617
+ let _localctx = new ThenTagsContext(this._ctx, this.state);
1618
+ this.enterRule(_localctx, 38, GherkinParser.RULE_thenTags);
1619
+ let _la;
930
1620
  try {
1621
+ let _alt;
931
1622
  this.enterOuterAlt(_localctx, 1);
932
1623
  {
933
- this.state = 210;
934
- this.match(GherkinParser.DOC_STRING);
1624
+ this.state = 406;
1625
+ this._errHandler.sync(this);
1626
+ _la = this._input.LA(1);
1627
+ while (_la === GherkinParser.NEWLINE) {
1628
+ {
1629
+ {
1630
+ this.state = 403;
1631
+ this.match(GherkinParser.NEWLINE);
1632
+ }
1633
+ }
1634
+ this.state = 408;
1635
+ this._errHandler.sync(this);
1636
+ _la = this._input.LA(1);
1637
+ }
1638
+ this.state = 416;
1639
+ this._errHandler.sync(this);
1640
+ _la = this._input.LA(1);
1641
+ do {
1642
+ {
1643
+ {
1644
+ this.state = 409;
1645
+ _la = this._input.LA(1);
1646
+ if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TODO_TAG) | (1 << GherkinParser.FAIL_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
1647
+ this._errHandler.recoverInline(this);
1648
+ }
1649
+ else {
1650
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1651
+ this.matchedEOF = true;
1652
+ }
1653
+ this._errHandler.reportMatch(this);
1654
+ this.consume();
1655
+ }
1656
+ this.state = 413;
1657
+ this._errHandler.sync(this);
1658
+ _alt = this.interpreter.adaptivePredict(this._input, 71, this._ctx);
1659
+ while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER) {
1660
+ if (_alt === 1) {
1661
+ {
1662
+ {
1663
+ this.state = 410;
1664
+ this.match(GherkinParser.NEWLINE);
1665
+ }
1666
+ }
1667
+ }
1668
+ this.state = 415;
1669
+ this._errHandler.sync(this);
1670
+ _alt = this.interpreter.adaptivePredict(this._input, 71, this._ctx);
1671
+ }
1672
+ }
1673
+ }
1674
+ this.state = 418;
1675
+ this._errHandler.sync(this);
1676
+ _la = this._input.LA(1);
1677
+ } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TODO_TAG) | (1 << GherkinParser.FAIL_TAG) | (1 << GherkinParser.TAG))) !== 0));
935
1678
  }
936
1679
  }
937
1680
  catch (re) {
@@ -950,37 +1693,27 @@ class GherkinParser extends Parser_1.Parser {
950
1693
  return _localctx;
951
1694
  }
952
1695
  // @RuleVersion(0)
953
- tags() {
954
- let _localctx = new TagsContext(this._ctx, this.state);
955
- this.enterRule(_localctx, 36, GherkinParser.RULE_tags);
1696
+ contentText() {
1697
+ let _localctx = new ContentTextContext(this._ctx, this.state);
1698
+ this.enterRule(_localctx, 40, GherkinParser.RULE_contentText);
956
1699
  let _la;
957
1700
  try {
958
1701
  this.enterOuterAlt(_localctx, 1);
959
1702
  {
960
- this.state = 213;
1703
+ this.state = 421;
961
1704
  this._errHandler.sync(this);
962
1705
  _la = this._input.LA(1);
963
1706
  do {
964
1707
  {
965
1708
  {
966
- this.state = 212;
967
- _la = this._input.LA(1);
968
- if (!((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0))) {
969
- this._errHandler.recoverInline(this);
970
- }
971
- else {
972
- if (this._input.LA(1) === Token_1.Token.EOF) {
973
- this.matchedEOF = true;
974
- }
975
- this._errHandler.reportMatch(this);
976
- this.consume();
977
- }
1709
+ this.state = 420;
1710
+ this.match(GherkinParser.TEXT_CHARACTER);
978
1711
  }
979
1712
  }
980
- this.state = 215;
1713
+ this.state = 423;
981
1714
  this._errHandler.sync(this);
982
1715
  _la = this._input.LA(1);
983
- } while ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << GherkinParser.ONLY_TAG) | (1 << GherkinParser.SKIP_TAG) | (1 << GherkinParser.TAG))) !== 0));
1716
+ } while (_la === GherkinParser.TEXT_CHARACTER);
984
1717
  }
985
1718
  }
986
1719
  catch (re) {
@@ -999,14 +1732,15 @@ class GherkinParser extends Parser_1.Parser {
999
1732
  return _localctx;
1000
1733
  }
1001
1734
  // @RuleVersion(0)
1002
- contentText() {
1003
- let _localctx = new ContentTextContext(this._ctx, this.state);
1004
- this.enterRule(_localctx, 38, GherkinParser.RULE_contentText);
1735
+ multilineText() {
1736
+ let _localctx = new MultilineTextContext(this._ctx, this.state);
1737
+ this.enterRule(_localctx, 42, GherkinParser.RULE_multilineText);
1738
+ let _la;
1005
1739
  try {
1006
1740
  let _alt;
1007
1741
  this.enterOuterAlt(_localctx, 1);
1008
1742
  {
1009
- this.state = 218;
1743
+ this.state = 426;
1010
1744
  this._errHandler.sync(this);
1011
1745
  _alt = 1;
1012
1746
  do {
@@ -1014,17 +1748,27 @@ class GherkinParser extends Parser_1.Parser {
1014
1748
  case 1:
1015
1749
  {
1016
1750
  {
1017
- this.state = 217;
1018
- this.match(GherkinParser.TEXT_CHARACTER);
1751
+ this.state = 425;
1752
+ _la = this._input.LA(1);
1753
+ if (!(_la === GherkinParser.TEXT_CHARACTER || _la === GherkinParser.NEWLINE)) {
1754
+ this._errHandler.recoverInline(this);
1755
+ }
1756
+ else {
1757
+ if (this._input.LA(1) === Token_1.Token.EOF) {
1758
+ this.matchedEOF = true;
1759
+ }
1760
+ this._errHandler.reportMatch(this);
1761
+ this.consume();
1762
+ }
1019
1763
  }
1020
1764
  }
1021
1765
  break;
1022
1766
  default:
1023
1767
  throw new NoViableAltException_1.NoViableAltException(this);
1024
1768
  }
1025
- this.state = 220;
1769
+ this.state = 428;
1026
1770
  this._errHandler.sync(this);
1027
- _alt = this.interpreter.adaptivePredict(this._input, 35, this._ctx);
1771
+ _alt = this.interpreter.adaptivePredict(this._input, 74, this._ctx);
1028
1772
  } while (_alt !== 2 && _alt !== ATN_1.ATN.INVALID_ALT_NUMBER);
1029
1773
  }
1030
1774
  }
@@ -1066,12 +1810,14 @@ GherkinParser.BACKGROUND = 12;
1066
1810
  GherkinParser.PIPE = 13;
1067
1811
  GherkinParser.ONLY_TAG = 14;
1068
1812
  GherkinParser.SKIP_TAG = 15;
1069
- GherkinParser.TAG = 16;
1070
- GherkinParser.COMMENT = 17;
1071
- GherkinParser.TEXT_CHARACTER = 18;
1072
- GherkinParser.WS = 19;
1073
- GherkinParser.WSS = 20;
1074
- GherkinParser.DOC_STRING = 21;
1813
+ GherkinParser.TODO_TAG = 16;
1814
+ GherkinParser.FAIL_TAG = 17;
1815
+ GherkinParser.TAG = 18;
1816
+ GherkinParser.COMMENT = 19;
1817
+ GherkinParser.TEXT_CHARACTER = 20;
1818
+ GherkinParser.NEWLINE = 21;
1819
+ GherkinParser.WSS = 22;
1820
+ GherkinParser.DOC_STRING = 23;
1075
1821
  GherkinParser.RULE_featureFile = 0;
1076
1822
  GherkinParser.RULE_feature = 1;
1077
1823
  GherkinParser.RULE_background = 2;
@@ -1091,125 +1837,252 @@ GherkinParser.RULE_andStep = 15;
1091
1837
  GherkinParser.RULE_butStep = 16;
1092
1838
  GherkinParser.RULE_docString = 17;
1093
1839
  GherkinParser.RULE_tags = 18;
1094
- GherkinParser.RULE_contentText = 19;
1840
+ GherkinParser.RULE_thenTags = 19;
1841
+ GherkinParser.RULE_contentText = 20;
1842
+ GherkinParser.RULE_multilineText = 21;
1095
1843
  // tslint:disable:no-trailing-whitespace
1096
1844
  GherkinParser.ruleNames = [
1097
1845
  "featureFile", "feature", "background", "scenario", "scenarioOutline",
1098
1846
  "examplesBlock", "tableHeader", "tableRow", "cell", "step", "givenStep",
1099
1847
  "andGivenStep", "whenStep", "andWhenStep", "thenStep", "andStep", "butStep",
1100
- "docString", "tags", "contentText",
1848
+ "docString", "tags", "thenTags", "contentText", "multilineText",
1101
1849
  ];
1102
1850
  GherkinParser._LITERAL_NAMES = [
1103
1851
  undefined, undefined, undefined, undefined, undefined, undefined, undefined,
1104
1852
  undefined, undefined, undefined, undefined, undefined, undefined, "'|'",
1105
- "'@only'", "'@skip'",
1853
+ "'@only'", "'@skip'", "'@todo'", "'@fail'",
1106
1854
  ];
1107
1855
  GherkinParser._SYMBOLIC_NAMES = [
1108
1856
  undefined, "FEATURE", "SCENARIO", "SCENARIO_OUTLINE", "GIVEN", "AND_GIVEN",
1109
1857
  "WHEN", "AND_WHEN", "THEN", "AND", "BUT", "EXAMPLES", "BACKGROUND", "PIPE",
1110
- "ONLY_TAG", "SKIP_TAG", "TAG", "COMMENT", "TEXT_CHARACTER", "WS", "WSS",
1111
- "DOC_STRING",
1858
+ "ONLY_TAG", "SKIP_TAG", "TODO_TAG", "FAIL_TAG", "TAG", "COMMENT", "TEXT_CHARACTER",
1859
+ "NEWLINE", "WSS", "DOC_STRING",
1112
1860
  ];
1113
1861
  GherkinParser.VOCABULARY = new VocabularyImpl_1.VocabularyImpl(GherkinParser._LITERAL_NAMES, GherkinParser._SYMBOLIC_NAMES, []);
1114
- GherkinParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x17\xE1\x04\x02" +
1115
- "\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04\x07" +
1116
- "\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" +
1117
- "\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12\x04" +
1118
- "\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x03\x02\x07\x02,\n\x02\f\x02\x0E" +
1119
- "\x02/\v\x02\x03\x03\x05\x032\n\x03\x03\x03\x03\x03\x03\x03\x05\x037\n" +
1120
- "\x03\x03\x03\x03\x03\x07\x03;\n\x03\f\x03\x0E\x03>\v\x03\x05\x03@\n\x03" +
1121
- "\x03\x04\x05\x04C\n\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04I\n\x04" +
1122
- "\f\x04\x0E\x04L\v\x04\x03\x04\x03\x04\x07\x04P\n\x04\f\x04\x0E\x04S\v" +
1123
- "\x04\x03\x05\x05\x05V\n\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x05" +
1124
- "\x06]\n\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x06\x03\x07\x03\x07\x03" +
1125
- "\x07\x06\x07g\n\x07\r\x07\x0E\x07h\x03\b\x03\b\x03\t\x03\t\x06\to\n\t" +
1126
- "\r\t\x0E\tp\x03\t\x03\t\x06\tu\n\t\r\t\x0E\tv\x07\ty\n\t\f\t\x0E\t|\v" +
1127
- "\t\x03\t\x03\t\x03\n\x03\n\x03\v\x03\v\x07\v\x84\n\v\f\v\x0E\v\x87\v\v" +
1128
- "\x03\v\x03\v\x07\v\x8B\n\v\f\v\x0E\v\x8E\v\v\x03\v\x03\v\x07\v\x92\n\v" +
1129
- "\f\v\x0E\v\x95\v\v\x03\v\x07\v\x98\n\v\f\v\x0E\v\x9B\v\v\x03\f\x05\f\x9E" +
1130
- "\n\f\x03\f\x03\f\x03\f\x05\f\xA3\n\f\x03\r\x05\r\xA6\n\r\x03\r\x03\r\x03" +
1131
- "\r\x05\r\xAB\n\r\x03\x0E\x05\x0E\xAE\n\x0E\x03\x0E\x03\x0E\x03\x0E\x05" +
1132
- "\x0E\xB3\n\x0E\x03\x0F\x05\x0F\xB6\n\x0F\x03\x0F\x03\x0F\x03\x0F\x05\x0F" +
1133
- "\xBB\n\x0F\x03\x10\x05\x10\xBE\n\x10\x03\x10\x03\x10\x03\x10\x05\x10\xC3" +
1134
- "\n\x10\x03\x11\x05\x11\xC6\n\x11\x03\x11\x03\x11\x03\x11\x05\x11\xCB\n" +
1135
- "\x11\x03\x12\x05\x12\xCE\n\x12\x03\x12\x03\x12\x03\x12\x05\x12\xD3\n\x12" +
1136
- "\x03\x13\x03\x13\x03\x14\x06\x14\xD8\n\x14\r\x14\x0E\x14\xD9\x03\x15\x06" +
1137
- "\x15\xDD\n\x15\r\x15\x0E\x15\xDE\x03\x15\x02\x02\x02\x16\x02\x02\x04\x02" +
1138
- "\x06\x02\b\x02\n\x02\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18" +
1139
- "\x02\x1A\x02\x1C\x02\x1E\x02 \x02\"\x02$\x02&\x02(\x02\x02\x03\x03\x02" +
1140
- "\x10\x12\x02\xF0\x02-\x03\x02\x02\x02\x041\x03\x02\x02\x02\x06B\x03\x02" +
1141
- "\x02\x02\bU\x03\x02\x02\x02\n\\\x03\x02\x02\x02\fc\x03\x02\x02\x02\x0E" +
1142
- "j\x03\x02\x02\x02\x10l\x03\x02\x02\x02\x12\x7F\x03\x02\x02\x02\x14\x81" +
1143
- "\x03\x02\x02\x02\x16\x9D\x03\x02\x02\x02\x18\xA5\x03\x02\x02\x02\x1A\xAD" +
1144
- "\x03\x02\x02\x02\x1C\xB5\x03\x02\x02\x02\x1E\xBD\x03\x02\x02\x02 \xC5" +
1145
- "\x03\x02\x02\x02\"\xCD\x03\x02\x02\x02$\xD4\x03\x02\x02\x02&\xD7\x03\x02" +
1146
- "\x02\x02(\xDC\x03\x02\x02\x02*,\x05\x04\x03\x02+*\x03\x02\x02\x02,/\x03" +
1147
- "\x02\x02\x02-+\x03\x02\x02\x02-.\x03\x02\x02\x02.\x03\x03\x02\x02\x02" +
1148
- "/-\x03\x02\x02\x0202\x05&\x14\x0210\x03\x02\x02\x0212\x03\x02\x02\x02" +
1149
- "23\x03\x02\x02\x0234\x07\x03\x02\x024?\x05(\x15\x0257\x05\x06\x04\x02" +
1150
- "65\x03\x02\x02\x0267\x03\x02\x02\x027@\x03\x02\x02\x028;\x05\b\x05\x02" +
1151
- "9;\x05\n\x06\x02:8\x03\x02\x02\x02:9\x03\x02\x02\x02;>\x03\x02\x02\x02" +
1152
- "<:\x03\x02\x02\x02<=\x03\x02\x02\x02=@\x03\x02\x02\x02><\x03\x02\x02\x02" +
1153
- "?6\x03\x02\x02\x02?<\x03\x02\x02\x02@\x05\x03\x02\x02\x02AC\x05&\x14\x02" +
1154
- "BA\x03\x02\x02\x02BC\x03\x02\x02\x02CD\x03\x02\x02\x02DE\x07\x0E\x02\x02" +
1155
- "EF\x05(\x15\x02FJ\x05\x16\f\x02GI\x05\x18\r\x02HG\x03\x02\x02\x02IL\x03" +
1156
- "\x02\x02\x02JH\x03\x02\x02\x02JK\x03\x02\x02\x02KQ\x03\x02\x02\x02LJ\x03" +
1157
- "\x02\x02\x02MP\x05\b\x05\x02NP\x05\n\x06\x02OM\x03\x02\x02\x02ON\x03\x02" +
1158
- "\x02\x02PS\x03\x02\x02\x02QO\x03\x02\x02\x02QR\x03\x02\x02\x02R\x07\x03" +
1159
- "\x02\x02\x02SQ\x03\x02\x02\x02TV\x05&\x14\x02UT\x03\x02\x02\x02UV\x03" +
1160
- "\x02\x02\x02VW\x03\x02\x02\x02WX\x07\x04\x02\x02XY\x05(\x15\x02YZ\x05" +
1161
- "\x14\v\x02Z\t\x03\x02\x02\x02[]\x05&\x14\x02\\[\x03\x02\x02\x02\\]\x03" +
1162
- "\x02\x02\x02]^\x03\x02\x02\x02^_\x07\x05\x02\x02_`\x05(\x15\x02`a\x05" +
1163
- "\x14\v\x02ab\x05\f\x07\x02b\v\x03\x02\x02\x02cd\x07\r\x02\x02df\x05\x0E" +
1164
- "\b\x02eg\x05\x10\t\x02fe\x03\x02\x02\x02gh\x03\x02\x02\x02hf\x03\x02\x02" +
1165
- "\x02hi\x03\x02\x02\x02i\r\x03\x02\x02\x02jk\x05\x10\t\x02k\x0F\x03\x02" +
1166
- "\x02\x02ln\x07\x0F\x02\x02mo\x05\x12\n\x02nm\x03\x02\x02\x02op\x03\x02" +
1167
- "\x02\x02pn\x03\x02\x02\x02pq\x03\x02\x02\x02qz\x03\x02\x02\x02rt\x07\x0F" +
1168
- "\x02\x02su\x05\x12\n\x02ts\x03\x02\x02\x02uv\x03\x02\x02\x02vt\x03\x02" +
1169
- "\x02\x02vw\x03\x02\x02\x02wy\x03\x02\x02\x02xr\x03\x02\x02\x02y|\x03\x02" +
1170
- "\x02\x02zx\x03\x02\x02\x02z{\x03\x02\x02\x02{}\x03\x02\x02\x02|z\x03\x02" +
1171
- "\x02\x02}~\x07\x0F\x02\x02~\x11\x03\x02\x02\x02\x7F\x80\x05(\x15\x02\x80" +
1172
- "\x13\x03\x02\x02\x02\x81\x85\x05\x16\f\x02\x82\x84\x05\x18\r\x02\x83\x82" +
1173
- "\x03\x02\x02\x02\x84\x87\x03\x02\x02\x02\x85\x83\x03\x02\x02\x02\x85\x86" +
1174
- "\x03\x02\x02\x02\x86\x88\x03\x02\x02\x02\x87\x85\x03\x02\x02\x02\x88\x8C" +
1175
- "\x05\x1A\x0E\x02\x89\x8B\x05\x1C\x0F\x02\x8A\x89\x03\x02\x02\x02\x8B\x8E" +
1176
- "\x03\x02\x02\x02\x8C\x8A\x03\x02\x02\x02\x8C\x8D\x03\x02\x02\x02\x8D\x8F" +
1177
- "\x03\x02\x02\x02\x8E\x8C\x03\x02\x02\x02\x8F\x93\x05\x1E\x10\x02\x90\x92" +
1178
- "\x05 \x11\x02\x91\x90\x03\x02\x02\x02\x92\x95\x03\x02\x02\x02\x93\x91" +
1179
- "\x03\x02\x02\x02\x93\x94\x03\x02\x02\x02\x94\x99\x03\x02\x02\x02\x95\x93" +
1180
- "\x03\x02\x02\x02\x96\x98\x05\"\x12\x02\x97\x96\x03\x02\x02\x02\x98\x9B" +
1181
- "\x03\x02\x02\x02\x99\x97\x03\x02\x02\x02\x99\x9A\x03\x02\x02\x02\x9A\x15" +
1182
- "\x03\x02\x02\x02\x9B\x99\x03\x02\x02\x02\x9C\x9E\x05&\x14\x02\x9D\x9C" +
1183
- "\x03\x02\x02\x02\x9D\x9E\x03\x02\x02\x02\x9E\x9F\x03\x02\x02\x02\x9F\xA0" +
1184
- "\x07\x06\x02\x02\xA0\xA2\x05(\x15\x02\xA1\xA3\x05$\x13\x02\xA2\xA1\x03" +
1185
- "\x02\x02\x02\xA2\xA3\x03\x02\x02\x02\xA3\x17\x03\x02\x02\x02\xA4\xA6\x05" +
1186
- "&\x14\x02\xA5\xA4\x03\x02\x02\x02\xA5\xA6\x03\x02\x02\x02\xA6\xA7\x03" +
1187
- "\x02\x02\x02\xA7\xA8\x07\x07\x02\x02\xA8\xAA\x05(\x15\x02\xA9\xAB\x05" +
1188
- "$\x13\x02\xAA\xA9\x03\x02\x02\x02\xAA\xAB\x03\x02\x02\x02\xAB\x19\x03" +
1189
- "\x02\x02\x02\xAC\xAE\x05&\x14\x02\xAD\xAC\x03\x02\x02\x02\xAD\xAE\x03" +
1190
- "\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF\xB0\x07\b\x02\x02\xB0\xB2\x05" +
1191
- "(\x15\x02\xB1\xB3\x05$\x13\x02\xB2\xB1\x03\x02\x02\x02\xB2\xB3\x03\x02" +
1192
- "\x02\x02\xB3\x1B\x03\x02\x02\x02\xB4\xB6\x05&\x14\x02\xB5\xB4\x03\x02" +
1193
- "\x02\x02\xB5\xB6\x03\x02\x02\x02\xB6\xB7\x03\x02\x02\x02\xB7\xB8\x07\t" +
1194
- "\x02\x02\xB8\xBA\x05(\x15\x02\xB9\xBB\x05$\x13\x02\xBA\xB9\x03\x02\x02" +
1195
- "\x02\xBA\xBB\x03\x02\x02\x02\xBB\x1D\x03\x02\x02\x02\xBC\xBE\x05&\x14" +
1196
- "\x02\xBD\xBC\x03\x02\x02\x02\xBD\xBE\x03\x02\x02\x02\xBE\xBF\x03\x02\x02" +
1197
- "\x02\xBF\xC0\x07\n\x02\x02\xC0\xC2\x05(\x15\x02\xC1\xC3\x05$\x13\x02\xC2" +
1198
- "\xC1\x03\x02\x02\x02\xC2\xC3\x03\x02\x02\x02\xC3\x1F\x03\x02\x02\x02\xC4" +
1199
- "\xC6\x05&\x14\x02\xC5\xC4\x03\x02\x02\x02\xC5\xC6\x03\x02\x02\x02\xC6" +
1200
- "\xC7\x03\x02\x02\x02\xC7\xC8\x07\v\x02\x02\xC8\xCA\x05(\x15\x02\xC9\xCB" +
1201
- "\x05$\x13\x02\xCA\xC9\x03\x02\x02\x02\xCA\xCB\x03\x02\x02\x02\xCB!\x03" +
1202
- "\x02\x02\x02\xCC\xCE\x05&\x14\x02\xCD\xCC\x03\x02\x02\x02\xCD\xCE\x03" +
1203
- "\x02\x02\x02\xCE\xCF\x03\x02\x02\x02\xCF\xD0\x07\f\x02\x02\xD0\xD2\x05" +
1204
- "(\x15\x02\xD1\xD3\x05$\x13\x02\xD2\xD1\x03\x02\x02\x02\xD2\xD3\x03\x02" +
1205
- "\x02\x02\xD3#\x03\x02\x02\x02\xD4\xD5\x07\x17\x02\x02\xD5%\x03\x02\x02" +
1206
- "\x02\xD6\xD8\t\x02\x02\x02\xD7\xD6\x03\x02\x02\x02\xD8\xD9\x03\x02\x02" +
1207
- "\x02\xD9\xD7\x03\x02\x02\x02\xD9\xDA\x03\x02\x02\x02\xDA\'\x03\x02\x02" +
1208
- "\x02\xDB\xDD\x07\x14\x02\x02\xDC\xDB\x03\x02\x02\x02\xDD\xDE\x03\x02\x02" +
1209
- "\x02\xDE\xDC\x03\x02\x02\x02\xDE\xDF\x03\x02\x02\x02\xDF)\x03\x02\x02" +
1210
- "\x02&-16:<?BJOQU\\hpvz\x85\x8C\x93\x99\x9D\xA2\xA5\xAA\xAD\xB2\xB5\xBA" +
1211
- "\xBD\xC2\xC5\xCA\xCD\xD2\xD9\xDE";
1862
+ GherkinParser._serializedATN = "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\x19\u01B1\x04" +
1863
+ "\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" +
1864
+ "\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" +
1865
+ "\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" +
1866
+ "\x04\x13\t\x13\x04\x14\t\x14\x04\x15\t\x15\x04\x16\t\x16\x04\x17\t\x17" +
1867
+ "\x03\x02\x07\x020\n\x02\f\x02\x0E\x023\v\x02\x03\x02\x07\x026\n\x02\f" +
1868
+ "\x02\x0E\x029\v\x02\x03\x02\x03\x02\x03\x03\x05\x03>\n\x03\x03\x03\x07" +
1869
+ "\x03A\n\x03\f\x03\x0E\x03D\v\x03\x03\x03\x03\x03\x03\x03\x05\x03I\n\x03" +
1870
+ "\x03\x03\x03\x03\x07\x03M\n\x03\f\x03\x0E\x03P\v\x03\x03\x03\x07\x03S" +
1871
+ "\n\x03\f\x03\x0E\x03V\v\x03\x03\x04\x05\x04Y\n\x04\x03\x04\x07\x04\\\n" +
1872
+ "\x04\f\x04\x0E\x04_\v\x04\x03\x04\x03\x04\x03\x04\x03\x04\x07\x04e\n\x04" +
1873
+ "\f\x04\x0E\x04h\v\x04\x03\x05\x05\x05k\n\x05\x03\x05\x07\x05n\n\x05\f" +
1874
+ "\x05\x0E\x05q\v\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x06\x05\x06x\n" +
1875
+ "\x06\x03\x06\x07\x06{\n\x06\f\x06\x0E\x06~\v\x06\x03\x06\x03\x06\x03\x06" +
1876
+ "\x03\x06\x03\x06\x03\x07\x07\x07\x86\n\x07\f\x07\x0E\x07\x89\v\x07\x03" +
1877
+ "\x07\x03\x07\x06\x07\x8D\n\x07\r\x07\x0E\x07\x8E\x03\x07\x03\x07\x06\x07" +
1878
+ "\x93\n\x07\r\x07\x0E\x07\x94\x03\b\x03\b\x03\t\x03\t\x03\t\x03\t\x07\t" +
1879
+ "\x9D\n\t\f\t\x0E\t\xA0\v\t\x03\t\x03\t\x06\t\xA4\n\t\r\t\x0E\t\xA5\x03" +
1880
+ "\n\x05\n\xA9\n\n\x03\v\x03\v\x07\v\xAD\n\v\f\v\x0E\v\xB0\v\v\x03\v\x03" +
1881
+ "\v\x07\v\xB4\n\v\f\v\x0E\v\xB7\v\v\x03\v\x03\v\x07\v\xBB\n\v\f\v\x0E\v" +
1882
+ "\xBE\v\v\x03\v\x07\v\xC1\n\v\f\v\x0E\v\xC4\v\v\x03\f\x05\f\xC7\n\f\x03" +
1883
+ "\f\x07\f\xCA\n\f\f\f\x0E\f\xCD\v\f\x03\f\x03\f\x03\f\x03\f\x03\f\x06\f" +
1884
+ "\xD4\n\f\r\f\x0E\f\xD5\x05\f\xD8\n\f\x03\f\x06\f\xDB\n\f\r\f\x0E\f\xDC" +
1885
+ "\x05\f\xDF\n\f\x03\r\x05\r\xE2\n\r\x03\r\x07\r\xE5\n\r\f\r\x0E\r\xE8\v" +
1886
+ "\r\x03\r\x03\r\x03\r\x03\r\x03\r\x06\r\xEF\n\r\r\r\x0E\r\xF0\x05\r\xF3" +
1887
+ "\n\r\x03\r\x06\r\xF6\n\r\r\r\x0E\r\xF7\x05\r\xFA\n\r\x03\x0E\x05\x0E\xFD" +
1888
+ "\n\x0E\x03\x0E\x07\x0E\u0100\n\x0E\f\x0E\x0E\x0E\u0103\v\x0E\x03\x0E\x03" +
1889
+ "\x0E\x03\x0E\x03\x0E\x03\x0E\x06\x0E\u010A\n\x0E\r\x0E\x0E\x0E\u010B\x05" +
1890
+ "\x0E\u010E\n\x0E\x03\x0E\x06\x0E\u0111\n\x0E\r\x0E\x0E\x0E\u0112\x05\x0E" +
1891
+ "\u0115\n\x0E\x03\x0F\x05\x0F\u0118\n\x0F\x03\x0F\x07\x0F\u011B\n\x0F\f" +
1892
+ "\x0F\x0E\x0F\u011E\v\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x06\x0F" +
1893
+ "\u0125\n\x0F\r\x0F\x0E\x0F\u0126\x05\x0F\u0129\n\x0F\x03\x0F\x06\x0F\u012C" +
1894
+ "\n\x0F\r\x0F\x0E\x0F\u012D\x05\x0F\u0130\n\x0F\x03\x10\x05\x10\u0133\n" +
1895
+ "\x10\x03\x10\x07\x10\u0136\n\x10\f\x10\x0E\x10\u0139\v\x10\x03\x10\x03" +
1896
+ "\x10\x03\x10\x03\x10\x03\x10\x06\x10\u0140\n\x10\r\x10\x0E\x10\u0141\x05" +
1897
+ "\x10\u0144\n\x10\x03\x10\x06\x10\u0147\n\x10\r\x10\x0E\x10\u0148\x05\x10" +
1898
+ "\u014B\n\x10\x03\x11\x05\x11\u014E\n\x11\x03\x11\x07\x11\u0151\n\x11\f" +
1899
+ "\x11\x0E\x11\u0154\v\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x11\x06\x11" +
1900
+ "\u015B\n\x11\r\x11\x0E\x11\u015C\x05\x11\u015F\n\x11\x03\x11\x06\x11\u0162" +
1901
+ "\n\x11\r\x11\x0E\x11\u0163\x05\x11\u0166\n\x11\x03\x12\x05\x12\u0169\n" +
1902
+ "\x12\x03\x12\x07\x12\u016C\n\x12\f\x12\x0E\x12\u016F\v\x12\x03\x12\x03" +
1903
+ "\x12\x03\x12\x03\x12\x03\x12\x06\x12\u0176\n\x12\r\x12\x0E\x12\u0177\x05" +
1904
+ "\x12\u017A\n\x12\x03\x12\x06\x12\u017D\n\x12\r\x12\x0E\x12\u017E\x05\x12" +
1905
+ "\u0181\n\x12\x03\x13\x03\x13\x03\x14\x07\x14\u0186\n\x14\f\x14\x0E\x14" +
1906
+ "\u0189\v\x14\x03\x14\x03\x14\x07\x14\u018D\n\x14\f\x14\x0E\x14\u0190\v" +
1907
+ "\x14\x06\x14\u0192\n\x14\r\x14\x0E\x14\u0193\x03\x15\x07\x15\u0197\n\x15" +
1908
+ "\f\x15\x0E\x15\u019A\v\x15\x03\x15\x03\x15\x07\x15\u019E\n\x15\f\x15\x0E" +
1909
+ "\x15\u01A1\v\x15\x06\x15\u01A3\n\x15\r\x15\x0E\x15\u01A4\x03\x16\x06\x16" +
1910
+ "\u01A8\n\x16\r\x16\x0E\x16\u01A9\x03\x17\x06\x17\u01AD\n\x17\r\x17\x0E" +
1911
+ "\x17\u01AE\x03\x17\x02\x02\x02\x18\x02\x02\x04\x02\x06\x02\b\x02\n\x02" +
1912
+ "\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02" +
1913
+ "\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02\x02\x05\x04\x02\x10\x11\x14" +
1914
+ "\x14\x03\x02\x10\x14\x03\x02\x16\x17\x02\u01E5\x021\x03\x02\x02\x02\x04" +
1915
+ "=\x03\x02\x02\x02\x06X\x03\x02\x02\x02\bj\x03\x02\x02\x02\nw\x03\x02\x02" +
1916
+ "\x02\f\x87\x03\x02\x02\x02\x0E\x96\x03\x02\x02\x02\x10\x98\x03\x02\x02" +
1917
+ "\x02\x12\xA8\x03\x02\x02\x02\x14\xAA\x03\x02\x02\x02\x16\xC6\x03\x02\x02" +
1918
+ "\x02\x18\xE1\x03\x02\x02\x02\x1A\xFC\x03\x02\x02\x02\x1C\u0117\x03\x02" +
1919
+ "\x02\x02\x1E\u0132\x03\x02\x02\x02 \u014D\x03\x02\x02\x02\"\u0168\x03" +
1920
+ "\x02\x02\x02$\u0182\x03\x02\x02\x02&\u0187\x03\x02\x02\x02(\u0198\x03" +
1921
+ "\x02\x02\x02*\u01A7\x03\x02\x02\x02,\u01AC\x03\x02\x02\x02.0\x05\x04\x03" +
1922
+ "\x02/.\x03\x02\x02\x0203\x03\x02\x02\x021/\x03\x02\x02\x0212\x03\x02\x02" +
1923
+ "\x0227\x03\x02\x02\x0231\x03\x02\x02\x0246\x07\x17\x02\x0254\x03\x02\x02" +
1924
+ "\x0269\x03\x02\x02\x0275\x03\x02\x02\x0278\x03\x02\x02\x028:\x03\x02\x02" +
1925
+ "\x0297\x03\x02\x02\x02:;\x07\x02\x02\x03;\x03\x03\x02\x02\x02<>\x05&\x14" +
1926
+ "\x02=<\x03\x02\x02\x02=>\x03\x02\x02\x02>B\x03\x02\x02\x02?A\x07\x17\x02" +
1927
+ "\x02@?\x03\x02\x02\x02AD\x03\x02\x02\x02B@\x03\x02\x02\x02BC\x03\x02\x02" +
1928
+ "\x02CE\x03\x02\x02\x02DB\x03\x02\x02\x02EF\x07\x03\x02\x02FH\x05,\x17" +
1929
+ "\x02GI\x05\x06\x04\x02HG\x03\x02\x02\x02HI\x03\x02\x02\x02IN\x03\x02\x02" +
1930
+ "\x02JM\x05\b\x05\x02KM\x05\n\x06\x02LJ\x03\x02\x02\x02LK\x03\x02\x02\x02" +
1931
+ "MP\x03\x02\x02\x02NL\x03\x02\x02\x02NO\x03\x02\x02\x02OT\x03\x02\x02\x02" +
1932
+ "PN\x03\x02\x02\x02QS\x07\x17\x02\x02RQ\x03\x02\x02\x02SV\x03\x02\x02\x02" +
1933
+ "TR\x03\x02\x02\x02TU\x03\x02\x02\x02U\x05\x03\x02\x02\x02VT\x03\x02\x02" +
1934
+ "\x02WY\x05&\x14\x02XW\x03\x02\x02\x02XY\x03\x02\x02\x02Y]\x03\x02\x02" +
1935
+ "\x02Z\\\x07\x17\x02\x02[Z\x03\x02\x02\x02\\_\x03\x02\x02\x02][\x03\x02" +
1936
+ "\x02\x02]^\x03\x02\x02\x02^`\x03\x02\x02\x02_]\x03\x02\x02\x02`a\x07\x0E" +
1937
+ "\x02\x02ab\x05,\x17\x02bf\x05\x16\f\x02ce\x05\x18\r\x02dc\x03\x02\x02" +
1938
+ "\x02eh\x03\x02\x02\x02fd\x03\x02\x02\x02fg\x03\x02\x02\x02g\x07\x03\x02" +
1939
+ "\x02\x02hf\x03\x02\x02\x02ik\x05&\x14\x02ji\x03\x02\x02\x02jk\x03\x02" +
1940
+ "\x02\x02ko\x03\x02\x02\x02ln\x07\x17\x02\x02ml\x03\x02\x02\x02nq\x03\x02" +
1941
+ "\x02\x02om\x03\x02\x02\x02op\x03\x02\x02\x02pr\x03\x02\x02\x02qo\x03\x02" +
1942
+ "\x02\x02rs\x07\x04\x02\x02st\x05,\x17\x02tu\x05\x14\v\x02u\t\x03\x02\x02" +
1943
+ "\x02vx\x05&\x14\x02wv\x03\x02\x02\x02wx\x03\x02\x02\x02x|\x03\x02\x02" +
1944
+ "\x02y{\x07\x17\x02\x02zy\x03\x02\x02\x02{~\x03\x02\x02\x02|z\x03\x02\x02" +
1945
+ "\x02|}\x03\x02\x02\x02}\x7F\x03\x02\x02\x02~|\x03\x02\x02\x02\x7F\x80" +
1946
+ "\x07\x05\x02\x02\x80\x81\x05,\x17\x02\x81\x82\x05\x14\v\x02\x82\x83\x05" +
1947
+ "\f\x07\x02\x83\v\x03\x02\x02\x02\x84\x86\x07\x17\x02\x02\x85\x84\x03\x02" +
1948
+ "\x02\x02\x86\x89\x03\x02\x02\x02\x87\x85\x03\x02\x02\x02\x87\x88\x03\x02" +
1949
+ "\x02\x02\x88\x8A\x03\x02\x02\x02\x89\x87\x03\x02\x02\x02\x8A\x8C\x07\r" +
1950
+ "\x02\x02\x8B\x8D\x07\x17\x02\x02\x8C\x8B\x03\x02\x02\x02\x8D\x8E\x03\x02" +
1951
+ "\x02\x02\x8E\x8C\x03\x02\x02\x02\x8E\x8F\x03\x02\x02\x02\x8F\x90\x03\x02" +
1952
+ "\x02\x02\x90\x92\x05\x0E\b\x02\x91\x93\x05\x10\t\x02\x92\x91\x03\x02\x02" +
1953
+ "\x02\x93\x94\x03\x02\x02\x02\x94\x92\x03\x02\x02\x02\x94\x95\x03\x02\x02" +
1954
+ "\x02\x95\r\x03\x02\x02\x02\x96\x97\x05\x10\t\x02\x97\x0F\x03\x02\x02\x02" +
1955
+ "\x98\x99\x07\x0F\x02\x02\x99\x9E\x05\x12\n\x02\x9A\x9B\x07\x0F\x02\x02" +
1956
+ "\x9B\x9D\x05\x12\n\x02\x9C\x9A\x03\x02\x02\x02\x9D\xA0\x03\x02\x02\x02" +
1957
+ "\x9E\x9C\x03\x02\x02\x02\x9E\x9F\x03\x02\x02\x02\x9F\xA1\x03\x02\x02\x02" +
1958
+ "\xA0\x9E\x03\x02\x02\x02\xA1\xA3\x07\x0F\x02\x02\xA2\xA4\x07\x17\x02\x02" +
1959
+ "\xA3\xA2\x03\x02\x02\x02\xA4\xA5\x03\x02\x02\x02\xA5\xA3\x03\x02\x02\x02" +
1960
+ "\xA5\xA6\x03\x02\x02\x02\xA6\x11\x03\x02\x02\x02\xA7\xA9\x05*\x16\x02" +
1961
+ "\xA8\xA7\x03\x02\x02\x02\xA8\xA9\x03\x02\x02\x02\xA9\x13\x03\x02\x02\x02" +
1962
+ "\xAA\xAE\x05\x16\f\x02\xAB\xAD\x05\x18\r\x02\xAC\xAB\x03\x02\x02\x02\xAD" +
1963
+ "\xB0\x03\x02\x02\x02\xAE\xAC\x03\x02\x02\x02\xAE\xAF\x03\x02\x02\x02\xAF" +
1964
+ "\xB1\x03\x02\x02\x02\xB0\xAE\x03\x02\x02\x02\xB1\xB5\x05\x1A\x0E\x02\xB2" +
1965
+ "\xB4\x05\x1C\x0F\x02\xB3\xB2\x03\x02\x02\x02\xB4\xB7\x03\x02\x02\x02\xB5" +
1966
+ "\xB3\x03\x02\x02\x02\xB5\xB6\x03\x02\x02\x02\xB6\xB8\x03\x02\x02\x02\xB7" +
1967
+ "\xB5\x03\x02\x02\x02\xB8\xBC\x05\x1E\x10\x02\xB9\xBB\x05 \x11\x02\xBA" +
1968
+ "\xB9\x03\x02\x02\x02\xBB\xBE\x03\x02\x02\x02\xBC\xBA\x03\x02\x02\x02\xBC" +
1969
+ "\xBD\x03\x02\x02\x02\xBD\xC2\x03\x02\x02\x02\xBE\xBC\x03\x02\x02\x02\xBF" +
1970
+ "\xC1\x05\"\x12\x02\xC0\xBF\x03\x02\x02\x02\xC1\xC4\x03\x02\x02\x02\xC2" +
1971
+ "\xC0\x03\x02\x02\x02\xC2\xC3\x03\x02\x02\x02\xC3\x15\x03\x02\x02\x02\xC4" +
1972
+ "\xC2\x03\x02\x02\x02\xC5\xC7\x05&\x14\x02\xC6\xC5\x03\x02\x02\x02\xC6" +
1973
+ "\xC7\x03\x02\x02\x02\xC7\xCB\x03\x02\x02\x02\xC8\xCA\x07\x17\x02\x02\xC9" +
1974
+ "\xC8\x03\x02\x02\x02\xCA\xCD\x03\x02\x02\x02\xCB\xC9\x03\x02\x02\x02\xCB" +
1975
+ "\xCC\x03\x02\x02\x02\xCC\xCE\x03\x02\x02\x02\xCD\xCB\x03\x02\x02\x02\xCE" +
1976
+ "\xCF\x07\x06\x02\x02\xCF\xDE\x05,\x17\x02\xD0\xD1\x07\x17\x02\x02\xD1" +
1977
+ "\xD3\x05$\x13\x02\xD2\xD4\x07\x17\x02\x02\xD3\xD2\x03\x02\x02\x02\xD4" +
1978
+ "\xD5\x03\x02\x02\x02\xD5\xD3\x03\x02\x02\x02\xD5\xD6\x03\x02\x02\x02\xD6" +
1979
+ "\xD8\x03\x02\x02\x02\xD7\xD0\x03\x02\x02\x02\xD7\xD8\x03\x02\x02\x02\xD8" +
1980
+ "\xDF\x03\x02\x02\x02\xD9\xDB\x07\x17\x02\x02\xDA\xD9\x03\x02\x02\x02\xDB" +
1981
+ "\xDC\x03\x02\x02\x02\xDC\xDA\x03\x02\x02\x02\xDC\xDD\x03\x02\x02\x02\xDD" +
1982
+ "\xDF\x03\x02\x02\x02\xDE\xD7\x03\x02\x02\x02\xDE\xDA\x03\x02\x02\x02\xDF" +
1983
+ "\x17\x03\x02\x02\x02\xE0\xE2\x05&\x14\x02\xE1\xE0\x03\x02\x02\x02\xE1" +
1984
+ "\xE2\x03\x02\x02\x02\xE2\xE6\x03\x02\x02\x02\xE3\xE5\x07\x17\x02\x02\xE4" +
1985
+ "\xE3\x03\x02\x02\x02\xE5\xE8\x03\x02\x02\x02\xE6\xE4\x03\x02\x02\x02\xE6" +
1986
+ "\xE7\x03\x02\x02\x02\xE7\xE9\x03\x02\x02\x02\xE8\xE6\x03\x02\x02\x02\xE9" +
1987
+ "\xEA\x07\x07\x02\x02\xEA\xF9\x05,\x17\x02\xEB\xEC\x07\x17\x02\x02\xEC" +
1988
+ "\xEE\x05$\x13\x02\xED\xEF\x07\x17\x02\x02\xEE\xED\x03\x02\x02\x02\xEF" +
1989
+ "\xF0\x03\x02\x02\x02\xF0\xEE\x03\x02\x02\x02\xF0\xF1\x03\x02\x02\x02\xF1" +
1990
+ "\xF3\x03\x02\x02\x02\xF2\xEB\x03\x02\x02\x02\xF2\xF3\x03\x02\x02\x02\xF3" +
1991
+ "\xFA\x03\x02\x02\x02\xF4\xF6\x07\x17\x02\x02\xF5\xF4\x03\x02\x02\x02\xF6" +
1992
+ "\xF7\x03\x02\x02\x02\xF7\xF5\x03\x02\x02\x02\xF7\xF8\x03\x02\x02\x02\xF8" +
1993
+ "\xFA\x03\x02\x02\x02\xF9\xF2\x03\x02\x02\x02\xF9\xF5\x03\x02\x02\x02\xFA" +
1994
+ "\x19\x03\x02\x02\x02\xFB\xFD\x05&\x14\x02\xFC\xFB\x03\x02\x02\x02\xFC" +
1995
+ "\xFD\x03\x02\x02\x02\xFD\u0101\x03\x02\x02\x02\xFE\u0100\x07\x17\x02\x02" +
1996
+ "\xFF\xFE\x03\x02\x02\x02\u0100\u0103\x03\x02\x02\x02\u0101\xFF\x03\x02" +
1997
+ "\x02\x02\u0101\u0102\x03\x02\x02\x02\u0102\u0104\x03\x02\x02\x02\u0103" +
1998
+ "\u0101\x03\x02\x02\x02\u0104\u0105\x07\b\x02\x02\u0105\u0114\x05,\x17" +
1999
+ "\x02\u0106\u0107\x07\x17\x02\x02\u0107\u0109\x05$\x13\x02\u0108\u010A" +
2000
+ "\x07\x17\x02\x02\u0109\u0108\x03\x02\x02\x02\u010A\u010B\x03\x02\x02\x02" +
2001
+ "\u010B\u0109\x03\x02\x02\x02\u010B\u010C\x03\x02\x02\x02\u010C\u010E\x03" +
2002
+ "\x02\x02\x02\u010D\u0106\x03\x02\x02\x02\u010D\u010E\x03\x02\x02\x02\u010E" +
2003
+ "\u0115\x03\x02\x02\x02\u010F\u0111\x07\x17\x02\x02\u0110\u010F\x03\x02" +
2004
+ "\x02\x02\u0111\u0112\x03\x02\x02\x02\u0112\u0110\x03\x02\x02\x02\u0112" +
2005
+ "\u0113\x03\x02\x02\x02\u0113\u0115\x03\x02\x02\x02\u0114\u010D\x03\x02" +
2006
+ "\x02\x02\u0114\u0110\x03\x02\x02\x02\u0115\x1B\x03\x02\x02\x02\u0116\u0118" +
2007
+ "\x05&\x14\x02\u0117\u0116\x03\x02\x02\x02\u0117\u0118\x03\x02\x02\x02" +
2008
+ "\u0118\u011C\x03\x02\x02\x02\u0119\u011B\x07\x17\x02\x02\u011A\u0119\x03" +
2009
+ "\x02\x02\x02\u011B\u011E\x03\x02\x02\x02\u011C\u011A\x03\x02\x02\x02\u011C" +
2010
+ "\u011D\x03\x02\x02\x02\u011D\u011F\x03\x02\x02\x02\u011E\u011C\x03\x02" +
2011
+ "\x02\x02\u011F\u0120\x07\t\x02\x02\u0120\u012F\x05,\x17\x02\u0121\u0122" +
2012
+ "\x07\x17\x02\x02\u0122\u0124\x05$\x13\x02\u0123\u0125\x07\x17\x02\x02" +
2013
+ "\u0124\u0123\x03\x02\x02\x02\u0125\u0126\x03\x02\x02\x02\u0126\u0124\x03" +
2014
+ "\x02\x02\x02\u0126\u0127\x03\x02\x02\x02\u0127\u0129\x03\x02\x02\x02\u0128" +
2015
+ "\u0121\x03\x02\x02\x02\u0128\u0129\x03\x02\x02\x02\u0129\u0130\x03\x02" +
2016
+ "\x02\x02\u012A\u012C\x07\x17\x02\x02\u012B\u012A\x03\x02\x02\x02\u012C" +
2017
+ "\u012D\x03\x02\x02\x02\u012D\u012B\x03\x02\x02\x02\u012D\u012E\x03\x02" +
2018
+ "\x02\x02\u012E\u0130\x03\x02\x02\x02\u012F\u0128\x03\x02\x02\x02\u012F" +
2019
+ "\u012B\x03\x02\x02\x02\u0130\x1D\x03\x02\x02\x02\u0131\u0133\x05(\x15" +
2020
+ "\x02\u0132\u0131\x03\x02\x02\x02\u0132\u0133\x03\x02\x02\x02\u0133\u0137" +
2021
+ "\x03\x02\x02\x02\u0134\u0136\x07\x17\x02\x02\u0135\u0134\x03\x02\x02\x02" +
2022
+ "\u0136\u0139\x03\x02\x02\x02\u0137\u0135\x03\x02\x02\x02\u0137\u0138\x03" +
2023
+ "\x02\x02\x02\u0138\u013A\x03\x02\x02\x02\u0139\u0137\x03\x02\x02\x02\u013A" +
2024
+ "\u013B\x07\n\x02\x02\u013B\u014A\x05,\x17\x02\u013C\u013D\x07\x17\x02" +
2025
+ "\x02\u013D\u013F\x05$\x13\x02\u013E\u0140\x07\x17\x02\x02\u013F\u013E" +
2026
+ "\x03\x02\x02\x02\u0140\u0141\x03\x02\x02\x02\u0141\u013F\x03\x02\x02\x02" +
2027
+ "\u0141\u0142\x03\x02\x02\x02\u0142\u0144\x03\x02\x02\x02\u0143\u013C\x03" +
2028
+ "\x02\x02\x02\u0143\u0144\x03\x02\x02\x02\u0144\u014B\x03\x02\x02\x02\u0145" +
2029
+ "\u0147\x07\x17\x02\x02\u0146\u0145\x03\x02\x02\x02\u0147\u0148\x03\x02" +
2030
+ "\x02\x02\u0148\u0146\x03\x02\x02\x02\u0148\u0149\x03\x02\x02\x02\u0149" +
2031
+ "\u014B\x03\x02\x02\x02\u014A\u0143\x03\x02\x02\x02\u014A\u0146\x03\x02" +
2032
+ "\x02\x02\u014B\x1F\x03\x02\x02\x02\u014C\u014E\x05(\x15\x02\u014D\u014C" +
2033
+ "\x03\x02\x02\x02\u014D\u014E\x03\x02\x02\x02\u014E\u0152\x03\x02\x02\x02" +
2034
+ "\u014F\u0151\x07\x17\x02\x02\u0150\u014F\x03\x02\x02\x02\u0151\u0154\x03" +
2035
+ "\x02\x02\x02\u0152\u0150\x03\x02\x02\x02\u0152\u0153\x03\x02\x02\x02\u0153" +
2036
+ "\u0155\x03\x02\x02\x02\u0154\u0152\x03\x02\x02\x02\u0155\u0156\x07\v\x02" +
2037
+ "\x02\u0156\u0165\x05,\x17\x02\u0157\u0158\x07\x17\x02\x02\u0158\u015A" +
2038
+ "\x05$\x13\x02\u0159\u015B\x07\x17\x02\x02\u015A\u0159\x03\x02\x02\x02" +
2039
+ "\u015B\u015C\x03\x02\x02\x02\u015C\u015A\x03\x02\x02\x02\u015C\u015D\x03" +
2040
+ "\x02\x02\x02\u015D\u015F\x03\x02\x02\x02\u015E\u0157\x03\x02\x02\x02\u015E" +
2041
+ "\u015F\x03\x02\x02\x02\u015F\u0166\x03\x02\x02\x02\u0160\u0162\x07\x17" +
2042
+ "\x02\x02\u0161\u0160\x03\x02\x02\x02\u0162\u0163\x03\x02\x02\x02\u0163" +
2043
+ "\u0161\x03\x02\x02\x02\u0163\u0164\x03\x02\x02\x02\u0164\u0166\x03\x02" +
2044
+ "\x02\x02\u0165\u015E\x03\x02\x02\x02\u0165\u0161\x03\x02\x02\x02\u0166" +
2045
+ "!\x03\x02\x02\x02\u0167\u0169\x05(\x15\x02\u0168\u0167\x03\x02\x02\x02" +
2046
+ "\u0168\u0169\x03\x02\x02\x02\u0169\u016D\x03\x02\x02\x02\u016A\u016C\x07" +
2047
+ "\x17\x02\x02\u016B\u016A\x03\x02\x02\x02\u016C\u016F\x03\x02\x02\x02\u016D" +
2048
+ "\u016B\x03\x02\x02\x02\u016D\u016E\x03\x02\x02\x02\u016E\u0170\x03\x02" +
2049
+ "\x02\x02\u016F\u016D\x03\x02\x02\x02\u0170\u0171\x07\f\x02\x02\u0171\u0180" +
2050
+ "\x05,\x17\x02\u0172\u0173\x07\x17\x02\x02\u0173\u0175\x05$\x13\x02\u0174" +
2051
+ "\u0176\x07\x17\x02\x02\u0175\u0174\x03\x02\x02\x02\u0176\u0177\x03\x02" +
2052
+ "\x02\x02\u0177\u0175\x03\x02\x02\x02\u0177\u0178\x03\x02\x02\x02\u0178" +
2053
+ "\u017A\x03\x02\x02\x02\u0179\u0172\x03\x02\x02\x02\u0179\u017A\x03\x02" +
2054
+ "\x02\x02\u017A\u0181\x03\x02\x02\x02\u017B\u017D\x07\x17\x02\x02\u017C" +
2055
+ "\u017B\x03\x02\x02\x02\u017D\u017E\x03\x02\x02\x02\u017E\u017C\x03\x02" +
2056
+ "\x02\x02\u017E\u017F\x03\x02\x02\x02\u017F\u0181\x03\x02\x02\x02\u0180" +
2057
+ "\u0179\x03\x02\x02\x02\u0180\u017C\x03\x02\x02\x02\u0181#\x03\x02\x02" +
2058
+ "\x02\u0182\u0183\x07\x19\x02\x02\u0183%\x03\x02\x02\x02\u0184\u0186\x07" +
2059
+ "\x17\x02\x02\u0185\u0184\x03\x02\x02\x02\u0186\u0189\x03\x02\x02\x02\u0187" +
2060
+ "\u0185\x03\x02\x02\x02\u0187\u0188\x03\x02\x02\x02\u0188\u0191\x03\x02" +
2061
+ "\x02\x02\u0189\u0187\x03\x02\x02\x02\u018A\u018E\t\x02\x02\x02\u018B\u018D" +
2062
+ "\x07\x17\x02\x02\u018C\u018B\x03\x02\x02\x02\u018D\u0190\x03\x02\x02\x02" +
2063
+ "\u018E\u018C\x03\x02\x02\x02\u018E\u018F\x03\x02\x02\x02\u018F\u0192\x03" +
2064
+ "\x02\x02\x02\u0190\u018E\x03\x02\x02\x02\u0191\u018A\x03\x02\x02\x02\u0192" +
2065
+ "\u0193\x03\x02\x02\x02\u0193\u0191\x03\x02\x02\x02\u0193\u0194\x03\x02" +
2066
+ "\x02\x02\u0194\'\x03\x02\x02\x02\u0195\u0197\x07\x17\x02\x02\u0196\u0195" +
2067
+ "\x03\x02\x02\x02\u0197\u019A\x03\x02\x02\x02\u0198\u0196\x03\x02\x02\x02" +
2068
+ "\u0198\u0199\x03\x02\x02\x02\u0199\u01A2\x03\x02\x02\x02\u019A\u0198\x03" +
2069
+ "\x02\x02\x02\u019B\u019F\t\x03\x02\x02\u019C\u019E\x07\x17\x02\x02\u019D" +
2070
+ "\u019C\x03\x02\x02\x02\u019E\u01A1\x03\x02\x02\x02\u019F\u019D\x03\x02" +
2071
+ "\x02\x02\u019F\u01A0\x03\x02\x02\x02\u01A0\u01A3\x03\x02\x02\x02\u01A1" +
2072
+ "\u019F\x03\x02\x02\x02\u01A2\u019B\x03\x02\x02\x02\u01A3\u01A4\x03\x02" +
2073
+ "\x02\x02\u01A4\u01A2\x03\x02\x02\x02\u01A4\u01A5\x03\x02\x02\x02\u01A5" +
2074
+ ")\x03\x02\x02\x02\u01A6\u01A8\x07\x16\x02\x02\u01A7\u01A6\x03\x02\x02" +
2075
+ "\x02\u01A8\u01A9\x03\x02\x02\x02\u01A9\u01A7\x03\x02\x02\x02\u01A9\u01AA" +
2076
+ "\x03\x02\x02\x02\u01AA+\x03\x02\x02\x02\u01AB\u01AD\t\x04\x02\x02\u01AC" +
2077
+ "\u01AB\x03\x02\x02\x02\u01AD\u01AE\x03\x02\x02\x02\u01AE\u01AC\x03\x02" +
2078
+ "\x02\x02\u01AE\u01AF\x03\x02\x02\x02\u01AF-\x03\x02\x02\x02M17=BHLNTX" +
2079
+ "]fjow|\x87\x8E\x94\x9E\xA5\xA8\xAE\xB5\xBC\xC2\xC6\xCB\xD5\xD7\xDC\xDE" +
2080
+ "\xE1\xE6\xF0\xF2\xF7\xF9\xFC\u0101\u010B\u010D\u0112\u0114\u0117\u011C" +
2081
+ "\u0126\u0128\u012D\u012F\u0132\u0137\u0141\u0143\u0148\u014A\u014D\u0152" +
2082
+ "\u015C\u015E\u0163\u0165\u0168\u016D\u0177\u0179\u017E\u0180\u0187\u018E" +
2083
+ "\u0193\u0198\u019F\u01A4\u01A9\u01AE";
1212
2084
  class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
2085
+ EOF() { return this.getToken(GherkinParser.EOF, 0); }
1213
2086
  feature(i) {
1214
2087
  if (i === undefined) {
1215
2088
  return this.getRuleContexts(FeatureContext);
@@ -1218,6 +2091,14 @@ class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
1218
2091
  return this.getRuleContext(i, FeatureContext);
1219
2092
  }
1220
2093
  }
2094
+ NEWLINE(i) {
2095
+ if (i === undefined) {
2096
+ return this.getTokens(GherkinParser.NEWLINE);
2097
+ }
2098
+ else {
2099
+ return this.getToken(GherkinParser.NEWLINE, i);
2100
+ }
2101
+ }
1221
2102
  constructor(parent, invokingState) {
1222
2103
  super(parent, invokingState);
1223
2104
  }
@@ -1236,12 +2117,20 @@ class FeatureFileContext extends ParserRuleContext_1.ParserRuleContext {
1236
2117
  exports.FeatureFileContext = FeatureFileContext;
1237
2118
  class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
1238
2119
  FEATURE() { return this.getToken(GherkinParser.FEATURE, 0); }
1239
- contentText() {
1240
- return this.getRuleContext(0, ContentTextContext);
2120
+ multilineText() {
2121
+ return this.getRuleContext(0, MultilineTextContext);
1241
2122
  }
1242
2123
  tags() {
1243
2124
  return this.tryGetRuleContext(0, TagsContext);
1244
2125
  }
2126
+ NEWLINE(i) {
2127
+ if (i === undefined) {
2128
+ return this.getTokens(GherkinParser.NEWLINE);
2129
+ }
2130
+ else {
2131
+ return this.getToken(GherkinParser.NEWLINE, i);
2132
+ }
2133
+ }
1245
2134
  background() {
1246
2135
  return this.tryGetRuleContext(0, BackgroundContext);
1247
2136
  }
@@ -1279,8 +2168,8 @@ class FeatureContext extends ParserRuleContext_1.ParserRuleContext {
1279
2168
  exports.FeatureContext = FeatureContext;
1280
2169
  class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1281
2170
  BACKGROUND() { return this.getToken(GherkinParser.BACKGROUND, 0); }
1282
- contentText() {
1283
- return this.getRuleContext(0, ContentTextContext);
2171
+ multilineText() {
2172
+ return this.getRuleContext(0, MultilineTextContext);
1284
2173
  }
1285
2174
  givenStep() {
1286
2175
  return this.getRuleContext(0, GivenStepContext);
@@ -1288,28 +2177,20 @@ class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1288
2177
  tags() {
1289
2178
  return this.tryGetRuleContext(0, TagsContext);
1290
2179
  }
1291
- andGivenStep(i) {
1292
- if (i === undefined) {
1293
- return this.getRuleContexts(AndGivenStepContext);
1294
- }
1295
- else {
1296
- return this.getRuleContext(i, AndGivenStepContext);
1297
- }
1298
- }
1299
- scenario(i) {
2180
+ NEWLINE(i) {
1300
2181
  if (i === undefined) {
1301
- return this.getRuleContexts(ScenarioContext);
2182
+ return this.getTokens(GherkinParser.NEWLINE);
1302
2183
  }
1303
2184
  else {
1304
- return this.getRuleContext(i, ScenarioContext);
2185
+ return this.getToken(GherkinParser.NEWLINE, i);
1305
2186
  }
1306
2187
  }
1307
- scenarioOutline(i) {
2188
+ andGivenStep(i) {
1308
2189
  if (i === undefined) {
1309
- return this.getRuleContexts(ScenarioOutlineContext);
2190
+ return this.getRuleContexts(AndGivenStepContext);
1310
2191
  }
1311
2192
  else {
1312
- return this.getRuleContext(i, ScenarioOutlineContext);
2193
+ return this.getRuleContext(i, AndGivenStepContext);
1313
2194
  }
1314
2195
  }
1315
2196
  constructor(parent, invokingState) {
@@ -1330,8 +2211,8 @@ class BackgroundContext extends ParserRuleContext_1.ParserRuleContext {
1330
2211
  exports.BackgroundContext = BackgroundContext;
1331
2212
  class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1332
2213
  SCENARIO() { return this.getToken(GherkinParser.SCENARIO, 0); }
1333
- contentText() {
1334
- return this.getRuleContext(0, ContentTextContext);
2214
+ multilineText() {
2215
+ return this.getRuleContext(0, MultilineTextContext);
1335
2216
  }
1336
2217
  step() {
1337
2218
  return this.getRuleContext(0, StepContext);
@@ -1339,6 +2220,14 @@ class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1339
2220
  tags() {
1340
2221
  return this.tryGetRuleContext(0, TagsContext);
1341
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
+ }
1342
2231
  constructor(parent, invokingState) {
1343
2232
  super(parent, invokingState);
1344
2233
  }
@@ -1357,8 +2246,8 @@ class ScenarioContext extends ParserRuleContext_1.ParserRuleContext {
1357
2246
  exports.ScenarioContext = ScenarioContext;
1358
2247
  class ScenarioOutlineContext extends ParserRuleContext_1.ParserRuleContext {
1359
2248
  SCENARIO_OUTLINE() { return this.getToken(GherkinParser.SCENARIO_OUTLINE, 0); }
1360
- contentText() {
1361
- return this.getRuleContext(0, ContentTextContext);
2249
+ multilineText() {
2250
+ return this.getRuleContext(0, MultilineTextContext);
1362
2251
  }
1363
2252
  step() {
1364
2253
  return this.getRuleContext(0, StepContext);
@@ -1369,6 +2258,14 @@ class ScenarioOutlineContext extends ParserRuleContext_1.ParserRuleContext {
1369
2258
  tags() {
1370
2259
  return this.tryGetRuleContext(0, TagsContext);
1371
2260
  }
2261
+ NEWLINE(i) {
2262
+ if (i === undefined) {
2263
+ return this.getTokens(GherkinParser.NEWLINE);
2264
+ }
2265
+ else {
2266
+ return this.getToken(GherkinParser.NEWLINE, i);
2267
+ }
2268
+ }
1372
2269
  constructor(parent, invokingState) {
1373
2270
  super(parent, invokingState);
1374
2271
  }
@@ -1390,6 +2287,14 @@ class ExamplesBlockContext extends ParserRuleContext_1.ParserRuleContext {
1390
2287
  tableHeader() {
1391
2288
  return this.getRuleContext(0, TableHeaderContext);
1392
2289
  }
2290
+ NEWLINE(i) {
2291
+ if (i === undefined) {
2292
+ return this.getTokens(GherkinParser.NEWLINE);
2293
+ }
2294
+ else {
2295
+ return this.getToken(GherkinParser.NEWLINE, i);
2296
+ }
2297
+ }
1393
2298
  tableRow(i) {
1394
2299
  if (i === undefined) {
1395
2300
  return this.getRuleContexts(TableRowContext);
@@ -1451,6 +2356,14 @@ class TableRowContext extends ParserRuleContext_1.ParserRuleContext {
1451
2356
  return this.getRuleContext(i, CellContext);
1452
2357
  }
1453
2358
  }
2359
+ NEWLINE(i) {
2360
+ if (i === undefined) {
2361
+ return this.getTokens(GherkinParser.NEWLINE);
2362
+ }
2363
+ else {
2364
+ return this.getToken(GherkinParser.NEWLINE, i);
2365
+ }
2366
+ }
1454
2367
  constructor(parent, invokingState) {
1455
2368
  super(parent, invokingState);
1456
2369
  }
@@ -1469,7 +2382,7 @@ class TableRowContext extends ParserRuleContext_1.ParserRuleContext {
1469
2382
  exports.TableRowContext = TableRowContext;
1470
2383
  class CellContext extends ParserRuleContext_1.ParserRuleContext {
1471
2384
  contentText() {
1472
- return this.getRuleContext(0, ContentTextContext);
2385
+ return this.tryGetRuleContext(0, ContentTextContext);
1473
2386
  }
1474
2387
  constructor(parent, invokingState) {
1475
2388
  super(parent, invokingState);
@@ -1547,12 +2460,20 @@ class StepContext extends ParserRuleContext_1.ParserRuleContext {
1547
2460
  exports.StepContext = StepContext;
1548
2461
  class GivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1549
2462
  GIVEN() { return this.getToken(GherkinParser.GIVEN, 0); }
1550
- contentText() {
1551
- return this.getRuleContext(0, ContentTextContext);
2463
+ multilineText() {
2464
+ return this.getRuleContext(0, MultilineTextContext);
1552
2465
  }
1553
2466
  tags() {
1554
2467
  return this.tryGetRuleContext(0, TagsContext);
1555
2468
  }
2469
+ NEWLINE(i) {
2470
+ if (i === undefined) {
2471
+ return this.getTokens(GherkinParser.NEWLINE);
2472
+ }
2473
+ else {
2474
+ return this.getToken(GherkinParser.NEWLINE, i);
2475
+ }
2476
+ }
1556
2477
  docString() {
1557
2478
  return this.tryGetRuleContext(0, DocStringContext);
1558
2479
  }
@@ -1574,12 +2495,20 @@ class GivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1574
2495
  exports.GivenStepContext = GivenStepContext;
1575
2496
  class AndGivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1576
2497
  AND_GIVEN() { return this.getToken(GherkinParser.AND_GIVEN, 0); }
1577
- contentText() {
1578
- return this.getRuleContext(0, ContentTextContext);
2498
+ multilineText() {
2499
+ return this.getRuleContext(0, MultilineTextContext);
1579
2500
  }
1580
2501
  tags() {
1581
2502
  return this.tryGetRuleContext(0, TagsContext);
1582
2503
  }
2504
+ NEWLINE(i) {
2505
+ if (i === undefined) {
2506
+ return this.getTokens(GherkinParser.NEWLINE);
2507
+ }
2508
+ else {
2509
+ return this.getToken(GherkinParser.NEWLINE, i);
2510
+ }
2511
+ }
1583
2512
  docString() {
1584
2513
  return this.tryGetRuleContext(0, DocStringContext);
1585
2514
  }
@@ -1601,12 +2530,20 @@ class AndGivenStepContext extends ParserRuleContext_1.ParserRuleContext {
1601
2530
  exports.AndGivenStepContext = AndGivenStepContext;
1602
2531
  class WhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1603
2532
  WHEN() { return this.getToken(GherkinParser.WHEN, 0); }
1604
- contentText() {
1605
- return this.getRuleContext(0, ContentTextContext);
2533
+ multilineText() {
2534
+ return this.getRuleContext(0, MultilineTextContext);
1606
2535
  }
1607
2536
  tags() {
1608
2537
  return this.tryGetRuleContext(0, TagsContext);
1609
2538
  }
2539
+ NEWLINE(i) {
2540
+ if (i === undefined) {
2541
+ return this.getTokens(GherkinParser.NEWLINE);
2542
+ }
2543
+ else {
2544
+ return this.getToken(GherkinParser.NEWLINE, i);
2545
+ }
2546
+ }
1610
2547
  docString() {
1611
2548
  return this.tryGetRuleContext(0, DocStringContext);
1612
2549
  }
@@ -1628,12 +2565,20 @@ class WhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1628
2565
  exports.WhenStepContext = WhenStepContext;
1629
2566
  class AndWhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1630
2567
  AND_WHEN() { return this.getToken(GherkinParser.AND_WHEN, 0); }
1631
- contentText() {
1632
- return this.getRuleContext(0, ContentTextContext);
2568
+ multilineText() {
2569
+ return this.getRuleContext(0, MultilineTextContext);
1633
2570
  }
1634
2571
  tags() {
1635
2572
  return this.tryGetRuleContext(0, TagsContext);
1636
2573
  }
2574
+ NEWLINE(i) {
2575
+ if (i === undefined) {
2576
+ return this.getTokens(GherkinParser.NEWLINE);
2577
+ }
2578
+ else {
2579
+ return this.getToken(GherkinParser.NEWLINE, i);
2580
+ }
2581
+ }
1637
2582
  docString() {
1638
2583
  return this.tryGetRuleContext(0, DocStringContext);
1639
2584
  }
@@ -1655,11 +2600,19 @@ class AndWhenStepContext extends ParserRuleContext_1.ParserRuleContext {
1655
2600
  exports.AndWhenStepContext = AndWhenStepContext;
1656
2601
  class ThenStepContext extends ParserRuleContext_1.ParserRuleContext {
1657
2602
  THEN() { return this.getToken(GherkinParser.THEN, 0); }
1658
- contentText() {
1659
- return this.getRuleContext(0, ContentTextContext);
2603
+ multilineText() {
2604
+ return this.getRuleContext(0, MultilineTextContext);
1660
2605
  }
1661
- tags() {
1662
- return this.tryGetRuleContext(0, TagsContext);
2606
+ thenTags() {
2607
+ return this.tryGetRuleContext(0, ThenTagsContext);
2608
+ }
2609
+ NEWLINE(i) {
2610
+ if (i === undefined) {
2611
+ return this.getTokens(GherkinParser.NEWLINE);
2612
+ }
2613
+ else {
2614
+ return this.getToken(GherkinParser.NEWLINE, i);
2615
+ }
1663
2616
  }
1664
2617
  docString() {
1665
2618
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1682,11 +2635,19 @@ class ThenStepContext extends ParserRuleContext_1.ParserRuleContext {
1682
2635
  exports.ThenStepContext = ThenStepContext;
1683
2636
  class AndStepContext extends ParserRuleContext_1.ParserRuleContext {
1684
2637
  AND() { return this.getToken(GherkinParser.AND, 0); }
1685
- contentText() {
1686
- return this.getRuleContext(0, ContentTextContext);
2638
+ multilineText() {
2639
+ return this.getRuleContext(0, MultilineTextContext);
1687
2640
  }
1688
- tags() {
1689
- return this.tryGetRuleContext(0, TagsContext);
2641
+ thenTags() {
2642
+ return this.tryGetRuleContext(0, ThenTagsContext);
2643
+ }
2644
+ NEWLINE(i) {
2645
+ if (i === undefined) {
2646
+ return this.getTokens(GherkinParser.NEWLINE);
2647
+ }
2648
+ else {
2649
+ return this.getToken(GherkinParser.NEWLINE, i);
2650
+ }
1690
2651
  }
1691
2652
  docString() {
1692
2653
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1709,11 +2670,19 @@ class AndStepContext extends ParserRuleContext_1.ParserRuleContext {
1709
2670
  exports.AndStepContext = AndStepContext;
1710
2671
  class ButStepContext extends ParserRuleContext_1.ParserRuleContext {
1711
2672
  BUT() { return this.getToken(GherkinParser.BUT, 0); }
1712
- contentText() {
1713
- return this.getRuleContext(0, ContentTextContext);
2673
+ multilineText() {
2674
+ return this.getRuleContext(0, MultilineTextContext);
1714
2675
  }
1715
- tags() {
1716
- return this.tryGetRuleContext(0, TagsContext);
2676
+ thenTags() {
2677
+ return this.tryGetRuleContext(0, ThenTagsContext);
2678
+ }
2679
+ NEWLINE(i) {
2680
+ if (i === undefined) {
2681
+ return this.getTokens(GherkinParser.NEWLINE);
2682
+ }
2683
+ else {
2684
+ return this.getToken(GherkinParser.NEWLINE, i);
2685
+ }
1717
2686
  }
1718
2687
  docString() {
1719
2688
  return this.tryGetRuleContext(0, DocStringContext);
@@ -1753,6 +2722,14 @@ class DocStringContext extends ParserRuleContext_1.ParserRuleContext {
1753
2722
  }
1754
2723
  exports.DocStringContext = DocStringContext;
1755
2724
  class TagsContext extends ParserRuleContext_1.ParserRuleContext {
2725
+ NEWLINE(i) {
2726
+ if (i === undefined) {
2727
+ return this.getTokens(GherkinParser.NEWLINE);
2728
+ }
2729
+ else {
2730
+ return this.getToken(GherkinParser.NEWLINE, i);
2731
+ }
2732
+ }
1756
2733
  ONLY_TAG(i) {
1757
2734
  if (i === undefined) {
1758
2735
  return this.getTokens(GherkinParser.ONLY_TAG);
@@ -1793,6 +2770,71 @@ class TagsContext extends ParserRuleContext_1.ParserRuleContext {
1793
2770
  }
1794
2771
  }
1795
2772
  exports.TagsContext = TagsContext;
2773
+ class ThenTagsContext extends ParserRuleContext_1.ParserRuleContext {
2774
+ NEWLINE(i) {
2775
+ if (i === undefined) {
2776
+ return this.getTokens(GherkinParser.NEWLINE);
2777
+ }
2778
+ else {
2779
+ return this.getToken(GherkinParser.NEWLINE, i);
2780
+ }
2781
+ }
2782
+ ONLY_TAG(i) {
2783
+ if (i === undefined) {
2784
+ return this.getTokens(GherkinParser.ONLY_TAG);
2785
+ }
2786
+ else {
2787
+ return this.getToken(GherkinParser.ONLY_TAG, i);
2788
+ }
2789
+ }
2790
+ SKIP_TAG(i) {
2791
+ if (i === undefined) {
2792
+ return this.getTokens(GherkinParser.SKIP_TAG);
2793
+ }
2794
+ else {
2795
+ return this.getToken(GherkinParser.SKIP_TAG, i);
2796
+ }
2797
+ }
2798
+ FAIL_TAG(i) {
2799
+ if (i === undefined) {
2800
+ return this.getTokens(GherkinParser.FAIL_TAG);
2801
+ }
2802
+ else {
2803
+ return this.getToken(GherkinParser.FAIL_TAG, i);
2804
+ }
2805
+ }
2806
+ TODO_TAG(i) {
2807
+ if (i === undefined) {
2808
+ return this.getTokens(GherkinParser.TODO_TAG);
2809
+ }
2810
+ else {
2811
+ return this.getToken(GherkinParser.TODO_TAG, i);
2812
+ }
2813
+ }
2814
+ TAG(i) {
2815
+ if (i === undefined) {
2816
+ return this.getTokens(GherkinParser.TAG);
2817
+ }
2818
+ else {
2819
+ return this.getToken(GherkinParser.TAG, i);
2820
+ }
2821
+ }
2822
+ constructor(parent, invokingState) {
2823
+ super(parent, invokingState);
2824
+ }
2825
+ // @Override
2826
+ get ruleIndex() { return GherkinParser.RULE_thenTags; }
2827
+ // @Override
2828
+ accept(visitor) {
2829
+ if (visitor.visitThenTags) {
2830
+ return visitor.visitThenTags(this);
2831
+ }
2832
+ else {
2833
+ return visitor.visitChildren(this);
2834
+ }
2835
+ }
2836
+ }
2837
+ exports.ThenTagsContext = ThenTagsContext;
1796
2838
  class ContentTextContext extends ParserRuleContext_1.ParserRuleContext {
1797
2839
  TEXT_CHARACTER(i) {
1798
2840
  if (i === undefined) {
@@ -1818,4 +2860,37 @@ class ContentTextContext extends ParserRuleContext_1.ParserRuleContext {
1818
2860
  }
1819
2861
  }
1820
2862
  exports.ContentTextContext = ContentTextContext;
2863
+ class MultilineTextContext extends ParserRuleContext_1.ParserRuleContext {
2864
+ TEXT_CHARACTER(i) {
2865
+ if (i === undefined) {
2866
+ return this.getTokens(GherkinParser.TEXT_CHARACTER);
2867
+ }
2868
+ else {
2869
+ return this.getToken(GherkinParser.TEXT_CHARACTER, i);
2870
+ }
2871
+ }
2872
+ NEWLINE(i) {
2873
+ if (i === undefined) {
2874
+ return this.getTokens(GherkinParser.NEWLINE);
2875
+ }
2876
+ else {
2877
+ return this.getToken(GherkinParser.NEWLINE, i);
2878
+ }
2879
+ }
2880
+ constructor(parent, invokingState) {
2881
+ super(parent, invokingState);
2882
+ }
2883
+ // @Override
2884
+ get ruleIndex() { return GherkinParser.RULE_multilineText; }
2885
+ // @Override
2886
+ accept(visitor) {
2887
+ if (visitor.visitMultilineText) {
2888
+ return visitor.visitMultilineText(this);
2889
+ }
2890
+ else {
2891
+ return visitor.visitChildren(this);
2892
+ }
2893
+ }
2894
+ }
2895
+ exports.MultilineTextContext = MultilineTextContext;
1821
2896
  //# sourceMappingURL=GherkinParser.js.map