browsecraft 0.1.0

package/dist/index.cjs

@@ -0,0 +1,831 @@
+'use strict';
+
+var chunkKIPQFK3Y_cjs = require('./chunk-KIPQFK3Y.cjs');
+var browsecraftBdd = require('browsecraft-bdd');
+
+// src/expect.ts
+var DEFAULT_ASSERTION_TIMEOUT = 5e3;
+function expect(subject) {
+  if (subject instanceof // We can't import Page directly for instanceof due to circular deps,
+  // so we check for the contextId property which only Page has
+  Object && "contextId" in subject && "session" in subject && !("target" in subject)) {
+    return new PageAssertions(subject);
+  }
+  return new ElementAssertions(subject);
+}
+var PageAssertions = class _PageAssertions {
+  page;
+  _not = false;
+  constructor(page) {
+    this.page = page;
+  }
+  /** Negate the assertion */
+  get not() {
+    const negated = new _PageAssertions(this.page);
+    negated._not = !this._not;
+    return negated;
+  }
+  /**
+   * Assert the page URL contains or matches the expected value.
+   *
+   * ```ts
+   * await expect(page).toHaveURL('/dashboard');
+   * await expect(page).toHaveURL(/dashboard/);
+   * ```
+   */
+  async toHaveURL(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `URL to ${isNot ? "not " : ""}match ${expected}`,
+      async () => {
+        const actual = await this.page.url();
+        const matches = typeof expected === "string" ? actual.includes(expected) : expected.test(actual);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected URL ${isNot ? "not " : ""}to match ${expected}`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the page title matches.
+   *
+   * ```ts
+   * await expect(page).toHaveTitle('Dashboard');
+   * await expect(page).toHaveTitle(/Dashboard/);
+   * ```
+   */
+  async toHaveTitle(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `title to ${isNot ? "not " : ""}match "${expected}"`,
+      async () => {
+        const actual = await this.page.title();
+        const matches = typeof expected === "string" ? actual.includes(expected) : expected.test(actual);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected title ${isNot ? "not " : ""}to match "${expected}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the page content (HTML body text) contains the expected text.
+   *
+   * ```ts
+   * await expect(page).toHaveContent('Welcome back');
+   * await expect(page).toHaveContent(/logged in as \w+/);
+   * ```
+   */
+  async toHaveContent(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastContent = "";
+    await retry(
+      `page to ${isNot ? "not " : ""}contain "${expected}"`,
+      async () => {
+        const content = await this.page.evaluate('document.body?.innerText || ""');
+        lastContent = content.slice(0, 200);
+        const matches = typeof expected === "string" ? content.includes(expected) : expected.test(content);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected page ${isNot ? "not " : ""}to contain "${expected}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+};
+var ElementAssertions = class _ElementAssertions {
+  element;
+  _not = false;
+  constructor(element) {
+    this.element = element;
+  }
+  /** Negate the assertion */
+  get not() {
+    const negated = new _ElementAssertions(this.element);
+    negated._not = !this._not;
+    return negated;
+  }
+  /**
+   * Assert the element is visible on the page.
+   *
+   * ```ts
+   * await expect(page.get('Welcome')).toBeVisible();
+   * await expect(page.get('Error')).not.toBeVisible();
+   * ```
+   */
+  async toBeVisible(options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `element to ${isNot ? "not " : ""}be visible`,
+      async () => {
+        const visible = await this.element.isVisible();
+        return isNot ? !visible : visible;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to be visible`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the element is hidden (not visible).
+   *
+   * ```ts
+   * await expect(page.get('Loading')).toBeHidden();
+   * ```
+   */
+  async toBeHidden(options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `element to ${isNot ? "not " : ""}be hidden`,
+      async () => {
+        const visible = await this.element.isVisible();
+        const hidden = !visible;
+        return isNot ? !hidden : hidden;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to be hidden`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the element's text content matches exactly.
+   *
+   * ```ts
+   * await expect(page.get('h1')).toHaveText('Welcome');
+   * await expect(page.get('.count')).toHaveText(/\d+ items/);
+   * ```
+   */
+  async toHaveText(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastActual = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}have text "${expected}"`,
+      async () => {
+        const actual = (await this.element.textContent()).trim();
+        lastActual = actual;
+        const matches = typeof expected === "string" ? actual === expected : expected.test(actual);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to have text "${expected}", but got "${lastActual}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the element's text content contains the expected substring.
+   *
+   * ```ts
+   * await expect(page.get('.message')).toContainText('success');
+   * ```
+   */
+  async toContainText(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastActual = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}contain text "${expected}"`,
+      async () => {
+        const actual = (await this.element.textContent()).trim();
+        lastActual = actual;
+        const matches = typeof expected === "string" ? actual.includes(expected) : expected.test(actual);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to contain text "${expected}", but got "${lastActual}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the number of matching elements.
+   *
+   * ```ts
+   * await expect(page.get('li')).toHaveCount(5);
+   * ```
+   */
+  async toHaveCount(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastCount = 0;
+    await retry(
+      `element count to ${isNot ? "not " : ""}be ${expected}`,
+      async () => {
+        const count = await this.element.count();
+        lastCount = count;
+        const matches = count === expected;
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected ${isNot ? "not " : ""}${expected} elements, but found ${lastCount}`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert the element has a specific attribute value.
+   *
+   * ```ts
+   * await expect(page.get('input')).toHaveAttribute('type', 'email');
+   * await expect(page.get('a')).toHaveAttribute('href', /login/);
+   * ```
+   */
+  async toHaveAttribute(name, expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastValue = null;
+    await retry(
+      `element to ${isNot ? "not " : ""}have attribute "${name}"${expected !== void 0 ? `="${expected}"` : ""}`,
+      async () => {
+        const value = await this.element.getAttribute(name);
+        lastValue = value;
+        if (expected === void 0) {
+          const has = value !== null;
+          return isNot ? !has : has;
+        }
+        if (value === null) {
+          return isNot;
+        }
+        const matches = typeof expected === "string" ? value === expected : expected.test(value);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          if (expected === void 0) {
+            return `Expected element ${isNot ? "not " : ""}to have attribute "${name}"`;
+          }
+          return `Expected attribute "${name}" ${isNot ? "not " : ""}to be "${expected}", but got "${lastValue}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an input/textarea/select has a specific value.
+   *
+   * ```ts
+   * await expect(page.get('Email')).toHaveValue('user@test.com');
+   * ```
+   */
+  async toHaveValue(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastValue = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}have value "${expected}"`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: 'function(el) { return el.value ?? ""; }',
+          target: { context: this.element.page.contextId },
+          arguments: [ref],
+          awaitPromise: false
+        });
+        const value = result.type === "success" && result.result?.type === "string" ? result.result.value : "";
+        lastValue = value;
+        const matches = typeof expected === "string" ? value === expected : expected.test(value);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected value ${isNot ? "not " : ""}to be "${expected}", but got "${lastValue}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert a checkbox/radio is checked.
+   *
+   * ```ts
+   * await expect(page.get('Terms')).toBeChecked();
+   * await expect(page.get('Newsletter')).not.toBeChecked();
+   * ```
+   */
+  async toBeChecked(options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `element to ${isNot ? "not " : ""}be checked`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: "function(el) { return !!el.checked; }",
+          target: { context: this.element.page.contextId },
+          arguments: [ref],
+          awaitPromise: false
+        });
+        const checked = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+        return isNot ? !checked : checked;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to be checked`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element is enabled (not disabled).
+   *
+   * ```ts
+   * await expect(page.get('Submit')).toBeEnabled();
+   * ```
+   */
+  async toBeEnabled(options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `element to ${isNot ? "not " : ""}be enabled`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: "function(el) { return !el.disabled; }",
+          target: { context: this.element.page.contextId },
+          arguments: [ref],
+          awaitPromise: false
+        });
+        const enabled = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+        return isNot ? !enabled : enabled;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to be enabled`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element is disabled.
+   *
+   * ```ts
+   * await expect(page.get('Submit')).toBeDisabled();
+   * ```
+   */
+  async toBeDisabled(options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    await retry(
+      `element to ${isNot ? "not " : ""}be disabled`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: "function(el) { return !!el.disabled; }",
+          target: { context: this.element.page.contextId },
+          arguments: [ref],
+          awaitPromise: false
+        });
+        const disabled = result.type === "success" && result.result?.type === "boolean" && result.result.value === true;
+        return isNot ? !disabled : disabled;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to be disabled`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element has a specific CSS class.
+   *
+   * ```ts
+   * await expect(page.get('.alert')).toHaveClass('alert-success');
+   * ```
+   */
+  async toHaveClass(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastClasses = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}have class "${expected}"`,
+      async () => {
+        const classes = await this.element.getAttribute("class") ?? "";
+        lastClasses = classes;
+        const matches = typeof expected === "string" ? classes.split(/\s+/).includes(expected) : expected.test(classes);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to have class "${expected}", but got "${lastClasses}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element has a specific CSS property value.
+   *
+   * ```ts
+   * await expect(page.get('.banner')).toHaveCSS('color', 'rgb(255, 0, 0)');
+   * await expect(page.get('.box')).toHaveCSS('display', 'flex');
+   * ```
+   */
+  async toHaveCSS(property, expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastValue = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}have CSS "${property}: ${expected}"`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: `function(el, prop) { return window.getComputedStyle(el).getPropertyValue(prop); }`,
+          target: { context: this.element.page.contextId },
+          arguments: [ref, { type: "string", value: property }],
+          awaitPromise: false
+        });
+        const value = result.type === "success" && result.result?.type === "string" ? result.result.value : "";
+        lastValue = value;
+        const matches = typeof expected === "string" ? value === expected : expected.test(value);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected CSS "${property}" ${isNot ? "not " : ""}to be "${expected}", but got "${lastValue}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element has a specific id attribute.
+   *
+   * ```ts
+   * await expect(page.get('Submit')).toHaveId('submit-btn');
+   * ```
+   */
+  async toHaveId(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastId = null;
+    await retry(
+      `element to ${isNot ? "not " : ""}have id "${expected}"`,
+      async () => {
+        const id = await this.element.getAttribute("id");
+        lastId = id;
+        const matches = id === expected;
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to have id "${expected}", but got "${lastId}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element has a specific placeholder text.
+   *
+   * ```ts
+   * await expect(page.get({ selector: '#email' })).toHavePlaceholder('Enter your email');
+   * ```
+   */
+  async toHavePlaceholder(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastPlaceholder = null;
+    await retry(
+      `element to ${isNot ? "not " : ""}have placeholder "${expected}"`,
+      async () => {
+        const placeholder = await this.element.getAttribute("placeholder");
+        lastPlaceholder = placeholder;
+        if (placeholder === null) return isNot;
+        const matches = typeof expected === "string" ? placeholder === expected : expected.test(placeholder);
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected placeholder ${isNot ? "not " : ""}to be "${expected}", but got "${lastPlaceholder}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+  /**
+   * Assert an element has a specific ARIA role.
+   *
+   * ```ts
+   * await expect(page.get('Submit')).toHaveRole('button');
+   * ```
+   */
+  async toHaveRole(expected, options) {
+    const timeout = options?.timeout ?? DEFAULT_ASSERTION_TIMEOUT;
+    const isNot = this._not;
+    let lastRole = "";
+    await retry(
+      `element to ${isNot ? "not " : ""}have role "${expected}"`,
+      async () => {
+        const located = await this.element.locate(timeout);
+        const ref = located.node.sharedId ? { sharedId: located.node.sharedId, handle: located.node.handle } : null;
+        if (!ref) return false;
+        const result = await this.element.page.session.script.callFunction({
+          functionDeclaration: `function(el) {
+						return el.getAttribute('role') || el.computedRole || '';
+					}`,
+          target: { context: this.element.page.contextId },
+          arguments: [ref],
+          awaitPromise: false
+        });
+        const role = result.type === "success" && result.result?.type === "string" ? result.result.value : "";
+        lastRole = role;
+        const matches = role === expected;
+        return isNot ? !matches : matches;
+      },
+      (pass) => {
+        if (!pass) {
+          return `Expected element ${isNot ? "not " : ""}to have role "${expected}", but got "${lastRole}"`;
+        }
+        return null;
+      },
+      timeout
+    );
+  }
+};
+async function retry(description, check, formatError, timeout) {
+  const interval = 100;
+  const startTime = Date.now();
+  let lastResult = false;
+  while (Date.now() - startTime < timeout) {
+    try {
+      lastResult = await check();
+      if (lastResult) return;
+    } catch {
+      lastResult = false;
+    }
+    await new Promise((r) => setTimeout(r, interval));
+  }
+  try {
+    lastResult = await check();
+    if (lastResult) return;
+  } catch {
+    lastResult = false;
+  }
+  const errorMsg = formatError(lastResult) ?? `Assertion failed: ${description}`;
+  throw new AssertionError(errorMsg);
+}
+var AssertionError = class extends Error {
+  name = "AssertionError";
+  constructor(message) {
+    super(message);
+  }
+};
+
+Object.defineProperty(exports, "Browser", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.Browser; }
+});
+Object.defineProperty(exports, "BrowserContext", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.BrowserContext; }
+});
+Object.defineProperty(exports, "ElementHandle", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.ElementHandle; }
+});
+Object.defineProperty(exports, "Page", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.Page; }
+});
+Object.defineProperty(exports, "afterAll", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.afterAll; }
+});
+Object.defineProperty(exports, "afterEach", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.afterEach; }
+});
+Object.defineProperty(exports, "beforeAll", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.beforeAll; }
+});
+Object.defineProperty(exports, "beforeEach", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.beforeEach; }
+});
+Object.defineProperty(exports, "defineConfig", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.defineConfig; }
+});
+Object.defineProperty(exports, "describe", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.describe; }
+});
+Object.defineProperty(exports, "resetTestState", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.resetTestState; }
+});
+Object.defineProperty(exports, "resolveConfig", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.resolveConfig; }
+});
+Object.defineProperty(exports, "runAfterAllHooks", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.runAfterAllHooks; }
+});
+Object.defineProperty(exports, "runTest", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.runTest; }
+});
+Object.defineProperty(exports, "test", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.test; }
+});
+Object.defineProperty(exports, "testRegistry", {
+  enumerable: true,
+  get: function () { return chunkKIPQFK3Y_cjs.testRegistry; }
+});
+Object.defineProperty(exports, "After", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.After; }
+});
+Object.defineProperty(exports, "AfterFeature", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.AfterFeature; }
+});
+Object.defineProperty(exports, "AfterStep", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.AfterStep; }
+});
+Object.defineProperty(exports, "BddAfterAll", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.AfterAll; }
+});
+Object.defineProperty(exports, "BddBeforeAll", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.BeforeAll; }
+});
+Object.defineProperty(exports, "BddExecutor", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.BddExecutor; }
+});
+Object.defineProperty(exports, "Before", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.Before; }
+});
+Object.defineProperty(exports, "BeforeFeature", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.BeforeFeature; }
+});
+Object.defineProperty(exports, "BeforeStep", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.BeforeStep; }
+});
+Object.defineProperty(exports, "BrowsecraftDataTable", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.BrowsecraftDataTable; }
+});
+Object.defineProperty(exports, "Given", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.Given; }
+});
+Object.defineProperty(exports, "Step", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.Step; }
+});
+Object.defineProperty(exports, "Then", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.Then; }
+});
+Object.defineProperty(exports, "When", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.When; }
+});
+Object.defineProperty(exports, "and", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.and; }
+});
+Object.defineProperty(exports, "autoGenerateSteps", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.autoGenerateSteps; }
+});
+Object.defineProperty(exports, "autoGenerateStepsFromDocument", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.autoGenerateStepsFromDocument; }
+});
+Object.defineProperty(exports, "but", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.but; }
+});
+Object.defineProperty(exports, "clearFeatures", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.clearFeatures; }
+});
+Object.defineProperty(exports, "createExecutor", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.createExecutor; }
+});
+Object.defineProperty(exports, "defineParameterType", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.defineParameterType; }
+});
+Object.defineProperty(exports, "feature", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.feature; }
+});
+Object.defineProperty(exports, "getSupportedLanguages", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.getSupportedLanguages; }
+});
+Object.defineProperty(exports, "given", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.given; }
+});
+Object.defineProperty(exports, "globalRegistry", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.globalRegistry; }
+});
+Object.defineProperty(exports, "matchesTags", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.matchesTags; }
+});
+Object.defineProperty(exports, "parseGherkin", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.parseGherkin; }
+});
+Object.defineProperty(exports, "parseTagExpression", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.parseTagExpression; }
+});
+Object.defineProperty(exports, "pending", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.pending; }
+});
+Object.defineProperty(exports, "runFeatures", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.runFeatures; }
+});
+Object.defineProperty(exports, "scenario", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.scenario; }
+});
+Object.defineProperty(exports, "then", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.then; }
+});
+Object.defineProperty(exports, "when", {
+  enumerable: true,
+  get: function () { return browsecraftBdd.when; }
+});
+exports.AssertionError = AssertionError;
+exports.expect = expect;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map