@step-forge/step-forge 0.0.12 → 0.0.13
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.
- package/dist/analyzer-QH03uejK.js +478 -0
- package/dist/analyzer-QH03uejK.js.map +1 -0
- package/dist/analyzer-cli.d.ts +1 -0
- package/dist/analyzer-cli.js +69 -0
- package/dist/analyzer-cli.js.map +1 -0
- package/dist/analyzer.d.ts +73 -0
- package/dist/analyzer.js +2 -0
- package/dist/step-forge.cjs +727 -0
- package/dist/step-forge.cjs.map +1 -0
- package/dist/step-forge.d.cts +326 -0
- package/dist/step-forge.d.ts +326 -0
- package/dist/step-forge.js +695 -0
- package/dist/step-forge.js.map +1 -0
- package/package.json +1 -2
- package/.claude/settings.local.json +0 -18
- package/.eslintignore +0 -6
- package/.eslintrc +0 -18
- package/.prettierignore +0 -6
- package/.prettierrc +0 -15
- package/CLAUDE.md +0 -115
- package/cucumber.mjs +0 -39
- package/docs/assets/state_deps.gif +0 -0
- package/features/TESTING.md +0 -100
- package/features/analyzer/analyzer.feature +0 -110
- package/features/analyzer/fixtures/ambiguous-step.feature +0 -5
- package/features/analyzer/fixtures/missing-given-dep.feature +0 -5
- package/features/analyzer/fixtures/missing-multiple-deps.feature +0 -6
- package/features/analyzer/fixtures/missing-when-dep.feature +0 -5
- package/features/analyzer/fixtures/steps.ts +0 -113
- package/features/analyzer/fixtures/undefined-step.feature +0 -5
- package/features/analyzer/fixtures/undefined-with-missing-dep.feature +0 -5
- package/features/analyzer/fixtures/valid-and-but-keywords.feature +0 -8
- package/features/analyzer/fixtures/valid-deps.feature +0 -6
- package/features/analyzer/fixtures/valid-no-deps.feature +0 -6
- package/features/analyzer/fixtures/valid-optional-deps.feature +0 -6
- package/features/analyzer/fixtures/valid-variables.feature +0 -6
- package/features/basic.feature +0 -21
- package/features/exported.feature +0 -6
- package/features/steps/analyzerSteps.ts +0 -67
- package/features/steps/commonSteps.ts +0 -93
- package/features/steps/exportedSteps.ts +0 -42
- package/features/steps/world.ts +0 -29
- package/src/analyzer/cli.ts +0 -96
- package/src/analyzer/gherkinParser.ts +0 -179
- package/src/analyzer/index.ts +0 -89
- package/src/analyzer/rules/ambiguousStepRule.ts +0 -36
- package/src/analyzer/rules/dependencyRule.ts +0 -71
- package/src/analyzer/rules/index.ts +0 -23
- package/src/analyzer/rules/undefinedStepRule.ts +0 -31
- package/src/analyzer/stepExtractor.ts +0 -432
- package/src/analyzer/stepMatcher.ts +0 -85
- package/src/analyzer/types.ts +0 -55
- package/src/builderTypeUtils.ts +0 -27
- package/src/common.ts +0 -138
- package/src/given.ts +0 -102
- package/src/index.ts +0 -46
- package/src/then.ts +0 -128
- package/src/utils.ts +0 -74
- package/src/when.ts +0 -118
- package/src/world.ts +0 -90
- package/test/givenCompilationTests.ts +0 -130
- package/test/testUtils.ts +0 -30
- package/test/thenCompilationTests.ts +0 -207
- package/test/whenCompilationTests.ts +0 -157
- package/ts-node-esm-register.js +0 -8
- package/tsconfig.cucumber.json +0 -14
- package/tsconfig.json +0 -29
- package/tsdown.config.ts +0 -35
|
@@ -0,0 +1,326 @@
|
|
|
1
|
+
//#region src/builderTypeUtils.d.ts
|
|
2
|
+
type EmptyObject = Record<string, never>;
|
|
3
|
+
type RequiredOrOptional<T> = { [K in keyof T]?: "required" | "optional" };
|
|
4
|
+
type GetFunctionArgs<T> = T extends ((...args: infer A) => any) ? A : never;
|
|
5
|
+
type EmptyDependencies = {
|
|
6
|
+
given: EmptyObject;
|
|
7
|
+
when: EmptyObject;
|
|
8
|
+
then: EmptyObject;
|
|
9
|
+
};
|
|
10
|
+
//#endregion
|
|
11
|
+
//#region src/given.d.ts
|
|
12
|
+
declare const givenBuilder: <GivenState>() => {
|
|
13
|
+
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
14
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>>(dependencies: {
|
|
15
|
+
given: GivenDeps;
|
|
16
|
+
}) => {
|
|
17
|
+
step: (stepFunction: (input: {
|
|
18
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
19
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
20
|
+
when: never;
|
|
21
|
+
then: never;
|
|
22
|
+
}) => Partial<GivenState>) => {
|
|
23
|
+
statement: Statement extends string ? () => string : Statement;
|
|
24
|
+
dependencies: {
|
|
25
|
+
given: GivenDeps;
|
|
26
|
+
} & {
|
|
27
|
+
when: EmptyObject;
|
|
28
|
+
then: EmptyObject;
|
|
29
|
+
};
|
|
30
|
+
stepType: "given";
|
|
31
|
+
stepFunction: (input: {
|
|
32
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
33
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
34
|
+
when: never;
|
|
35
|
+
then: never;
|
|
36
|
+
}) => Partial<GivenState>;
|
|
37
|
+
register: () => {
|
|
38
|
+
stepType: "given";
|
|
39
|
+
dependencies: {
|
|
40
|
+
given: GivenDeps;
|
|
41
|
+
} & {
|
|
42
|
+
when: EmptyObject;
|
|
43
|
+
then: EmptyObject;
|
|
44
|
+
};
|
|
45
|
+
statement: Statement extends string ? () => string : Statement;
|
|
46
|
+
stepFunction: (input: {
|
|
47
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
48
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
49
|
+
when: never;
|
|
50
|
+
then: never;
|
|
51
|
+
}) => Partial<GivenState>;
|
|
52
|
+
};
|
|
53
|
+
};
|
|
54
|
+
};
|
|
55
|
+
step: (stepFunction: (input: {
|
|
56
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
57
|
+
given: never;
|
|
58
|
+
when: never;
|
|
59
|
+
then: never;
|
|
60
|
+
}) => Partial<GivenState>) => {
|
|
61
|
+
statement: Statement extends string ? () => string : Statement;
|
|
62
|
+
dependencies: EmptyDependencies;
|
|
63
|
+
stepType: "given";
|
|
64
|
+
stepFunction: (input: {
|
|
65
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
66
|
+
given: never;
|
|
67
|
+
when: never;
|
|
68
|
+
then: never;
|
|
69
|
+
}) => Partial<GivenState>;
|
|
70
|
+
register: () => {
|
|
71
|
+
stepType: "given";
|
|
72
|
+
dependencies: EmptyDependencies;
|
|
73
|
+
statement: Statement extends string ? () => string : Statement;
|
|
74
|
+
stepFunction: (input: {
|
|
75
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
76
|
+
given: never;
|
|
77
|
+
when: never;
|
|
78
|
+
then: never;
|
|
79
|
+
}) => Partial<GivenState>;
|
|
80
|
+
};
|
|
81
|
+
};
|
|
82
|
+
};
|
|
83
|
+
};
|
|
84
|
+
//#endregion
|
|
85
|
+
//#region src/when.d.ts
|
|
86
|
+
declare const whenBuilder: <GivenState, WhenState>() => {
|
|
87
|
+
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
88
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>>(dependencies: {
|
|
89
|
+
given?: GivenDeps | undefined;
|
|
90
|
+
when?: WhenDeps | undefined;
|
|
91
|
+
}) => {
|
|
92
|
+
step: (stepFunction: (input: {
|
|
93
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
94
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
95
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
96
|
+
then: never;
|
|
97
|
+
}) => Partial<WhenState>) => {
|
|
98
|
+
statement: Statement extends string ? () => string : Statement;
|
|
99
|
+
dependencies: {
|
|
100
|
+
given: GivenDeps;
|
|
101
|
+
when: WhenDeps;
|
|
102
|
+
then: EmptyObject;
|
|
103
|
+
};
|
|
104
|
+
stepType: "when";
|
|
105
|
+
stepFunction: (input: {
|
|
106
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
107
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
108
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
109
|
+
then: never;
|
|
110
|
+
}) => Partial<WhenState>;
|
|
111
|
+
register: () => {
|
|
112
|
+
stepType: "when";
|
|
113
|
+
dependencies: {
|
|
114
|
+
given: GivenDeps;
|
|
115
|
+
when: WhenDeps;
|
|
116
|
+
then: EmptyObject;
|
|
117
|
+
};
|
|
118
|
+
statement: Statement extends string ? () => string : Statement;
|
|
119
|
+
stepFunction: (input: {
|
|
120
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
121
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
122
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
123
|
+
then: never;
|
|
124
|
+
}) => Partial<WhenState>;
|
|
125
|
+
};
|
|
126
|
+
};
|
|
127
|
+
};
|
|
128
|
+
step: (stepFunction: (input: {
|
|
129
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
130
|
+
given: never;
|
|
131
|
+
when: never;
|
|
132
|
+
then: never;
|
|
133
|
+
}) => Partial<WhenState>) => {
|
|
134
|
+
statement: Statement extends string ? () => string : Statement;
|
|
135
|
+
dependencies: EmptyDependencies;
|
|
136
|
+
stepType: "when";
|
|
137
|
+
stepFunction: (input: {
|
|
138
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
139
|
+
given: never;
|
|
140
|
+
when: never;
|
|
141
|
+
then: never;
|
|
142
|
+
}) => Partial<WhenState>;
|
|
143
|
+
register: () => {
|
|
144
|
+
stepType: "when";
|
|
145
|
+
dependencies: EmptyDependencies;
|
|
146
|
+
statement: Statement extends string ? () => string : Statement;
|
|
147
|
+
stepFunction: (input: {
|
|
148
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
149
|
+
given: never;
|
|
150
|
+
when: never;
|
|
151
|
+
then: never;
|
|
152
|
+
}) => Partial<WhenState>;
|
|
153
|
+
};
|
|
154
|
+
};
|
|
155
|
+
};
|
|
156
|
+
};
|
|
157
|
+
//#endregion
|
|
158
|
+
//#region src/then.d.ts
|
|
159
|
+
declare const thenBuilder: <GivenState, WhenState, ThenState>() => {
|
|
160
|
+
statement: <Statement extends ((...args: [...any]) => string) | string>(statement: Statement) => {
|
|
161
|
+
dependencies: <GivenDeps extends RequiredOrOptional<GivenState>, WhenDeps extends RequiredOrOptional<WhenState>, ThenDeps extends RequiredOrOptional<ThenState>>(dependencies: {
|
|
162
|
+
given?: GivenDeps | undefined;
|
|
163
|
+
when?: WhenDeps | undefined;
|
|
164
|
+
then?: ThenDeps | undefined;
|
|
165
|
+
}) => {
|
|
166
|
+
step: (stepFunction: (input: {
|
|
167
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
168
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
169
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
170
|
+
then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
|
|
171
|
+
}) => void | Partial<ThenState>) => {
|
|
172
|
+
statement: Statement extends string ? () => string : Statement;
|
|
173
|
+
dependencies: {
|
|
174
|
+
given: GivenDeps;
|
|
175
|
+
when: WhenDeps;
|
|
176
|
+
then: ThenDeps;
|
|
177
|
+
};
|
|
178
|
+
stepType: "then";
|
|
179
|
+
stepFunction: (input: {
|
|
180
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
181
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
182
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
183
|
+
then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
|
|
184
|
+
}) => void | Partial<ThenState>;
|
|
185
|
+
register: () => {
|
|
186
|
+
stepType: "then";
|
|
187
|
+
dependencies: {
|
|
188
|
+
given: GivenDeps;
|
|
189
|
+
when: WhenDeps;
|
|
190
|
+
then: ThenDeps;
|
|
191
|
+
};
|
|
192
|
+
statement: Statement extends string ? () => string : Statement;
|
|
193
|
+
stepFunction: (input: {
|
|
194
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
195
|
+
given: { [K in keyof GivenState as K extends keyof GivenDeps ? K : never]: GivenDeps[K] extends "optional" ? GivenState[K] | undefined : GivenState[K] };
|
|
196
|
+
when: { [K_1 in keyof WhenState as K_1 extends keyof WhenDeps ? K_1 : never]: WhenDeps[K_1] extends "optional" ? WhenState[K_1] | undefined : WhenState[K_1] };
|
|
197
|
+
then: { [K_2 in keyof ThenState as K_2 extends keyof ThenDeps ? K_2 : never]: ThenDeps[K_2] extends "optional" ? ThenState[K_2] | undefined : ThenState[K_2] };
|
|
198
|
+
}) => void | Partial<ThenState>;
|
|
199
|
+
};
|
|
200
|
+
};
|
|
201
|
+
};
|
|
202
|
+
step: (stepFunction: (input: {
|
|
203
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
204
|
+
given: never;
|
|
205
|
+
when: never;
|
|
206
|
+
then: never;
|
|
207
|
+
}) => void | Partial<ThenState>) => {
|
|
208
|
+
statement: Statement extends string ? () => string : Statement;
|
|
209
|
+
dependencies: EmptyDependencies;
|
|
210
|
+
stepType: "then";
|
|
211
|
+
stepFunction: (input: {
|
|
212
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
213
|
+
given: never;
|
|
214
|
+
when: never;
|
|
215
|
+
then: never;
|
|
216
|
+
}) => void | Partial<ThenState>;
|
|
217
|
+
register: () => {
|
|
218
|
+
stepType: "then";
|
|
219
|
+
dependencies: EmptyDependencies;
|
|
220
|
+
statement: Statement extends string ? () => string : Statement;
|
|
221
|
+
stepFunction: (input: {
|
|
222
|
+
variables: Statement extends string ? [] : GetFunctionArgs<Statement>;
|
|
223
|
+
given: never;
|
|
224
|
+
when: never;
|
|
225
|
+
then: never;
|
|
226
|
+
}) => void | Partial<ThenState>;
|
|
227
|
+
};
|
|
228
|
+
};
|
|
229
|
+
};
|
|
230
|
+
};
|
|
231
|
+
//#endregion
|
|
232
|
+
//#region src/world.d.ts
|
|
233
|
+
type WorldState<State> = { readonly [K in keyof State]?: State[K] };
|
|
234
|
+
type MergeableWorldState<T> = WorldState<T> & {
|
|
235
|
+
merge: (newState: Partial<T>) => void;
|
|
236
|
+
};
|
|
237
|
+
declare class BasicWorld<Given, When, Then> {
|
|
238
|
+
private givenState;
|
|
239
|
+
private whenState;
|
|
240
|
+
private thenState;
|
|
241
|
+
get given(): MergeableWorldState<Given>;
|
|
242
|
+
get when(): MergeableWorldState<When>;
|
|
243
|
+
get then(): MergeableWorldState<Then>;
|
|
244
|
+
}
|
|
245
|
+
//#endregion
|
|
246
|
+
//#region src/analyzer/types.d.ts
|
|
247
|
+
interface StepDefinitionMeta {
|
|
248
|
+
stepType: "given" | "when" | "then";
|
|
249
|
+
expression: string;
|
|
250
|
+
dependencies: {
|
|
251
|
+
given: Record<string, "required" | "optional">;
|
|
252
|
+
when: Record<string, "required" | "optional">;
|
|
253
|
+
then: Record<string, "required" | "optional">;
|
|
254
|
+
};
|
|
255
|
+
produces: string[];
|
|
256
|
+
sourceFile: string;
|
|
257
|
+
line: number;
|
|
258
|
+
}
|
|
259
|
+
interface ParsedScenario {
|
|
260
|
+
name: string;
|
|
261
|
+
file: string;
|
|
262
|
+
steps: ParsedStep[];
|
|
263
|
+
}
|
|
264
|
+
interface ParsedStep {
|
|
265
|
+
keyword: "Given" | "When" | "Then" | "And" | "But";
|
|
266
|
+
effectiveKeyword: "Given" | "When" | "Then";
|
|
267
|
+
text: string;
|
|
268
|
+
line: number;
|
|
269
|
+
column: number;
|
|
270
|
+
}
|
|
271
|
+
interface MatchedStep extends ParsedStep {
|
|
272
|
+
definitions: StepDefinitionMeta[];
|
|
273
|
+
}
|
|
274
|
+
interface Diagnostic {
|
|
275
|
+
file: string;
|
|
276
|
+
range: {
|
|
277
|
+
startLine: number;
|
|
278
|
+
startColumn: number;
|
|
279
|
+
endLine: number;
|
|
280
|
+
endColumn: number;
|
|
281
|
+
};
|
|
282
|
+
severity: "error" | "warning" | "info";
|
|
283
|
+
message: string;
|
|
284
|
+
rule: string;
|
|
285
|
+
source: "step-forge";
|
|
286
|
+
}
|
|
287
|
+
interface AnalysisRule {
|
|
288
|
+
name: string;
|
|
289
|
+
check(scenario: ParsedScenario, matchedSteps: MatchedStep[]): Diagnostic[];
|
|
290
|
+
}
|
|
291
|
+
interface AnalyzerConfig {
|
|
292
|
+
stepFiles: string[];
|
|
293
|
+
featureFiles: string[];
|
|
294
|
+
tsConfigPath?: string;
|
|
295
|
+
}
|
|
296
|
+
//#endregion
|
|
297
|
+
//#region src/analyzer/stepExtractor.d.ts
|
|
298
|
+
declare function extractStepDefinitions(filePaths: string[], tsConfigPath?: string): StepDefinitionMeta[];
|
|
299
|
+
//#endregion
|
|
300
|
+
//#region src/analyzer/gherkinParser.d.ts
|
|
301
|
+
declare function parseFeatureFiles(filePaths: string[]): ParsedScenario[];
|
|
302
|
+
declare function parseFeatureContent(content: string, filePath: string): ParsedScenario[];
|
|
303
|
+
//#endregion
|
|
304
|
+
//#region src/analyzer/stepMatcher.d.ts
|
|
305
|
+
declare function matchScenarioSteps(scenario: ParsedScenario, definitions: StepDefinitionMeta[]): MatchedStep[];
|
|
306
|
+
declare function findMatchingDefinitions(text: string, effectiveKeyword: "Given" | "When" | "Then", definitions: StepDefinitionMeta[]): StepDefinitionMeta[];
|
|
307
|
+
//#endregion
|
|
308
|
+
//#region src/analyzer/index.d.ts
|
|
309
|
+
interface AnalyzeOptions {
|
|
310
|
+
rules?: AnalysisRule[];
|
|
311
|
+
}
|
|
312
|
+
declare function analyze(config: AnalyzerConfig, options?: AnalyzeOptions): Promise<Diagnostic[]>;
|
|
313
|
+
//#endregion
|
|
314
|
+
//#region src/index.d.ts
|
|
315
|
+
declare const analyzer: {
|
|
316
|
+
analyze: typeof analyze;
|
|
317
|
+
extractStepDefinitions: typeof extractStepDefinitions;
|
|
318
|
+
parseFeatureFiles: typeof parseFeatureFiles;
|
|
319
|
+
parseFeatureContent: typeof parseFeatureContent;
|
|
320
|
+
matchScenarioSteps: typeof matchScenarioSteps;
|
|
321
|
+
findMatchingDefinitions: typeof findMatchingDefinitions;
|
|
322
|
+
defaultRules: AnalysisRule[];
|
|
323
|
+
};
|
|
324
|
+
//#endregion
|
|
325
|
+
export { type AnalysisRule, type AnalyzeOptions, type AnalyzerConfig, BasicWorld, type Diagnostic, type MatchedStep, type ParsedScenario, type ParsedStep, type StepDefinitionMeta, analyzer, givenBuilder, thenBuilder, whenBuilder };
|
|
326
|
+
//# sourceMappingURL=step-forge.d.ts.map
|