@dev-blinq/cucumber-js 1.0.36 → 1.0.37-stage

package/lib/support_code_library_builder/sourced_parameter_type_registry.js

@@ -1,19 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SourcedParameterTypeRegistry = void 0;
-const cucumber_expressions_1 = require("@cucumber/cucumber-expressions");
-class SourcedParameterTypeRegistry extends cucumber_expressions_1.ParameterTypeRegistry {
-    constructor() {
-        super(...arguments);
-        this.parameterTypeToSource = new WeakMap();
-    }
-    defineSourcedParameterType(parameterType, source) {
-        this.defineParameterType(parameterType);
-        this.parameterTypeToSource.set(parameterType, source);
-    }
-    lookupSource(parameterType) {
-        return this.parameterTypeToSource.get(parameterType);
-    }
-}
-exports.SourcedParameterTypeRegistry = SourcedParameterTypeRegistry;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourcedParameterTypeRegistry = void 0;
+const cucumber_expressions_1 = require("@cucumber/cucumber-expressions");
+class SourcedParameterTypeRegistry extends cucumber_expressions_1.ParameterTypeRegistry {
+    constructor() {
+        super(...arguments);
+        this.parameterTypeToSource = new WeakMap();
+    }
+    defineSourcedParameterType(parameterType, source) {
+        this.defineParameterType(parameterType);
+        this.parameterTypeToSource.set(parameterType, source);
+    }
+    lookupSource(parameterType) {
+        return this.parameterTypeToSource.get(parameterType);
+    }
+}
+exports.SourcedParameterTypeRegistry = SourcedParameterTypeRegistry;
 //# sourceMappingURL=sourced_parameter_type_registry.js.map

package/lib/support_code_library_builder/types.d.ts

