vitest-cucumber-plugin 0.1.3

package/CONTRIBUTING.md

@@ -0,0 +1,42 @@
+# Contributing Guide
+
+## Testing
+
+```
+$ npm test
+```
+
+Running this does a "npm install" followed by a "npm test" in each of the directories found in the [tests](tests)
+directory.  The test suite fails if either of these commands returns with a non-zero exit code.
+
+## Gherkin parser
+
+This plugin uses [nearley](https://nearley.js.org/) with [moo](https://github.com/no-context/moo) to create it's
+Gherkin parser.
+
+Before you can run the parser generation script, you must install nearly globally:
+```
+$ npm install -g nearly
+```
+
+The parser nearley file is [src/gherkin.ne](src/gherkin.ne).  If you modify this file, you must
+regenerate the generated parser JS file via:
+```
+$ npm run nearley
+```
+
+In addition to running nearley, this script also runs rollup in order to convert the generated parser into an 
+ECMAScript module.
+
+## Branching
+
+This repo uses [git flow](https://www.atlassian.com/git/tutorials/comparing-workflows/gitflow-workflow) as it's 
+branching model.  The 'main' branch the release branch and is only pushed to during the release process.  The
+'develop' branch is the cutting edge branch which is pushed to whenever a feature branch is finished.
+
+## Doing a release
+
+1. git flow release start <version>
+1. Update version number in package.json
+1. Add the release notes to [RELEASE_NOTES.md](RELEASE_NOTES.md).
+1. git flow release finish <version>

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 SamZiegler
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# vitest-cucumber-plugin
+
+Plugin for [Vitest](https://vitest.dev/) to allow tests to be written in [Cucumber](https://cucumber.io/) format.
+
+## Installation
+
+```
+$ npm install --save-dev SamZiegler/vitest-cucumber-plugin
+```
+
+## Usage
+
+
+### vite.config.js
+
+Import the plugin then add it to the plugins array.  Change test.inclue to look for .feature files.
+
+```
+import { defineConfig } from 'vitest/config'
+import vitestCucumberPlugin from 'vitest-cucumber-plugin';
+
+export default defineConfig({
+    plugins: [vitestCucumberPlugin()],
+    test: {
+        include : [ '**/*.feature' ]
+    },
+})
+```
+
+### Writing tests
+
+Put feature files into the 'features/' directory and step definitions into the 'features/step_definitions/' directory.
+
+See below for the differences between tests written for Cucumber and for this plugin.
+
+## Examples
+
+Look in the [tests directory](tests) for examples on how to use the plugin.
+
+## Differences between this plugin and Cucumber
+
+The goal of this plugin is to fully implement Cucumber's Gherkin syntax for feature files, but
+there are a few differences in how step definitions are written.
+
+### Changes to Given/When/Then
+
+The function signatures for Given, When and Then callbacks have been modified in order to make the step definitions
+more friendly for functional programming.  Specifically, the callback functions differ in that they
+now have two parameters, a state object and array of parameters.  The callback functions then return a new state
+object which is passed to the next step definition in the chain.
+
+For example, here is how you'd write step definitions in Cucumber:
+```
+const assert = require('assert');
+const { Given, When, Then } = require('@cucumber/cucumber');
+
+function isItFriday(today) {
+  if (today === "Friday") {
+    return "TGIF";
+  } else {
+    return "Nope";
+  }
+}
+
+Given('today is {string}', function (givenDay) {
+  this.today = givenDay;
+});
+
+When('I ask whether it\'s Friday yet', function () {
+  this.actualAnswer = isItFriday(this.today);
+});
+
+Then('I should be told {string}', function (expectedAnswer) {
+  assert.strictEqual(this.actualAnswer, expectedAnswer);
+});
+```
+
+Here is how you'd write the same step functions in this plugin:
+```
+import { Given, When, Then } from 'vitest-cucumber-plugin';
+import _ from 'lodash/fp.js';
+import { expect } from 'vitest'
+
+Given('today is Sunday', function () {
+    return { today : 'Sunday' };
+});
+
+Given('today is Friday', function () {
+    return { today : 'Friday' };
+});
+
+When('I ask whether it\'s Friday yet', function (state) {
+    return _.set('answer',(state.today === 'Friday') ? 'TGIF' : 'Nope',state);
+});
+
+Then('I should be told {string}', function (state,[ answer ]) {
+    expect(state.answer).toBe(answer);
+});
+```
+
+### Step definitions must be ECMAScript modules
+
+Currently, all step definition files must be in ECMAScript module format.  CommonJS files might
+work, but this configuration isn't tested.
+
+
+### Not yet implemented
+
+This plugin is not yet feature complete.  Here is the list of features from Cucumber which aren't yet implemented:
+* Rule keyword
+* Doc strings
+* Data Table escape characters
+* Boolean expression support for tags

package/RELEASE_NOTES.md

@@ -0,0 +1,9 @@
+* v0.1.3 : Import modules from generated code to make sure they are processed correctly
+* v0.1.2 : Set default log level to warn and make it configurable
+* v0.1.1 : Use root dir from the config to find step_definitions dir
+* v0.1.0 : Added basic support for tags.
+* v0.0.5 : Implemented keyword aliases and comments
+* v0.0.4 : Implemented Data Tables
+* v0.0.3 : Implemented Scenario Outline
+* v0.0.2 : Updated README
+* v0.0.1 : Initial release

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "vitest-cucumber-plugin",
+    "version": "0.1.3",
+    "description": "Plugin for Vitest which allows for tests to be written in Cucumber format.",
+    "keywords": [
+        "vite",
+        "vitest",
+        "cucumber"
+    ],
+    "homepage": "https://github.com/SamZiegler/vitest-cucumber-plugin#readme",
+    "bugs": {
+        "url": "https://github.com/SamZiegler/vitest-cucumber-plugin/issues"
+    },
+    "license": "MIT",
+    "main": "src/index.js",
+    "type": "module",
+    "scripts": {
+        "nearley": "nearleyc src/gherkin.ne -o src/gherkin.umd.js && rollup -c rollup-nearley.js",
+        "test": "./run-tests"
+    },
+    "dependencies": {
+        "@cucumber/cucumber-expressions": "^16.1.2",
+        "lodash": "^4.17.21",
+        "moo": "^0.5.2",
+        "nearley": "^2.20.1",
+        "pino": "^8.11.0"
+    },
+    "devDependencies": {
+        "@rollup/plugin-commonjs": "^24.1.0",
+        "@types/lodash": "^4.14.194",
+        "rollup": "^3.20.7"
+    },
+    "repository" : "https://github.com/SamZiegler/vitest-cucumber-plugin.git"
+}

package/rollup-nearley.js

@@ -0,0 +1,10 @@
+import commonjs from "@rollup/plugin-commonjs";
+
+export default {
+    input: "src/gherkin.umd.js",
+    output: {
+        file: "src/gherkin.js",
+        format: "es",
+    },
+    plugins: [commonjs()],
+};

package/run-tests

@@ -0,0 +1,8 @@
+#!/usr/bin/bash
+
+for i in `ls tests`; do
+    pushd tests/$i
+    npm install || exit
+    npm test || exit
+    popd
+done

package/src/generate/example.js

@@ -0,0 +1,20 @@
+import { escape, shouldSkip } from './util.js';
+import { generateTests } from './tests.js';
+import _ from 'lodash/fp.js';
+import { log } from '../logger.js';
+
+export const generateExample = (config,example) => {
+    log.debug('generateExample config: '+JSON.stringify(config)+' example: '+JSON.stringify(example));
+    var tests = '';
+
+    const steps = _.has('background.steps',example) ? _.concat(example.background.steps,example.steps) : example.steps;
+
+    tests += generateTests(steps);
+    
+    const skip = shouldSkip(config,example.tags) ? '.skip' : '';
+
+    const code = `  describe${skip}('${escape(example.type.name)}: ${escape(example.name)}', () => {${tests}
+  });
+`;
+    return code;
+}

package/src/generate/examples.js

@@ -0,0 +1,47 @@
+import { escape, shouldSkip } from './util.js';
+import { generateTests } from './tests.js';
+import _ from 'lodash/fp.js';
+import { log } from '../logger.js';
+
+const createParameterMap = (parameters,values) => {
+    const parameterMap = _.reduce((parameterMap,value) => {
+        return {
+            map : _.set(parameters[parameterMap.index],value,parameterMap.map),
+            index : parameterMap.index + 1
+        };
+    },{ map : {}, index : 0 })(values);
+
+    return parameterMap.map;
+}
+
+const generateAllTests = (steps,parameters,parameterValues) => {
+    const allTests = _.reduce((allTests,values) => {
+        const parameterMap = createParameterMap(parameters,values);
+        log.debug('parameterMap : '+JSON.stringify(parameterMap));
+
+        const tests = generateTests(steps,parameterMap,'    ');
+
+        return { tests : allTests.tests + `
+      describe('${allTests.index}',() => {${tests}
+      });`, index : allTests.index + 1 };
+    },{ tests : '', index : 0})(parameterValues);
+
+    return allTests.tests;
+}
+
+export const generateExamples = (config,steps,examplesStatement) => {
+    log.debug('generateExamples steps:'+JSON.stringify(steps)+' examples: '+JSON.stringify(examplesStatement));
+
+    const parameters = _.head(examplesStatement.dataTable);
+    const parameterValues = _.tail(examplesStatement.dataTable);
+
+    log.debug('generateExamples parameters:'+JSON.stringify(parameters)+' parameterValues: '+
+              JSON.stringify(parameterValues));
+
+    const skip = shouldSkip(config,examplesStatement.tags) ? '.skip' : '';
+
+    const allTests = generateAllTests(steps,parameters,parameterValues);
+    const code = `    describe${skip}('${escape(examplesStatement.type.name)}: ${escape(examplesStatement.name)}', () => {${allTests}
+    });`;
+    return code;
+}

package/src/generate/feature.js

@@ -0,0 +1,45 @@
+import _ from 'lodash/fp.js';
+import { log } from '../logger.js';
+import { generateExample, generateScenarioOutline } from './index.js';
+import { escape, shouldSkip } from './util.js';
+
+export const generateFeature = (config,feature) => {
+    const name = feature.name;
+    const statements = feature.statements;
+
+    const testStatements = _.reduce((testStatements,statement) => {
+        if (feature.background) {
+            statement = _.set('background',feature.background,statement);
+        }
+        if (statement.type.type === 'example') {
+            return testStatements + generateExample(config,statement);
+        } else if (statement.type.type === 'scenarioOutline') {
+            return testStatements + generateScenarioOutline(config,statement);
+        }
+    },'')(statements);
+
+    const skip = shouldSkip(config,feature.tags) ? '.skip' : '';
+    const configStr = JSON.stringify(config);
+
+    const code = `import { expect, test, describe } from 'vitest';
+import { Test } from 'vitest-cucumber-plugin';
+import { readdir } from 'node:fs/promises';
+
+const importStepDefinitions = async (config) => {
+    const stepDefinitionDirectory = config.root+'/features/step_definitions';
+    const files = await readdir(stepDefinitionDirectory);
+    for (const file of files) {
+        const stepDefinition = stepDefinitionDirectory+'/'+file;
+        await import(stepDefinition);
+    }
+};
+
+await importStepDefinitions(${configStr});
+
+describe${skip}('${escape(feature.type.name)}: ${escape(name)}', () => {
+${testStatements}});
+`;
+    log.debug(code);
+
+    return code;
+}

package/src/generate/index.js

@@ -0,0 +1,13 @@
+import { generateTests } from './tests.js';
+import { generateExample } from './example.js';
+import { generateExamples } from './examples.js';
+import { generateScenarioOutline } from './scenarioOutline.js';
+import { generateFeature } from './feature.js';
+
+export {
+    generateTests,
+    generateExample,
+    generateExamples,
+    generateScenarioOutline,
+    generateFeature
+};

package/src/generate/scenarioOutline.js

@@ -0,0 +1,18 @@
+import _ from 'lodash/fp.js';
+import { generateExamples } from './examples.js';
+import { escape, shouldSkip } from './util.js';
+
+export const generateScenarioOutline = (config,scenarioOutline) => {
+    const examplesStatements = _.reduce((examplesStatements,examplesStatement) => {
+        return examplesStatements + generateExamples(config,scenarioOutline.steps,examplesStatement);
+    },'')(scenarioOutline.examples);
+
+    const skip = shouldSkip(config,scenarioOutline.tags) ? '.skip' : '';
+
+    const code = `  describe${skip}('${escape(scenarioOutline.type.name)}: ${escape(scenarioOutline.name)}', () => {
+${examplesStatements}
+  });
+`;
+
+    return code;
+}

package/src/generate/tests.js

@@ -0,0 +1,23 @@
+import _ from 'lodash/fp.js';
+import { escape } from './util.js';
+import { parameterizeText } from '../parameterize.js';
+import { log } from '../logger.js';
+
+export const generateTests = (steps,parameterMap,extraIndent) => {
+    log.debug('generateTests steps : '+JSON.stringify(steps));
+    const indent = extraIndent ? extraIndent : '';
+    let tests = `
+${indent}    var state = {};`;
+    
+    _.forEach((step) => {
+        const parameterizedText = ( parameterMap ? parameterizeText(step.text,parameterMap) : step.text);
+        const name = parameterizedText;
+        const parameterizedStep = _.set('text',parameterizedText,step);
+
+        const stepString = JSON.stringify(parameterizedStep);
+        tests = tests+`
+${indent}    test('${escape(step.type.name)} ${escape(name)}', () => { state = Test(state,${stepString}); });`;
+    },steps);
+
+    return tests;
+};

package/src/generate/util.js

@@ -0,0 +1,10 @@
+import _ from 'lodash/fp.js';
+import { log } from '../logger.js';
+
+export const escape = (str) => str.replace(/'/g,"\\'");
+export const shouldSkip = (config,tags) => {
+    const exclude = _.getOr([],'tags.exclude',config);
+    const intersection = _.intersection(exclude,tags);
+    log.debug('shouldSkip config: '+JSON.stringify(config)+' tags: '+JSON.stringify(tags)+' intersection: '+JSON.stringify(intersection));
+    return intersection.length > 0;
+}

package/src/gherkin.js

@@ -0,0 +1,171 @@
+import require$$0 from 'lodash/fp.js';
+import require$$1 from 'moo';
+import pino from 'pino';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+function getAugmentedNamespace(n) {
+  if (n.__esModule) return n;
+  var f = n.default;
+	if (typeof f == "function") {
+		var a = function a () {
+			if (this instanceof a) {
+				var args = [null];
+				args.push.apply(args, arguments);
+				var Ctor = Function.bind.apply(f, args);
+				return new Ctor();
+			}
+			return f.apply(this, arguments);
+		};
+		a.prototype = f.prototype;
+  } else a = {};
+  Object.defineProperty(a, '__esModule', {value: true});
+	Object.keys(n).forEach(function (k) {
+		var d = Object.getOwnPropertyDescriptor(n, k);
+		Object.defineProperty(a, k, d.get ? d : {
+			enumerable: true,
+			get: function () {
+				return n[k];
+			}
+		});
+	});
+	return a;
+}
+
+var gherkin_umd$1 = {exports: {}};
+
+const log = pino();
+
+log.level = 'warn';
+
+var logger = /*#__PURE__*/Object.freeze({
+	__proto__: null,
+	log: log
+});
+
+var require$$2 = /*@__PURE__*/getAugmentedNamespace(logger);
+
+(function (module) {
+	// Generated automatically by nearley, version 2.20.1
+	// http://github.com/Hardmath123/nearley
+	(function () {
+
+	const fp = require$$0;
+	const moo = require$$1;
+	require$$2.log;
+	const lexer = moo.compile({
+	  emptyLine : { match: /^[ \t]*(?:\#[^\n]+)?\n/, lineBreaks : true },
+	  newline : { match : '\n', lineBreaks : true },
+	  ws : /[ \t]+/,
+	  at : '@',
+	  colon : ':',
+	  step : '*',
+	  pipe : '|',
+	  backSlash : '\\',
+	  scenarioOutline : ['Scenario Outline','Scenario Template'],
+	  word : {
+	    match : /[^ \t\n:|\\]+/,
+	    type : moo.keywords({
+	      feature : 'Feature',
+	      examples : ['Examples','Scenarios'],
+	      step : ['Given','When','Then','And','But'],
+	      example : ['Example','Scenario'],
+	      background : 'Background',
+	    }),
+	  },
+	});
+	var grammar = {
+	    Lexer: lexer,
+	    ParserRules: [
+	    {"name": "main", "symbols": ["emptyLines", "tags", "feature"], "postprocess": data => fp.set('tags',data[1],data[2])},
+	    {"name": "feature", "symbols": ["featureStatement", "freeform", "background", "statements"], "postprocess": 
+	        (data) => fp.assign(data[0],{ description : data[1].trim(), background : data[2], statements : data[3] })
+	        },
+	    {"name": "featureStatement", "symbols": ["_", (lexer.has("feature") ? {type: "feature"} : feature), "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'feature', name : data[1].value.trim() }, name : data[4].trim() } }
+	        },
+	    {"name": "tags", "symbols": [], "postprocess": data => []},
+	    {"name": "tags", "symbols": ["_", "tag", "tagList", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => fp.concat(data[1],data[2])},
+	    {"name": "tagList", "symbols": [], "postprocess": data => []},
+	    {"name": "tagList", "symbols": ["tagList", (lexer.has("ws") ? {type: "ws"} : ws), "tag"], "postprocess": data => fp.concat(data[0],data[2])},
+	    {"name": "tag", "symbols": [(lexer.has("at") ? {type: "at"} : at), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value.trim()},
+	    {"name": "background", "symbols": [], "postprocess": data => null},
+	    {"name": "background", "symbols": ["backgroundStatement", "freeform", "steps"], "postprocess": 
+	        data => fp.assign(data[0],{ description : data[1].trim(), steps : data[2] })
+	        },
+	    {"name": "backgroundStatement", "symbols": ["_", (lexer.has("background") ? {type: "background"} : background), "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'background', name : data[1].value }, name : data[4].trim() } }
+	        },
+	    {"name": "statement", "symbols": ["example"], "postprocess": data => data[0]},
+	    {"name": "statement", "symbols": ["scenarioOutline"], "postprocess": data => data[0]},
+	    {"name": "statements", "symbols": [], "postprocess": data => []},
+	    {"name": "statements", "symbols": ["statements", "statement"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "example", "symbols": ["tags", "exampleStatement", "steps"], "postprocess": (data) => fp.assign(data[1],{ tags : data[0], steps : data[2] })},
+	    {"name": "exampleStatement", "symbols": ["_", "exampleKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'example', name : data[1] }, name : data[4].trim() } }
+	        },
+	    {"name": "exampleKeyword", "symbols": [(lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0].value},
+	    {"name": "scenarioOutline", "symbols": ["tags", "scenarioOutlineStatement", "steps", "examplesList"], "postprocess": 
+	        data => fp.assign(data[1],{ tags : data[0], steps : data[2], examples : data[3] })
+	        },
+	    {"name": "scenarioOutlineStatement", "symbols": ["_", "scenarioOutlineKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'scenarioOutline', name : data[1] }, name : data[4].trim() } }
+	        },
+	    {"name": "scenarioOutlineKeyword", "symbols": [(lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0].value},
+	    {"name": "examplesList", "symbols": [], "postprocess": data => []},
+	    {"name": "examplesList", "symbols": ["examplesList", "examples"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "examples", "symbols": ["tags", "examplesStatement", "dataTable", "emptyLines"], "postprocess": 
+	        data => fp.assign(data[1],{ tags : data[0], dataTable : data[2] })
+	        },
+	    {"name": "examplesStatement", "symbols": ["_", "examplesKeyword", "_", (lexer.has("colon") ? {type: "colon"} : colon), "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": 
+	        (data) => { return { type : { type : 'examples', name : data[1] }, name : data[4] } }
+	        },
+	    {"name": "examplesKeyword", "symbols": [(lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0].value},
+	    {"name": "dataTable", "symbols": [], "postprocess": data => []},
+	    {"name": "dataTable", "symbols": ["dataTable", "dataTableRow"], "postprocess": data => fp.concat(data[0],[data[1]])},
+	    {"name": "dataTableRow", "symbols": ["_", (lexer.has("pipe") ? {type: "pipe"} : pipe), "dataTableColumns", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => data[2]},
+	    {"name": "dataTableColumns", "symbols": [], "postprocess": data => []},
+	    {"name": "dataTableColumns", "symbols": ["dataTableColumns", "text", (lexer.has("pipe") ? {type: "pipe"} : pipe)], "postprocess": data => fp.concat(data[0],data[1].trim())},
+	    {"name": "steps", "symbols": ["stepAndTable", "moreSteps"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "moreSteps", "symbols": [], "postprocess": data => []},
+	    {"name": "moreSteps", "symbols": ["moreSteps", "stepAndTable"], "postprocess": data => fp.concat(data[0],data[1])},
+	    {"name": "moreSteps", "symbols": ["moreSteps", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]},
+	    {"name": "step", "symbols": ["_", "stepKeyword", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess": data => { return { type : data[1], text : data[2].trim() } }},
+	    {"name": "stepAndTable", "symbols": ["step", "dataTable"], "postprocess": data => fp.set('dataTable',data[1],data[0])},
+	    {"name": "stepKeyword", "symbols": [(lexer.has("step") ? {type: "step"} : step)], "postprocess": (data) => { return { type : 'step', name : data[0].value } }},
+	    {"name": "text", "symbols": [], "postprocess": data => ''},
+	    {"name": "text", "symbols": ["text", (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("step") ? {type: "step"} : step)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("colon") ? {type: "colon"} : colon)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("example") ? {type: "example"} : example)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("examples") ? {type: "examples"} : examples)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("scenarioOutline") ? {type: "scenarioOutline"} : scenarioOutline)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "text", "symbols": ["text", (lexer.has("background") ? {type: "background"} : background)], "postprocess": data => data[0]+data[1].value},
+	    {"name": "bolText", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws), (lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[1].value},
+	    {"name": "bolText", "symbols": [(lexer.has("word") ? {type: "word"} : word)], "postprocess": data => data[0].value},
+	    {"name": "freeform", "symbols": [], "postprocess": data => ''},
+	    {"name": "freeform", "symbols": ["freeform", "bolText", "text", (lexer.has("newline") ? {type: "newline"} : newline)], "postprocess":  (data) => {
+	          return data[0]+data[1]+data[2]+'\n'
+	        }
+	        },
+	    {"name": "freeform", "symbols": ["freeform", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'},
+	    {"name": "_", "symbols": [], "postprocess": data => ''},
+	    {"name": "_", "symbols": [(lexer.has("ws") ? {type: "ws"} : ws)], "postprocess": data => data[0].value},
+	    {"name": "emptyLines", "symbols": [], "postprocess": data => ''},
+	    {"name": "emptyLines", "symbols": ["emptyLines", (lexer.has("emptyLine") ? {type: "emptyLine"} : emptyLine)], "postprocess": data => data[0]+'\n'}
+	]
+	  , ParserStart: "main"
+	};
+	{
+	   module.exports = grammar;
+	}
+	})(); 
+} (gherkin_umd$1));
+
+var gherkin_umdExports = gherkin_umd$1.exports;
+var gherkin_umd = /*@__PURE__*/getDefaultExportFromCjs(gherkin_umdExports);
+
+export { gherkin_umd as default };