pickle-jar 1.2.0 → 1.3.0

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