@@ -1,88 +1,88 @@
-import * as messages from '@cucumber/messages';
-import TestCaseHookDefinition from '../models/test_case_hook_definition';
-import TestStepHookDefinition from '../models/test_step_hook_definition';
-import TestRunHookDefinition from '../models/test_run_hook_definition';
-import StepDefinition from '../models/step_definition';
-import { IWorld } from './world';
-import { SourcedParameterTypeRegistry } from './sourced_parameter_type_registry';
-export type DefineStepPattern = string | RegExp;
-export type ParallelAssignmentValidator = (pickle: messages.Pickle, runningPickles: messages.Pickle[]) => boolean;
-export interface ITestCaseHookParameter {
-    gherkinDocument: messages.GherkinDocument;
-    pickle: messages.Pickle;
-    result?: messages.TestStepResult;
-    willBeRetried?: boolean;
-    testCaseStartedId: string;
-}
-export interface ITestStepHookParameter {
-    gherkinDocument: messages.GherkinDocument;
-    pickle: messages.Pickle;
-    pickleStep: messages.PickleStep;
-    result: messages.TestStepResult;
-    testCaseStartedId: string;
-    testStepId: string;
-}
-export type TestCaseHookFunction<WorldType> = (this: WorldType, arg: ITestCaseHookParameter) => any | Promise<any>;
-export type TestStepHookFunction<WorldType> = (this: WorldType, arg: ITestStepHookParameter) => any | Promise<any>;
-export type TestStepFunction<WorldType> = (this: WorldType, ...args: any[]) => any | Promise<any>;
-export interface IDefineStepOptions {
-    timeout?: number;
-    wrapperOptions?: any;
-}
-export interface IDefineTestCaseHookOptions {
-    name?: string;
-    tags?: string;
-    timeout?: number;
-}
-export interface IDefineTestStepHookOptions {
-    tags?: string;
-    timeout?: number;
-}
-export interface IDefineTestRunHookOptions {
-    timeout?: number;
-}
-export interface IParameterTypeDefinition<T> {
-    name: string;
-    regexp: readonly RegExp[] | readonly string[] | RegExp | string;
-    transformer: (...match: string[]) => T;
-    useForSnippets?: boolean;
-    preferForRegexpMatch?: boolean;
-}
-export type IDefineStep = (<WorldType = IWorld>(pattern: DefineStepPattern, code: TestStepFunction<WorldType>) => void) & (<WorldType = IWorld>(pattern: DefineStepPattern, options: IDefineStepOptions, code: TestStepFunction<WorldType>) => void);
-export interface IDefineSupportCodeMethods {
-    defineParameterType: (options: IParameterTypeDefinition<any>) => void;
-    defineStep: IDefineStep;
-    setDefaultTimeout: (milliseconds: number) => void;
-    setDefinitionFunctionWrapper: (fn: Function) => void;
-    setParallelCanAssign: (fn: ParallelAssignmentValidator) => void;
-    setWorldConstructor: (fn: any) => void;
-    After: (<WorldType = IWorld>(code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestCaseHookOptions, code: TestCaseHookFunction<WorldType>) => void);
-    AfterStep: (<WorldType = IWorld>(code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestStepHookOptions, code: TestStepHookFunction<WorldType>) => void);
-    AfterAll: ((code: Function) => void) & ((options: IDefineTestRunHookOptions, code: Function) => void);
-    Before: (<WorldType = IWorld>(code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestCaseHookOptions, code: TestCaseHookFunction<WorldType>) => void);
-    BeforeStep: (<WorldType = IWorld>(code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestStepHookOptions, code: TestStepHookFunction<WorldType>) => void);
-    BeforeAll: ((code: Function) => void) & ((options: IDefineTestRunHookOptions, code: Function) => void);
-    Given: IDefineStep;
-    Then: IDefineStep;
-    When: IDefineStep;
-}
-export interface ISupportCodeCoordinates {
-    requireModules: string[];
-    requirePaths: string[];
-    importPaths: string[];
-}
-export interface ISupportCodeLibrary {
-    readonly originalCoordinates: ISupportCodeCoordinates;
-    readonly afterTestCaseHookDefinitions: TestCaseHookDefinition[];
-    readonly afterTestStepHookDefinitions: TestStepHookDefinition[];
-    readonly afterTestRunHookDefinitions: TestRunHookDefinition[];
-    readonly beforeTestCaseHookDefinitions: TestCaseHookDefinition[];
-    readonly beforeTestStepHookDefinitions: TestStepHookDefinition[];
-    readonly beforeTestRunHookDefinitions: TestRunHookDefinition[];
-    readonly defaultTimeout: number;
-    readonly stepDefinitions: StepDefinition[];
-    readonly undefinedParameterTypes: messages.UndefinedParameterType[];
-    readonly parameterTypeRegistry: SourcedParameterTypeRegistry;
-    readonly World: any;
-    readonly parallelCanAssign: ParallelAssignmentValidator;
-}
+import * as messages from '@cucumber/messages';
+import TestCaseHookDefinition from '../models/test_case_hook_definition';
+import TestStepHookDefinition from '../models/test_step_hook_definition';
+import TestRunHookDefinition from '../models/test_run_hook_definition';
+import StepDefinition from '../models/step_definition';
+import { IWorld } from './world';
+import { SourcedParameterTypeRegistry } from './sourced_parameter_type_registry';
+export type DefineStepPattern = string | RegExp;
+export type ParallelAssignmentValidator = (pickle: messages.Pickle, runningPickles: messages.Pickle[]) => boolean;
+export interface ITestCaseHookParameter {
+    gherkinDocument: messages.GherkinDocument;
+    pickle: messages.Pickle;
+    result?: messages.TestStepResult;
+    willBeRetried?: boolean;
+    testCaseStartedId: string;
+}
+export interface ITestStepHookParameter {
+    gherkinDocument: messages.GherkinDocument;
+    pickle: messages.Pickle;
+    pickleStep: messages.PickleStep;
+    result: messages.TestStepResult;
+    testCaseStartedId: string;
+    testStepId: string;
+}
+export type TestCaseHookFunction<WorldType> = (this: WorldType, arg: ITestCaseHookParameter) => any | Promise<any>;
+export type TestStepHookFunction<WorldType> = (this: WorldType, arg: ITestStepHookParameter) => any | Promise<any>;
+export type TestStepFunction<WorldType> = (this: WorldType, ...args: any[]) => any | Promise<any>;
+export interface IDefineStepOptions {
+    timeout?: number;
+    wrapperOptions?: any;
+}
+export interface IDefineTestCaseHookOptions {
+    name?: string;
+    tags?: string;
+    timeout?: number;
+}
+export interface IDefineTestStepHookOptions {
+    tags?: string;
+    timeout?: number;
+}
+export interface IDefineTestRunHookOptions {
+    timeout?: number;
+}
+export interface IParameterTypeDefinition<T> {
+    name: string;
+    regexp: readonly RegExp[] | readonly string[] | RegExp | string;
+    transformer: (...match: string[]) => T;
+    useForSnippets?: boolean;
+    preferForRegexpMatch?: boolean;
+}
+export type IDefineStep = (<WorldType = IWorld>(pattern: DefineStepPattern, code: TestStepFunction<WorldType>) => void) & (<WorldType = IWorld>(pattern: DefineStepPattern, options: IDefineStepOptions, code: TestStepFunction<WorldType>) => void);
+export interface IDefineSupportCodeMethods {
+    defineParameterType: (options: IParameterTypeDefinition<any>) => void;
+    defineStep: IDefineStep;
+    setDefaultTimeout: (milliseconds: number) => void;
+    setDefinitionFunctionWrapper: (fn: Function) => void;
+    setParallelCanAssign: (fn: ParallelAssignmentValidator) => void;
+    setWorldConstructor: (fn: any) => void;
+    After: (<WorldType = IWorld>(code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestCaseHookOptions, code: TestCaseHookFunction<WorldType>) => void);
+    AfterStep: (<WorldType = IWorld>(code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestStepHookOptions, code: TestStepHookFunction<WorldType>) => void);
+    AfterAll: ((code: Function) => void) & ((options: IDefineTestRunHookOptions, code: Function) => void);
+    Before: (<WorldType = IWorld>(code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestCaseHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestCaseHookOptions, code: TestCaseHookFunction<WorldType>) => void);
+    BeforeStep: (<WorldType = IWorld>(code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(tags: string, code: TestStepHookFunction<WorldType>) => void) & (<WorldType = IWorld>(options: IDefineTestStepHookOptions, code: TestStepHookFunction<WorldType>) => void);
+    BeforeAll: ((code: Function) => void) & ((options: IDefineTestRunHookOptions, code: Function) => void);
+    Given: IDefineStep;
+    Then: IDefineStep;
+    When: IDefineStep;
+}
+export interface ISupportCodeCoordinates {
+    requireModules: string[];
+    requirePaths: string[];
+    importPaths: string[];
+}
+export interface ISupportCodeLibrary {
+    readonly originalCoordinates: ISupportCodeCoordinates;
+    readonly afterTestCaseHookDefinitions: TestCaseHookDefinition[];
+    readonly afterTestStepHookDefinitions: TestStepHookDefinition[];
+    readonly afterTestRunHookDefinitions: TestRunHookDefinition[];
+    readonly beforeTestCaseHookDefinitions: TestCaseHookDefinition[];
+    readonly beforeTestStepHookDefinitions: TestStepHookDefinition[];
+    readonly beforeTestRunHookDefinitions: TestRunHookDefinition[];
+    readonly defaultTimeout: number;
+    readonly stepDefinitions: StepDefinition[];
+    readonly undefinedParameterTypes: messages.UndefinedParameterType[];
+    readonly parameterTypeRegistry: SourcedParameterTypeRegistry;
+    readonly World: any;
+    readonly parallelCanAssign: ParallelAssignmentValidator;
+}

package/lib/support_code_library_builder/types.js

@@ -1,3 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/lib/support_code_library_builder/validate_arguments.d.ts

@@ -1,12 +1,12 @@
-import { DefineStepPattern, IDefineStepOptions } from './types';
-interface IDefineStepArguments {
-    pattern?: DefineStepPattern;
-    options?: IDefineStepOptions;
-    code?: Function;
-}
-export default function validateArguments({ args, fnName, location, }: {
-    args?: IDefineStepArguments;
-    fnName: string;
-    location: string;
-}): void;
-export {};
+import { DefineStepPattern, IDefineStepOptions } from './types';
+interface IDefineStepArguments {
+    pattern?: DefineStepPattern;
+    options?: IDefineStepOptions;
+    code?: Function;
+}
+export default function validateArguments({ args, fnName, location, }: {
+    args?: IDefineStepArguments;
+    fnName: string;
+    location: string;
+}): void;
+export {};

package/lib/support_code_library_builder/validate_arguments.js

@@ -1,73 +1,73 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const optionsValidation = {
-    expectedType: 'object or function',
-    predicate({ options }) {
-        return typeof options === 'object';
-    },
-};
-const optionsTimeoutValidation = {
-    identifier: '"options.timeout"',
-    expectedType: 'integer',
-    predicate({ options }) {
-        return options.timeout == null || typeof options.timeout === 'number';
-    },
-};
-const fnValidation = {
-    expectedType: 'function',
-    predicate({ code }) {
-        return typeof code === 'function';
-    },
-};
-const validations = {
-    defineTestRunHook: [
-        { identifier: 'first argument', ...optionsValidation },
-        optionsTimeoutValidation,
-        { identifier: 'second argument', ...fnValidation },
-    ],
-    defineTestCaseHook: [
-        { identifier: 'first argument', ...optionsValidation },
-        {
-            identifier: '"options.tags"',
-            expectedType: 'string',
-            predicate({ options }) {
-                return options.tags == null || typeof options.tags === 'string';
-            },
-        },
-        optionsTimeoutValidation,
-        { identifier: 'second argument', ...fnValidation },
-    ],
-    defineTestStepHook: [
-        { identifier: 'first argument', ...optionsValidation },
-        {
-            identifier: '"options.tags"',
-            expectedType: 'string',
-            predicate({ options }) {
-                return options.tags == null || typeof options.tags === 'string';
-            },
-        },
-        optionsTimeoutValidation,
-        { identifier: 'second argument', ...fnValidation },
-    ],
-    defineStep: [
-        {
-            identifier: 'first argument',
-            expectedType: 'string or regular expression',
-            predicate({ pattern }) {
-                return pattern instanceof RegExp || typeof pattern === 'string';
-            },
-        },
-        { identifier: 'second argument', ...optionsValidation },
-        optionsTimeoutValidation,
-        { identifier: 'third argument', ...fnValidation },
-    ],
-};
-function validateArguments({ args, fnName, location, }) {
-    validations[fnName].forEach(({ identifier, expectedType, predicate }) => {
-        if (!predicate(args)) {
-            throw new Error(`${location}: Invalid ${identifier}: should be a ${expectedType}`);
-        }
-    });
-}
-exports.default = validateArguments;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const optionsValidation = {
+    expectedType: 'object or function',
+    predicate({ options }) {
+        return typeof options === 'object';
+    },
+};
+const optionsTimeoutValidation = {
+    identifier: '"options.timeout"',
+    expectedType: 'integer',
+    predicate({ options }) {
+        return options.timeout == null || typeof options.timeout === 'number';
+    },
+};
+const fnValidation = {
+    expectedType: 'function',
+    predicate({ code }) {
+        return typeof code === 'function';
+    },
+};
+const validations = {
+    defineTestRunHook: [
+        { identifier: 'first argument', ...optionsValidation },
+        optionsTimeoutValidation,
+        { identifier: 'second argument', ...fnValidation },
+    ],
+    defineTestCaseHook: [
+        { identifier: 'first argument', ...optionsValidation },
+        {
+            identifier: '"options.tags"',
+            expectedType: 'string',
+            predicate({ options }) {
+                return options.tags == null || typeof options.tags === 'string';
+            },
+        },
+        optionsTimeoutValidation,
+        { identifier: 'second argument', ...fnValidation },
+    ],
+    defineTestStepHook: [
+        { identifier: 'first argument', ...optionsValidation },
+        {
+            identifier: '"options.tags"',
+            expectedType: 'string',
+            predicate({ options }) {
+                return options.tags == null || typeof options.tags === 'string';
+            },
+        },
+        optionsTimeoutValidation,
+        { identifier: 'second argument', ...fnValidation },
+    ],
+    defineStep: [
+        {
+            identifier: 'first argument',
+            expectedType: 'string or regular expression',
+            predicate({ pattern }) {
+                return pattern instanceof RegExp || typeof pattern === 'string';
+            },
+        },
+        { identifier: 'second argument', ...optionsValidation },
+        optionsTimeoutValidation,
+        { identifier: 'third argument', ...fnValidation },
+    ],
+};
+function validateArguments({ args, fnName, location, }) {
+    validations[fnName].forEach(({ identifier, expectedType, predicate }) => {
+        if (!predicate(args)) {
+            throw new Error(`${location}: Invalid ${identifier}: should be a ${expectedType}`);
+        }
+    });
+}
+exports.default = validateArguments;
 //# sourceMappingURL=validate_arguments.js.map

package/lib/support_code_library_builder/world.d.ts

@@ -1,18 +1,18 @@
-import { ICreateAttachment, ICreateLog } from '../runtime/attachment_manager';
-export interface IWorldOptions<ParametersType = any> {
-    attach: ICreateAttachment;
-    log: ICreateLog;
-    parameters: ParametersType;
-}
-export interface IWorld<ParametersType = any> {
-    readonly attach: ICreateAttachment;
-    readonly log: ICreateLog;
-    readonly parameters: ParametersType;
-    [key: string]: any;
-}
-export default class World<ParametersType = any> implements IWorld<ParametersType> {
-    readonly attach: ICreateAttachment;
-    readonly log: ICreateLog;
-    readonly parameters: ParametersType;
-    constructor({ attach, log, parameters }: IWorldOptions<ParametersType>);
-}
+import { ICreateAttachment, ICreateLog } from '../runtime/attachment_manager';
+export interface IWorldOptions<ParametersType = any> {
+    attach: ICreateAttachment;
+    log: ICreateLog;
+    parameters: ParametersType;
+}
+export interface IWorld<ParametersType = any> {
+    readonly attach: ICreateAttachment;
+    readonly log: ICreateLog;
+    readonly parameters: ParametersType;
+    [key: string]: any;
+}
+export default class World<ParametersType = any> implements IWorld<ParametersType> {
+    readonly attach: ICreateAttachment;
+    readonly log: ICreateLog;
+    readonly parameters: ParametersType;
+    constructor({ attach, log, parameters }: IWorldOptions<ParametersType>);
+}

package/lib/support_code_library_builder/world.js

@@ -1,11 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class World {
-    constructor({ attach, log, parameters }) {
-        this.attach = attach;
-        this.log = log;
-        this.parameters = parameters;
-    }
-}
-exports.default = World;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class World {
+    constructor({ attach, log, parameters }) {
+        this.attach = attach;
+        this.log = log;
+        this.parameters = parameters;
+    }
+}
+exports.default = World;
 //# sourceMappingURL=world.js.map

package/lib/time.d.ts

@@ -1,18 +1,18 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import { performance } from 'perf_hooks';
-import * as messages from '@cucumber/messages';
-interface ProtectedTimingBuiltins {
-    clearImmediate: typeof clearImmediate;
-    clearInterval: typeof clearInterval;
-    clearTimeout: typeof clearTimeout;
-    Date: typeof Date;
-    setImmediate: typeof setImmediate;
-    setInterval: typeof setInterval;
-    setTimeout: typeof setTimeout;
-    performance: typeof performance;
-}
-declare const methods: Partial<ProtectedTimingBuiltins>;
-export declare function durationBetweenTimestamps(startedTimestamp: messages.Timestamp, finishedTimestamp: messages.Timestamp): messages.Duration;
-export declare function wrapPromiseWithTimeout<T>(promise: Promise<T>, timeoutInMilliseconds: number, timeoutMessage?: string): Promise<T>;
-export default methods;
+/// <reference types="node" />
+/// <reference types="node" />
+import { performance } from 'perf_hooks';
+import * as messages from '@cucumber/messages';
+interface ProtectedTimingBuiltins {
+    clearImmediate: typeof clearImmediate;
+    clearInterval: typeof clearInterval;
+    clearTimeout: typeof clearTimeout;
+    Date: typeof Date;
+    setImmediate: typeof setImmediate;
+    setInterval: typeof setInterval;
+    setTimeout: typeof setTimeout;
+    performance: typeof performance;
+}
+declare const methods: Partial<ProtectedTimingBuiltins>;
+export declare function durationBetweenTimestamps(startedTimestamp: messages.Timestamp, finishedTimestamp: messages.Timestamp): messages.Duration;
+export declare function wrapPromiseWithTimeout<T>(promise: Promise<T>, timeoutInMilliseconds: number, timeoutMessage?: string): Promise<T>;
+export default methods;

package/lib/time.js

@@ -1,61 +1,61 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapPromiseWithTimeout = exports.durationBetweenTimestamps = void 0;
-const perf_hooks_1 = require("perf_hooks");
-const messages = __importStar(require("@cucumber/messages"));
-const methods = {
-    clearInterval: clearInterval.bind(global),
-    clearTimeout: clearTimeout.bind(global),
-    Date,
-    setInterval: setInterval.bind(global),
-    setTimeout: setTimeout.bind(global),
-    performance: perf_hooks_1.performance,
-};
-if (typeof setImmediate !== 'undefined') {
-    methods.setImmediate = setImmediate.bind(global);
-    methods.clearImmediate = clearImmediate.bind(global);
-}
-function durationBetweenTimestamps(startedTimestamp, finishedTimestamp) {
-    const durationMillis = messages.TimeConversion.timestampToMillisecondsSinceEpoch(finishedTimestamp) -
-        messages.TimeConversion.timestampToMillisecondsSinceEpoch(startedTimestamp);
-    return messages.TimeConversion.millisecondsToDuration(durationMillis);
-}
-exports.durationBetweenTimestamps = durationBetweenTimestamps;
-async function wrapPromiseWithTimeout(promise, timeoutInMilliseconds, timeoutMessage = '') {
-    let timeoutId;
-    if (timeoutMessage === '') {
-        timeoutMessage = `Action did not complete within ${timeoutInMilliseconds} milliseconds`;
-    }
-    const timeoutPromise = new Promise((resolve, reject) => {
-        timeoutId = methods.setTimeout(() => {
-            reject(new Error(timeoutMessage));
-        }, timeoutInMilliseconds);
-    });
-    return await Promise.race([promise, timeoutPromise]).finally(() => methods.clearTimeout(timeoutId));
-}
-exports.wrapPromiseWithTimeout = wrapPromiseWithTimeout;
-exports.default = methods;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapPromiseWithTimeout = exports.durationBetweenTimestamps = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const messages = __importStar(require("@cucumber/messages"));
+const methods = {
+    clearInterval: clearInterval.bind(global),
+    clearTimeout: clearTimeout.bind(global),
+    Date,
+    setInterval: setInterval.bind(global),
+    setTimeout: setTimeout.bind(global),
+    performance: perf_hooks_1.performance,
+};
+if (typeof setImmediate !== 'undefined') {
+    methods.setImmediate = setImmediate.bind(global);
+    methods.clearImmediate = clearImmediate.bind(global);
+}
+function durationBetweenTimestamps(startedTimestamp, finishedTimestamp) {
+    const durationMillis = messages.TimeConversion.timestampToMillisecondsSinceEpoch(finishedTimestamp) -
+        messages.TimeConversion.timestampToMillisecondsSinceEpoch(startedTimestamp);
+    return messages.TimeConversion.millisecondsToDuration(durationMillis);
+}
+exports.durationBetweenTimestamps = durationBetweenTimestamps;
+async function wrapPromiseWithTimeout(promise, timeoutInMilliseconds, timeoutMessage = '') {
+    let timeoutId;
+    if (timeoutMessage === '') {
+        timeoutMessage = `Action did not complete within ${timeoutInMilliseconds} milliseconds`;
+    }
+    const timeoutPromise = new Promise((resolve, reject) => {
+        timeoutId = methods.setTimeout(() => {
+            reject(new Error(timeoutMessage));
+        }, timeoutInMilliseconds);
+    });
+    return await Promise.race([promise, timeoutPromise]).finally(() => methods.clearTimeout(timeoutId));
+}
+exports.wrapPromiseWithTimeout = wrapPromiseWithTimeout;
+exports.default = methods;
 //# sourceMappingURL=time.js.map

package/lib/try_require.d.ts

@@ -1,7 +1,7 @@
-/**
- * Provides a try guarded require call that will throw a more detailed error when
- * the ERR_REQUIRE_ESM error code is encountered.
- *
- * @param {string} path File path to require from.
- */
-export default function tryRequire(path: string): any;
+/**
+ * Provides a try guarded require call that will throw a more detailed error when
+ * the ERR_REQUIRE_ESM error code is encountered.
+ *
+ * @param {string} path File path to require from.
+ */
+export default function tryRequire(path: string): any;