@step-forge/step-forge 0.0.12 → 0.0.13

package/dist/step-forge.js

@@ -0,0 +1,695 @@
+import { Given, Then, When } from "@cucumber/cucumber";
+import _ from "lodash";
+import { glob } from "node:fs/promises";
+import * as path from "node:path";
+import ts from "typescript";
+import * as fs from "node:fs";
+import { AstBuilder, GherkinClassicTokenMatcher, Parser } from "@cucumber/gherkin";
+import * as messages from "@cucumber/messages";
+//#region src/builderTypeUtils.ts
+const isString = (statement) => typeof statement === "string";
+//#endregion
+//#region src/utils.ts
+const requireFromGiven = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.given[key]) throw new Error(`Key ${String(key)} is required in given state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.given[key]
+		};
+	}, {});
+};
+const requireFromWhen = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.when[key]) throw new Error(`Key ${String(key)} is required in when state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.when[key]
+		};
+	}, {});
+};
+const requireFromThen = (keys, world) => {
+	keys.forEach((key) => {
+		if (!world.then[key]) throw new Error(`Key ${String(key)} is required in then state`);
+	});
+	return keys.reduce((acc, key) => {
+		return {
+			...acc,
+			[key]: world.then[key]
+		};
+	}, {});
+};
+const typeCoercer = (value) => {
+	const numberValue = parseInt(value, 10);
+	if (!isNaN(numberValue)) return numberValue;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	return value;
+};
+//#endregion
+//#region src/common.ts
+const cucFunctionMap = {
+	given: Given,
+	when: When,
+	then: Then
+};
+const addStep = (statement, stepType, dependencies = {
+	given: {},
+	when: {},
+	then: {}
+}) => (stepFunction) => {
+	const statementFunction = statement;
+	const { given: givenDependencies, when: whenDependencies, then: thenDependencies } = dependencies;
+	return {
+		statement,
+		dependencies,
+		stepType,
+		stepFunction,
+		register: () => {
+			const argCount = statementFunction.length;
+			const statement = statementFunction(...Array.from({ length: argCount }, () => "{string}"));
+			const cucStepFunction = Object.defineProperty(async function(...args) {
+				const coercedArgs = args.map(typeCoercer);
+				const ensuredGivenValues = requireFromGiven(Object.entries(givenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const narrowedGiven = {
+					..._.pick(this.given, Object.keys(givenDependencies ?? {})),
+					...ensuredGivenValues
+				};
+				const ensuredWhenValues = requireFromWhen(Object.entries(whenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const narrowedWhen = {
+					..._.pick(this.when, Object.keys(whenDependencies ?? {})),
+					...ensuredWhenValues
+				};
+				const ensuredThenValues = requireFromThen(Object.entries(thenDependencies ?? {}).filter(([, value]) => value === "required").map(([key]) => key), this);
+				const result = await stepFunction({
+					variables: coercedArgs,
+					given: narrowedGiven,
+					when: narrowedWhen,
+					then: {
+						..._.pick(this.then, Object.keys(thenDependencies ?? {})),
+						...ensuredThenValues
+					}
+				});
+				this[stepType].merge({ ...result });
+			}, "length", {
+				value: argCount,
+				configurable: true
+			});
+			const cucStep = cucFunctionMap[stepType];
+			cucStep(statement, cucStepFunction);
+			return {
+				stepType,
+				dependencies,
+				statement: statementFunction,
+				stepFunction
+			};
+		}
+	};
+};
+//#endregion
+//#region src/given.ts
+const givenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		...dependencies,
+		when: {},
+		then: {}
+	}) };
+};
+const givenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: givenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const givenBuilder = () => {
+	return { statement: givenStatement("given") };
+};
+//#endregion
+//#region src/when.ts
+const whenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		given: dependencies.given ?? {},
+		when: dependencies.when ?? {},
+		then: {}
+	}) };
+};
+const whenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: whenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const whenBuilder = () => {
+	return { statement: whenStatement("when") };
+};
+//#endregion
+//#region src/then.ts
+const thenDependencies = (statement, stepType) => (dependencies) => {
+	return { step: addStep(statement, stepType, {
+		given: dependencies.given ?? {},
+		when: dependencies.when ?? {},
+		then: dependencies.then ?? {}
+	}) };
+};
+const thenStatement = (stepType) => (statement) => {
+	let normalizedStatement;
+	if (isString(statement)) normalizedStatement = (() => statement);
+	else normalizedStatement = statement;
+	return {
+		dependencies: thenDependencies(normalizedStatement, stepType),
+		step: addStep(normalizedStatement, stepType)
+	};
+};
+const thenBuilder = () => {
+	return { statement: thenStatement("then") };
+};
+//#endregion
+//#region src/world.ts
+function mergeCustomizer(objValue, srcValue) {
+	if (_.isArray(objValue)) return objValue.concat(srcValue);
+	else if (objValue && !_.isPlainObject(objValue) && objValue !== srcValue) throw new Error(`Merge would have destroyed previous value ${objValue} with ${srcValue}`);
+	return objValue;
+}
+var BasicWorld = class {
+	givenState = {};
+	whenState = {};
+	thenState = {};
+	get given() {
+		return {
+			...this.givenState,
+			merge: (newState) => {
+				this.givenState = _.merge({ ...this.givenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get when() {
+		return {
+			...this.whenState,
+			merge: (newState) => {
+				this.whenState = _.merge({ ...this.whenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+	get then() {
+		return {
+			...this.thenState,
+			merge: (newState) => {
+				this.thenState = _.merge({ ...this.thenState }, newState, mergeCustomizer);
+			}
+		};
+	}
+};
+//#endregion
+//#region src/analyzer/stepExtractor.ts
+const BUILDER_NAMES = {
+	givenBuilder: "given",
+	whenBuilder: "when",
+	thenBuilder: "then"
+};
+function extractStepDefinitions(filePaths, tsConfigPath) {
+	const configPath = tsConfigPath ?? ts.findConfigFile(process.cwd(), ts.sys.fileExists);
+	let compilerOptions = {
+		target: ts.ScriptTarget.ESNext,
+		module: ts.ModuleKind.ESNext,
+		moduleResolution: ts.ModuleResolutionKind.Node10,
+		strict: true,
+		esModuleInterop: true
+	};
+	if (configPath) {
+		const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
+		if (!configFile.error) compilerOptions = ts.parseJsonConfigFileContent(configFile.config, ts.sys, configPath.replace(/[/\\][^/\\]+$/, "")).options;
+	}
+	compilerOptions.noEmit = true;
+	const program = ts.createProgram(filePaths, compilerOptions);
+	const checker = program.getTypeChecker();
+	const results = [];
+	for (const filePath of filePaths) {
+		const sourceFile = program.getSourceFile(filePath);
+		if (!sourceFile) continue;
+		const fileResults = extractFromSourceFile(sourceFile, checker);
+		results.push(...fileResults);
+	}
+	return results;
+}
+function extractFromSourceFile(sourceFile, checker) {
+	const results = [];
+	function visit(node) {
+		if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "register") {
+			const meta = extractFromRegisterCall(node, sourceFile, checker);
+			if (meta) results.push(meta);
+		}
+		ts.forEachChild(node, visit);
+	}
+	visit(sourceFile);
+	return results;
+}
+function extractFromRegisterCall(registerCall, sourceFile, checker) {
+	const chain = collectCallChain(registerCall);
+	let stepType = null;
+	let expression = null;
+	let dependencies = {
+		given: {},
+		when: {},
+		then: {}
+	};
+	let produces = [];
+	for (const link of chain) {
+		const name = getCallName(link);
+		if (!name) continue;
+		if (name === "register") continue;
+		if (name === "step") {
+			produces = extractProducedKeys(link, checker);
+			continue;
+		}
+		if (name === "dependencies") {
+			dependencies = extractDependencies(link);
+			continue;
+		}
+		if (name === "statement") {
+			expression = extractExpression(link);
+			continue;
+		}
+		if (BUILDER_NAMES[name]) {
+			stepType = BUILDER_NAMES[name];
+			continue;
+		}
+	}
+	if (!stepType || !expression) {
+		const reExport = resolveReExportedCall(chain, checker);
+		if (reExport) {
+			if (!stepType) stepType = reExport.stepType;
+			if (!expression) expression = reExport.expression;
+		}
+	}
+	if (!stepType || !expression) return null;
+	const line = sourceFile.getLineAndCharacterOfPosition(registerCall.getStart()).line + 1;
+	return {
+		stepType,
+		expression,
+		dependencies,
+		produces,
+		sourceFile: sourceFile.fileName,
+		line
+	};
+}
+/**
+* Collect all call expressions in the method chain, from register() back to the origin.
+*/
+function collectCallChain(call) {
+	const chain = [call];
+	let current = call.expression;
+	while (true) {
+		if (ts.isPropertyAccessExpression(current)) current = current.expression;
+		if (ts.isCallExpression(current)) {
+			chain.push(current);
+			current = current.expression;
+		} else break;
+	}
+	return chain;
+}
+function getCallName(call) {
+	const expr = call.expression;
+	if (ts.isPropertyAccessExpression(expr)) return expr.name.text;
+	if (ts.isIdentifier(expr)) return expr.text;
+	return null;
+}
+function extractExpression(statementCall) {
+	const arg = statementCall.arguments[0];
+	if (!arg) return null;
+	if (ts.isStringLiteral(arg)) return arg.text;
+	if (ts.isArrowFunction(arg)) return extractExpressionFromArrowFunction(arg);
+	return null;
+}
+function extractExpressionFromArrowFunction(fn) {
+	const params = fn.parameters.map((p) => p.name.getText());
+	let body = fn.body;
+	if (ts.isBlock(body)) {
+		const returnStmt = body.statements.find(ts.isReturnStatement);
+		if (returnStmt?.expression) body = returnStmt.expression;
+		else return null;
+	}
+	if (ts.isTemplateExpression(body)) return reconstructExpressionFromTemplate(body, params);
+	if (ts.isNoSubstitutionTemplateLiteral(body)) return body.text;
+	return null;
+}
+function reconstructExpressionFromTemplate(template, paramNames) {
+	let result = template.head.text;
+	for (const span of template.templateSpans) {
+		if (ts.isIdentifier(span.expression) && paramNames.includes(span.expression.text)) result += "{string}";
+		else result += "{string}";
+		result += span.literal.text;
+	}
+	return result;
+}
+function extractDependencies(depsCall) {
+	const deps = {
+		given: {},
+		when: {},
+		then: {}
+	};
+	const arg = depsCall.arguments[0];
+	if (!arg || !ts.isObjectLiteralExpression(arg)) return deps;
+	for (const prop of arg.properties) {
+		if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+		const phase = prop.name.text;
+		if (!deps[phase]) continue;
+		if (ts.isObjectLiteralExpression(prop.initializer)) {
+			for (const innerProp of prop.initializer.properties) if (ts.isPropertyAssignment(innerProp) && ts.isIdentifier(innerProp.name) && ts.isStringLiteral(innerProp.initializer)) {
+				const val = innerProp.initializer.text;
+				if (val === "required" || val === "optional") deps[phase][innerProp.name.text] = val;
+			}
+		}
+	}
+	return deps;
+}
+function extractProducedKeys(stepCall, checker) {
+	const callback = stepCall.arguments[0];
+	if (!callback) return [];
+	if (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) return extractProducedKeysFromCallback(callback, checker);
+	return [];
+}
+function extractProducedKeysFromCallback(callback, checker) {
+	const body = callback.body;
+	if (!ts.isBlock(body)) return extractKeysFromExpression(body, checker);
+	const keys = /* @__PURE__ */ new Set();
+	function visitReturn(node) {
+		if (ts.isReturnStatement(node) && node.expression) for (const key of extractKeysFromExpression(node.expression, checker)) keys.add(key);
+		ts.forEachChild(node, visitReturn);
+	}
+	visitReturn(body);
+	return [...keys];
+}
+function extractKeysFromExpression(expr, checker) {
+	while (ts.isParenthesizedExpression(expr)) expr = expr.expression;
+	if (ts.isObjectLiteralExpression(expr)) return expr.properties.filter((p) => ts.isPropertyAssignment(p) || ts.isShorthandPropertyAssignment(p)).map((p) => p.name.getText()).filter(Boolean);
+	try {
+		return checker.getTypeAtLocation(expr).getProperties().map((p) => p.name).filter((n) => n !== "merge");
+	} catch {
+		return [];
+	}
+}
+function resolveReExportedCall(chain, checker) {
+	const lastCall = chain[chain.length - 1];
+	if (!lastCall) return null;
+	const expr = lastCall.expression;
+	let identifier = null;
+	if (ts.isIdentifier(expr)) identifier = expr;
+	else if (ts.isPropertyAccessExpression(expr) && ts.isIdentifier(expr.expression)) identifier = expr.expression;
+	if (!identifier) return null;
+	const symbol = checker.getSymbolAtLocation(identifier);
+	if (!symbol) return null;
+	const decl = symbol.valueDeclaration;
+	if (!decl || !ts.isVariableDeclaration(decl) || !decl.initializer) return null;
+	const init = decl.initializer;
+	if (ts.isPropertyAccessExpression(init) && init.name.text === "statement") {
+		const callExpr = init.expression;
+		if (ts.isCallExpression(callExpr)) {
+			const callee = callExpr.expression;
+			if (ts.isIdentifier(callee) && BUILDER_NAMES[callee.text]) {
+				const expression = extractExpression(lastCall);
+				return {
+					stepType: BUILDER_NAMES[callee.text],
+					expression
+				};
+			}
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/analyzer/gherkinParser.ts
+function parseFeatureFiles(filePaths) {
+	const scenarios = [];
+	for (const filePath of filePaths) {
+		const parsed = parseFeatureContent(fs.readFileSync(filePath, "utf-8"), filePath);
+		scenarios.push(...parsed);
+	}
+	return scenarios;
+}
+function parseFeatureContent(content, filePath) {
+	const feature = new Parser(new AstBuilder(messages.IdGenerator.uuid()), new GherkinClassicTokenMatcher()).parse(content).feature;
+	if (!feature) return [];
+	const featureBackground = [];
+	const scenarios = [];
+	for (const child of feature.children) {
+		if (child.background) featureBackground.push(...child.background.steps);
+		if (child.scenario) scenarios.push(...expandScenario(child.scenario, featureBackground, filePath));
+		if (child.rule) {
+			const ruleBackground = [...featureBackground];
+			for (const ruleChild of child.rule.children) {
+				if (ruleChild.background) ruleBackground.push(...ruleChild.background.steps);
+				if (ruleChild.scenario) scenarios.push(...expandScenario(ruleChild.scenario, ruleBackground, filePath));
+			}
+		}
+	}
+	return scenarios;
+}
+function expandScenario(scenario, backgroundSteps, filePath) {
+	if (!(scenario.examples.length > 0 && scenario.examples.some((e) => e.tableBody.length > 0))) {
+		const bgParsed = convertSteps(backgroundSteps);
+		const scenarioParsed = convertSteps(scenario.steps);
+		const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioParsed]);
+		return [{
+			name: scenario.name,
+			file: filePath,
+			steps: allSteps
+		}];
+	}
+	const results = [];
+	for (const example of scenario.examples) {
+		if (!example.tableHeader || example.tableBody.length === 0) continue;
+		const headers = example.tableHeader.cells.map((c) => c.value);
+		for (const row of example.tableBody) {
+			const values = row.cells.map((c) => c.value);
+			const substitution = {};
+			headers.forEach((h, i) => {
+				substitution[h] = values[i];
+			});
+			const bgParsed = convertSteps(backgroundSteps);
+			const scenarioSteps = convertSteps(scenario.steps).map((step) => ({
+				...step,
+				text: substituteExampleValues(step.text, substitution)
+			}));
+			const allSteps = resolveEffectiveKeywords([...bgParsed, ...scenarioSteps]);
+			results.push({
+				name: `${scenario.name} (${values.join(", ")})`,
+				file: filePath,
+				steps: allSteps
+			});
+		}
+	}
+	return results;
+}
+function convertSteps(steps) {
+	return steps.map((step) => ({
+		keyword: normalizeKeyword(step.keyword),
+		text: step.text,
+		line: step.location.line,
+		column: (step.location.column ?? 1) + step.keyword.length
+	}));
+}
+function normalizeKeyword(keyword) {
+	const trimmed = keyword.trim();
+	if (trimmed === "Given") return "Given";
+	if (trimmed === "When") return "When";
+	if (trimmed === "Then") return "Then";
+	if (trimmed === "And") return "And";
+	if (trimmed === "But") return "But";
+	return "Given";
+}
+function resolveEffectiveKeywords(steps) {
+	let lastEffective = "Given";
+	return steps.map((step) => {
+		let effectiveKeyword;
+		if (step.keyword === "And" || step.keyword === "But") effectiveKeyword = lastEffective;
+		else effectiveKeyword = step.keyword;
+		lastEffective = effectiveKeyword;
+		return {
+			...step,
+			effectiveKeyword
+		};
+	});
+}
+function substituteExampleValues(text, substitution) {
+	let result = text;
+	for (const [key, value] of Object.entries(substitution)) result = result.replace(new RegExp(`<${key}>`, "g"), value);
+	return result;
+}
+//#endregion
+//#region src/analyzer/stepMatcher.ts
+function compileDefinitions(definitions) {
+	const compiled = [];
+	for (const def of definitions) try {
+		const placeholder = "###PLACEHOLDER###";
+		const regexStr = def.expression.replace(/\{[^}]+\}/g, placeholder).replace(/[.*+?^$()|[\]\\]/g, "\\$&").replace(new RegExp(placeholder, "g"), "(.+)");
+		compiled.push({
+			regex: new RegExp(`^${regexStr}$`, "i"),
+			definition: def
+		});
+	} catch {}
+	return compiled;
+}
+function matchScenarioSteps(scenario, definitions) {
+	const compiled = compileDefinitions(definitions);
+	return scenario.steps.map((step) => {
+		const matches = findMatches(step.text, step.effectiveKeyword, compiled);
+		return {
+			...step,
+			definitions: matches
+		};
+	});
+}
+function findMatchingDefinitions(text, effectiveKeyword, definitions) {
+	return findMatches(text, effectiveKeyword, compileDefinitions(definitions));
+}
+function findMatches(text, effectiveKeyword, compiled) {
+	const expectedStepType = {
+		Given: "given",
+		When: "when",
+		Then: "then"
+	}[effectiveKeyword];
+	const typedMatches = [];
+	for (const { regex, definition } of compiled) {
+		if (definition.stepType !== expectedStepType) continue;
+		if (regex.test(text)) typedMatches.push(definition);
+	}
+	if (typedMatches.length > 0) return typedMatches;
+	const fallbackMatches = [];
+	for (const { regex, definition } of compiled) if (regex.test(text)) fallbackMatches.push(definition);
+	return fallbackMatches;
+}
+//#endregion
+//#region src/analyzer/rules/index.ts
+const defaultRules = [
+	{
+		name: "undefined-step",
+		check(scenario, matchedSteps) {
+			return matchedSteps.filter((step) => step.definitions.length === 0).map((step) => ({
+				file: scenario.file,
+				range: {
+					startLine: step.line,
+					startColumn: step.column,
+					endLine: step.line,
+					endColumn: step.column + step.text.length
+				},
+				severity: "error",
+				message: `Step "${step.text}" does not match any step definition`,
+				rule: "undefined-step",
+				source: "step-forge"
+			}));
+		}
+	},
+	{
+		name: "ambiguous-step",
+		check(scenario, matchedSteps) {
+			return matchedSteps.filter((step) => step.definitions.length > 1).map((step) => {
+				const locations = step.definitions.map((d) => `${d.sourceFile}:${d.line}`).join(", ");
+				return {
+					file: scenario.file,
+					range: {
+						startLine: step.line,
+						startColumn: step.column,
+						endLine: step.line,
+						endColumn: step.column + step.text.length
+					},
+					severity: "error",
+					message: `Step "${step.text}" matches multiple step definitions: ${locations}`,
+					rule: "ambiguous-step",
+					source: "step-forge"
+				};
+			});
+		}
+	},
+	{
+		name: "dependency-check",
+		check(scenario, matchedSteps) {
+			const diagnostics = [];
+			const produced = {
+				given: /* @__PURE__ */ new Set(),
+				when: /* @__PURE__ */ new Set(),
+				then: /* @__PURE__ */ new Set()
+			};
+			for (const step of matchedSteps) {
+				if (step.definitions.length !== 1) continue;
+				const { dependencies, produces, stepType } = step.definitions[0];
+				const missing = {};
+				for (const phase of [
+					"given",
+					"when",
+					"then"
+				]) for (const [key, requirement] of Object.entries(dependencies[phase])) if (requirement === "required" && !produced[phase].has(key)) {
+					if (!missing[phase]) missing[phase] = [];
+					missing[phase].push(key);
+				}
+				if (Object.keys(missing).length > 0) {
+					const message = "Missing required dependencies:\n" + Object.entries(missing).map(([phase, keys]) => `${phase.charAt(0).toUpperCase() + phase.slice(1)}: ${keys.map((k) => `${phase}.${k}`).join(", ")}`).join("\n");
+					diagnostics.push({
+						file: scenario.file,
+						range: {
+							startLine: step.line,
+							startColumn: step.column,
+							endLine: step.line,
+							endColumn: step.column + step.text.length
+						},
+						severity: "error",
+						message,
+						rule: "dependency-check",
+						source: "step-forge"
+					});
+				}
+				for (const key of produces) produced[stepType].add(key);
+			}
+			return diagnostics;
+		}
+	}
+];
+function runRules(rules, scenario, matchedSteps) {
+	return rules.flatMap((rule) => rule.check(scenario, matchedSteps));
+}
+//#endregion
+//#region src/analyzer/index.ts
+async function analyze(config, options) {
+	const rules = options?.rules ?? defaultRules;
+	const stepFilePaths = await resolveGlobs(config.stepFiles);
+	const featureFilePaths = await resolveGlobs(config.featureFiles);
+	if (stepFilePaths.length === 0) return [];
+	if (featureFilePaths.length === 0) return [];
+	const stepDefinitions = extractStepDefinitions(stepFilePaths, config.tsConfigPath);
+	const scenarios = parseFeatureFiles(featureFilePaths);
+	const diagnostics = [];
+	for (const scenario of scenarios) {
+		const scenarioDiags = runRules(rules, scenario, matchScenarioSteps(scenario, stepDefinitions));
+		diagnostics.push(...scenarioDiags);
+	}
+	return diagnostics;
+}
+async function resolveGlobs(patterns) {
+	const files = [];
+	for (const pattern of patterns) for await (const file of glob(pattern)) files.push(path.resolve(file));
+	return [...new Set(files)];
+}
+//#endregion
+//#region src/index.ts
+const analyzer = {
+	analyze,
+	extractStepDefinitions,
+	parseFeatureFiles,
+	parseFeatureContent,
+	matchScenarioSteps,
+	findMatchingDefinitions,
+	defaultRules
+};
+//#endregion
+export { BasicWorld, analyzer, givenBuilder, thenBuilder, whenBuilder };
+
+//# sourceMappingURL=step-forge.js.map