ex-pw 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1663 @@
+// src/index.ts
+import { expect as playwrightExpect } from "@playwright/test";
+
+// src/matchers/locator/toBeClickable.ts
+async function toBeClickable(locator, options = {}) {
+  const assertionName = "toBeClickable";
+  const timeout = options.timeout ?? this.timeout;
+  let pass = false;
+  let errorMessage = "";
+  try {
+    await locator.click({ trial: true, timeout });
+    pass = true;
+  } catch (error) {
+    pass = false;
+    errorMessage = error instanceof Error ? error.message : String(error);
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element to NOT be clickable
+Received: element is clickable`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' to be clickable
+Received: element is not clickable
+` + (errorMessage ? `
+Error: ${errorMessage}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/locator/toBeCheckable.ts
+async function toBeCheckable(locator, options = {}) {
+  const assertionName = "toBeCheckable";
+  const timeout = options.timeout ?? this.timeout;
+  let pass = false;
+  let errorMessage = "";
+  try {
+    await locator.check({ trial: true, timeout });
+    pass = true;
+  } catch (error) {
+    pass = false;
+    errorMessage = error instanceof Error ? error.message : String(error);
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' to NOT be checkable
+Received: element is checkable`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' to be checkable
+Received: element is not checkable
+` + (errorMessage ? `
+Error: ${errorMessage}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/locator/toBeRequired.ts
+import { expect } from "@playwright/test";
+async function toBeRequired(locator, options = {}) {
+  const assertionName = "toBeRequired";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let errorMessage = "";
+  try {
+    await expect.poll(
+      async () => {
+        const hasRequiredAttr = await locator.getAttribute("required");
+        if (hasRequiredAttr !== null) return true;
+        const ariaRequired = await locator.getAttribute("aria-required");
+        if (ariaRequired === "true") return true;
+        const isRequired = await locator.evaluate((el) => {
+          if ("required" in el) {
+            return el.required;
+          }
+          return false;
+        });
+        return isRequired;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch (error) {
+    pass = false;
+    errorMessage = error instanceof Error ? error.message : String(error);
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' to NOT be required
+Received: element is required`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' to be required
+Received: element is not required
+` + (errorMessage ? `
+Details: ${errorMessage}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/locator/toBeInvalid.ts
+import { expect as expect2 } from "@playwright/test";
+var INVALID_CLASSES = [
+  "ng-invalid",
+  // Angular
+  "is-invalid",
+  // Bootstrap
+  "error",
+  // Common pattern
+  "has-error",
+  // Another common pattern
+  "invalid"
+  // Generic
+];
+async function toBeInvalid(locator, options = {}) {
+  const assertionName = "toBeInvalid";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let errorMessage = "";
+  try {
+    await expect2.poll(
+      async () => {
+        const ariaInvalid = await locator.getAttribute("aria-invalid");
+        if (ariaInvalid === "true") return true;
+        const isNativeInvalid = await locator.evaluate((el) => {
+          if ("validity" in el) {
+            return !el.validity.valid;
+          }
+          return false;
+        });
+        if (isNativeInvalid) return true;
+        const classAttr = await locator.getAttribute("class");
+        if (classAttr) {
+          const classes = classAttr.split(/\s+/);
+          for (const invalidClass of INVALID_CLASSES) {
+            if (classes.includes(invalidClass)) return true;
+          }
+        }
+        return false;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch (error) {
+    pass = false;
+    errorMessage = error instanceof Error ? error.message : String(error);
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' to NOT be invalid
+Received: element is invalid`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' to be invalid
+Received: element is valid
+` + (errorMessage ? `
+Details: ${errorMessage}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/locator/toBeValid.ts
+import { expect as expect3 } from "@playwright/test";
+var INVALID_CLASSES2 = [
+  "ng-invalid",
+  // Angular
+  "is-invalid",
+  // Bootstrap
+  "error",
+  // Common pattern
+  "has-error",
+  // Another common pattern
+  "invalid"
+  // Generic
+];
+async function toBeValid(locator, options = {}) {
+  const assertionName = "toBeValid";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let errorMessage = "";
+  try {
+    await expect3.poll(
+      async () => {
+        const ariaInvalid = await locator.getAttribute("aria-invalid");
+        if (ariaInvalid === "true") return false;
+        const hasValidity = await locator.evaluate((el) => "validity" in el);
+        if (hasValidity) {
+          const isNativeValid = await locator.evaluate((el) => {
+            return el.validity.valid;
+          });
+          if (!isNativeValid) return false;
+        }
+        const classAttr = await locator.getAttribute("class");
+        if (classAttr) {
+          const classes = classAttr.split(/\s+/);
+          for (const invalidClass of INVALID_CLASSES2) {
+            if (classes.includes(invalidClass)) return false;
+          }
+        }
+        return true;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch (error) {
+    pass = false;
+    errorMessage = error instanceof Error ? error.message : String(error);
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' to NOT be valid
+Received: element is valid`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' to be valid
+Received: element is invalid
+` + (errorMessage ? `
+Details: ${errorMessage}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/locator/toHaveCount.ts
+import { expect as expect4 } from "@playwright/test";
+async function toHaveCountGreaterThan(locator, count, options = {}) {
+  const assertionName = "toHaveCountGreaterThan";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let actualCount = 0;
+  try {
+    await expect4.poll(
+      async () => {
+        actualCount = await locator.count();
+        return actualCount;
+      },
+      { timeout, intervals }
+    ).toBeGreaterThan(count);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' count to NOT be greater than ${count}
+Received: ${actualCount}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' count to be greater than ${count}
+Received: ${actualCount}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: `> ${count}`,
+    actual: actualCount
+  };
+}
+async function toHaveCountGreaterThanOrEqual(locator, count, options = {}) {
+  const assertionName = "toHaveCountGreaterThanOrEqual";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let actualCount = 0;
+  try {
+    await expect4.poll(
+      async () => {
+        actualCount = await locator.count();
+        return actualCount;
+      },
+      { timeout, intervals }
+    ).toBeGreaterThanOrEqual(count);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' count to NOT be greater than or equal to ${count}
+Received: ${actualCount}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' count to be greater than or equal to ${count}
+Received: ${actualCount}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: `>= ${count}`,
+    actual: actualCount
+  };
+}
+async function toHaveCountLessThan(locator, count, options = {}) {
+  const assertionName = "toHaveCountLessThan";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let actualCount = 0;
+  try {
+    await expect4.poll(
+      async () => {
+        actualCount = await locator.count();
+        return actualCount;
+      },
+      { timeout, intervals }
+    ).toBeLessThan(count);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' count to NOT be less than ${count}
+Received: ${actualCount}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' count to be less than ${count}
+Received: ${actualCount}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: `< ${count}`,
+    actual: actualCount
+  };
+}
+async function toHaveCountLessThanOrEqual(locator, count, options = {}) {
+  const assertionName = "toHaveCountLessThanOrEqual";
+  const timeout = options.timeout ?? this.timeout;
+  const intervals = options.intervals;
+  let pass = false;
+  let actualCount = 0;
+  try {
+    await expect4.poll(
+      async () => {
+        actualCount = await locator.count();
+        return actualCount;
+      },
+      { timeout, intervals }
+    ).toBeLessThanOrEqual(count);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: element '${locator}' count to NOT be less than or equal to ${count}
+Received: ${actualCount}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: element '${locator}' count to be less than or equal to ${count}
+Received: ${actualCount}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: `<= ${count}`,
+    actual: actualCount
+  };
+}
+
+// src/matchers/locator/toHaveWidth.ts
+import { expect as expect5 } from "@playwright/test";
+async function toHaveWidth(locator, expected, options) {
+  const timeout = options?.timeout ?? this.timeout;
+  const intervals = options?.intervals;
+  try {
+    await expect5.poll(async () => {
+      const box = await locator.boundingBox();
+      return box ? box.width : null;
+    }, { timeout, intervals }).toBe(expected);
+    return {
+      message: () => `expected element '${locator}' to have width ${expected}`,
+      pass: true
+    };
+  } catch (e) {
+    return {
+      message: () => `expected element '${locator}' to have width ${expected}`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/locator/toHaveHeight.ts
+import { expect as expect6 } from "@playwright/test";
+async function toHaveHeight(locator, expected, options) {
+  const timeout = options?.timeout ?? this.timeout;
+  const intervals = options?.intervals;
+  try {
+    await expect6.poll(async () => {
+      const box = await locator.boundingBox();
+      return box ? box.height : null;
+    }, { timeout, intervals }).toBe(expected);
+    return {
+      message: () => `expected element '${locator}' to have height ${expected}`,
+      pass: true
+    };
+  } catch (e) {
+    return {
+      message: () => `expected element '${locator}' to have height ${expected}`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/locator/toHaveSize.ts
+import { expect as expect7 } from "@playwright/test";
+async function toHaveSize(locator, width, height, options) {
+  const timeout = options?.timeout ?? this.timeout;
+  const intervals = options?.intervals;
+  try {
+    await expect7.poll(async () => {
+      const box = await locator.boundingBox();
+      return box ? { width: box.width, height: box.height } : null;
+    }, { timeout, intervals }).toEqual({ width, height });
+    return {
+      message: () => `expected element '${locator}' to have size { width: ${width}, height: ${height} }`,
+      pass: true
+    };
+  } catch (e) {
+    return {
+      message: () => `expected element '${locator}' to have size { width: ${width}, height: ${height} }`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/locator/toHaveLoadedImage.ts
+import { expect as expect8 } from "@playwright/test";
+async function toHaveLoadedImage(locator, options) {
+  const timeout = options?.timeout ?? this.timeout;
+  const intervals = options?.intervals;
+  try {
+    await expect8.poll(async () => {
+      return await locator.evaluate((el) => {
+        if (!(el instanceof HTMLImageElement)) {
+          throw new Error("Element is not an HTMLImageElement");
+        }
+        return el.complete && el.naturalWidth > 0;
+      });
+    }, { timeout, intervals }).toBe(true);
+    return {
+      message: () => `expected element '${locator}' to have loaded image`,
+      pass: true
+    };
+  } catch (e) {
+    if (e.message && e.message.includes("Element is not an HTMLImageElement")) {
+      return {
+        message: () => `expected element '${locator}' to have loaded image, but it is not an HTMLImageElement`,
+        pass: false
+      };
+    }
+    return {
+      message: () => `expected element '${locator}' to have loaded image`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/locator/index.ts
+var locatorMatchers = {
+  toBeClickable,
+  toBeCheckable,
+  toBeRequired,
+  toBeInvalid,
+  toBeValid,
+  toHaveCountGreaterThan,
+  toHaveCountGreaterThanOrEqual,
+  toHaveCountLessThan,
+  toHaveCountLessThanOrEqual,
+  toHaveWidth,
+  toHaveHeight,
+  toHaveSize,
+  toHaveLoadedImage
+};
+
+// src/matchers/page/toHaveNoErrors.ts
+function toHaveNoErrors(testObject, options = {}) {
+  const assertionName = "toHaveNoErrors";
+  const { ignore } = options;
+  const testInfo = testObject.info();
+  let errors = testInfo.errors || [];
+  if (ignore) {
+    errors = errors.filter((error) => {
+      const message2 = error.message || "";
+      return !ignore.test(message2);
+    });
+  }
+  const pass = errors.length === 0;
+  const errorMessages = errors.map((e, i) => `  ${i + 1}. ${e.message || "Unknown error"}`).join("\n");
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: to have errors
+Received: no errors`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: no errors
+Received: ${errors.length} error(s)
+
+` + errorMessages;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: 0,
+    actual: errors.length
+  };
+}
+
+// src/matchers/page/toHaveCookie.ts
+import { expect as expect9 } from "@playwright/test";
+async function toHaveCookie(page, name, options = {}) {
+  const assertionName = "toHaveCookie";
+  const { value, domain, timeout = this.timeout, intervals } = options;
+  let pass = false;
+  let actualValue;
+  let foundCookie = false;
+  try {
+    await expect9.poll(
+      async () => {
+        const cookies = await page.context().cookies();
+        const cookie = cookies.find((c) => {
+          if (c.name !== name) return false;
+          if (domain && c.domain !== domain) return false;
+          return true;
+        });
+        if (!cookie) {
+          foundCookie = false;
+          actualValue = void 0;
+          return false;
+        }
+        foundCookie = true;
+        actualValue = cookie.value;
+        if (value !== void 0) {
+          if (typeof value === "string") {
+            return cookie.value === value;
+          } else {
+            return value.test(cookie.value);
+          }
+        }
+        return true;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const expectedDesc = value ? `cookie "${name}" with value ${value instanceof RegExp ? value : `"${value}"`}` : `cookie "${name}"`;
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have ${expectedDesc}
+Received: cookie found with value "${actualValue}"`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: ${expectedDesc}
+` + (foundCookie ? `Received: cookie found with value "${actualValue}"` : `Received: cookie not found`);
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: value ?? name,
+    actual: actualValue
+  };
+}
+
+// src/matchers/page/toHaveLocalStorage.ts
+import { expect as expect10 } from "@playwright/test";
+
+// src/utils/matcherUtils.ts
+function formatValue(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") return `"${value}"`;
+  if (typeof value === "object") {
+    try {
+      return JSON.stringify(value, null, 2);
+    } catch {
+      return String(value);
+    }
+  }
+  return String(value);
+}
+
+// src/matchers/page/toHaveLocalStorage.ts
+async function toHaveLocalStorage(page, key, options = {}) {
+  const assertionName = "toHaveLocalStorage";
+  const { value, timeout = this.timeout, intervals } = options;
+  let pass = false;
+  let actualValue;
+  let foundKey = false;
+  try {
+    await expect10.poll(
+      async () => {
+        const storageState = await page.context().storageState();
+        const pageUrl = page.url();
+        let origin;
+        try {
+          origin = new URL(pageUrl).origin;
+        } catch {
+          origin = pageUrl;
+        }
+        const originStorage = storageState.origins.find(
+          (o) => o.origin === origin
+        );
+        if (!originStorage) {
+          foundKey = false;
+          actualValue = void 0;
+          return false;
+        }
+        const item = originStorage.localStorage.find((ls) => ls.name === key);
+        if (!item) {
+          foundKey = false;
+          actualValue = void 0;
+          return false;
+        }
+        foundKey = true;
+        try {
+          actualValue = JSON.parse(item.value);
+        } catch {
+          actualValue = item.value;
+        }
+        if (value !== void 0) {
+          try {
+            expect10(actualValue).toEqual(value);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const expectedDesc = value !== void 0 ? `localStorage key "${key}" with value ${formatValue(value)}` : `localStorage key "${key}"`;
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have ${expectedDesc}
+Received: key found with value ${formatValue(actualValue)}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: ${expectedDesc}
+` + (foundKey ? `Received: key found with value ${formatValue(actualValue)}` : `Received: key not found`);
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: value ?? key,
+    actual: actualValue
+  };
+}
+
+// src/matchers/page/toHaveSessionStorage.ts
+import { expect as expect11 } from "@playwright/test";
+async function toHaveSessionStorage(page, key, options = {}) {
+  const assertionName = "toHaveSessionStorage";
+  const { value, timeout = this.timeout, intervals } = options;
+  let pass = false;
+  let actualValue;
+  let foundKey = false;
+  try {
+    await expect11.poll(
+      async () => {
+        const rawValue = await page.evaluate((k) => {
+          return window.sessionStorage.getItem(k);
+        }, key);
+        if (rawValue === null) {
+          foundKey = false;
+          actualValue = void 0;
+          return false;
+        }
+        foundKey = true;
+        try {
+          actualValue = JSON.parse(rawValue);
+        } catch {
+          actualValue = rawValue;
+        }
+        if (value !== void 0) {
+          try {
+            expect11(actualValue).toEqual(value);
+            return true;
+          } catch {
+            return false;
+          }
+        }
+        return true;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const expectedDesc = value !== void 0 ? `sessionStorage key "${key}" with value ${formatValue(value)}` : `sessionStorage key "${key}"`;
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have ${expectedDesc}
+Received: key found with value ${formatValue(actualValue)}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: ${expectedDesc}
+` + (foundKey ? `Received: key found with value ${formatValue(actualValue)}` : `Received: key not found`);
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: value ?? key,
+    actual: actualValue
+  };
+}
+
+// src/matchers/page/toHaveClipboardText.ts
+import { expect as expect12 } from "@playwright/test";
+async function toHaveClipboardText(page, expected, options) {
+  const timeout = options?.timeout ?? this.timeout;
+  const intervals = options?.intervals;
+  try {
+    const assertion = expect12.poll(async () => {
+      return await page.evaluate(() => navigator.clipboard.readText());
+    }, { timeout, intervals });
+    if (expected instanceof RegExp) {
+      await assertion.toMatch(expected);
+    } else {
+      await assertion.toBe(expected);
+    }
+    return {
+      message: () => `expected clipboard to have text ${expected}`,
+      pass: true
+    };
+  } catch (e) {
+    return {
+      message: () => `expected clipboard to have text ${expected} but got error or different text: ${e.message}`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/page/toHaveRequest.ts
+import { expect as expect13 } from "@playwright/test";
+async function toHaveRequest(page, options = {}) {
+  const assertionName = "toHaveRequest";
+  const { method, status, url, timeout = this.timeout, intervals } = options;
+  let matchedRequest;
+  let requests = [];
+  let pass = false;
+  try {
+    await expect13.poll(
+      async () => {
+        requests = await page.requests();
+        for (const request of requests) {
+          let matches = true;
+          if (url !== void 0) {
+            const requestUrl = request.url();
+            if (typeof url === "string") {
+              if (!requestUrl.includes(url)) matches = false;
+            } else {
+              if (!url.test(requestUrl)) matches = false;
+            }
+          }
+          if (matches && method !== void 0) {
+            if (request.method().toUpperCase() !== method.toUpperCase()) matches = false;
+          }
+          if (matches && status !== void 0) {
+            const response = await request.response();
+            if (!response || response.status() !== status) matches = false;
+          }
+          if (matches) {
+            matchedRequest = request;
+            return true;
+          }
+        }
+        return false;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const criteriaDesc = [
+    url ? `URL matching ${url instanceof RegExp ? url : `"${url}"`}` : null,
+    method ? `method "${method}"` : null,
+    status ? `status ${status}` : null
+  ].filter(Boolean).join(", ");
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have request with ${criteriaDesc || "any criteria"}
+Received: found matching request: ${matchedRequest?.method()} ${matchedRequest?.url()}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: request with ${criteriaDesc || "any criteria"}
+Received: no matching request found among ${requests.length} captured requests
+
+Note: page.requests() only returns up to 100 most recent requests`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/page/toHaveConsoleMessage.ts
+import { expect as expect14 } from "@playwright/test";
+async function toHaveConsoleMessage(page, options = {}) {
+  const assertionName = "toHaveConsoleMessage";
+  const { type, text, timeout = this.timeout, intervals } = options;
+  let matchedMessage;
+  let messages = [];
+  let pass = false;
+  try {
+    await expect14.poll(
+      async () => {
+        messages = await page.consoleMessages();
+        matchedMessage = messages.find((msg) => {
+          if (type !== void 0) {
+            if (msg.type() !== type) return false;
+          }
+          if (text !== void 0) {
+            const msgText = msg.text();
+            if (typeof text === "string") {
+              if (!msgText.includes(text)) return false;
+            } else {
+              if (!text.test(msgText)) return false;
+            }
+          }
+          return true;
+        });
+        return matchedMessage !== void 0;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const criteriaDesc = [
+    type ? `type "${type}"` : null,
+    text ? `text matching ${text instanceof RegExp ? text : `"${text}"`}` : null
+  ].filter(Boolean).join(", ");
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have console message with ${criteriaDesc || "any criteria"}
+Received: found matching message: "${matchedMessage?.text()}"`;
+    }
+    const capturedMessages = messages.slice(0, 5).map((m) => `  [${m.type()}] ${m.text().substring(0, 50)}${m.text().length > 50 ? "..." : ""}`).join("\n");
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: console message with ${criteriaDesc || "any criteria"}
+Received: no matching message found among ${messages.length} captured messages
+` + (capturedMessages ? `
+Recent messages:
+${capturedMessages}` : "") + `
+
+Note: page.consoleMessages() only returns up to 200 most recent messages`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/page/toHavePageError.ts
+import { expect as expect15 } from "@playwright/test";
+async function toHavePageError(page, options = {}) {
+  const assertionName = "toHavePageError";
+  const { message: errorMessage, name: errorName, timeout = this.timeout, intervals } = options;
+  let matchedError;
+  let errors = [];
+  let pass = false;
+  try {
+    await expect15.poll(
+      async () => {
+        errors = await page.pageErrors();
+        matchedError = errors.find((error) => {
+          if (errorMessage !== void 0) {
+            const msg = error.message;
+            if (typeof errorMessage === "string") {
+              if (!msg.includes(errorMessage)) return false;
+            } else {
+              if (!errorMessage.test(msg)) return false;
+            }
+          }
+          if (errorName !== void 0) {
+            if (error.name !== errorName) return false;
+          }
+          return true;
+        });
+        return matchedError !== void 0;
+      },
+      { timeout, intervals }
+    ).toBe(true);
+    pass = true;
+  } catch {
+    pass = false;
+  }
+  const criteriaDesc = [
+    errorMessage ? `message matching ${errorMessage instanceof RegExp ? errorMessage : `"${errorMessage}"`}` : null,
+    errorName ? `name "${errorName}"` : null
+  ].filter(Boolean).join(", ");
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have page error with ${criteriaDesc || "any criteria"}
+Received: found matching error: ${matchedError?.name}: ${matchedError?.message}`;
+    }
+    const capturedErrors = errors.slice(0, 5).map((e) => `  ${e.name}: ${e.message.substring(0, 60)}${e.message.length > 60 ? "..." : ""}`).join("\n");
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: page error with ${criteriaDesc || "any criteria"}
+Received: no matching error found among ${errors.length} captured errors
+` + (capturedErrors ? `
+Recent errors:
+${capturedErrors}` : "") + `
+
+Note: page.pageErrors() only returns up to 200 most recent errors`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName
+  };
+}
+
+// src/matchers/page/index.ts
+var pageMatchers = {
+  toHaveNoErrors,
+  toHaveCookie,
+  toHaveLocalStorage,
+  toHaveSessionStorage,
+  toHaveClipboardText,
+  toHaveRequest,
+  toHaveConsoleMessage,
+  toHavePageError
+};
+
+// src/matchers/api/toMatchJSON.ts
+import { expect as expect16 } from "@playwright/test";
+async function toMatchJSON(response, expected) {
+  const assertionName = "toMatchJSON";
+  let pass = false;
+  let actualBody;
+  let parseError = null;
+  try {
+    actualBody = await response.json();
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error);
+  }
+  if (parseError) {
+    pass = false;
+  } else {
+    try {
+      expect16(actualBody).toEqual(expected);
+      pass = true;
+    } catch {
+      pass = false;
+    }
+  }
+  const message = () => {
+    if (parseError) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Failed to parse response body as JSON:
+${parseError}`;
+    }
+    const diff = this.utils.diff(expected, actualBody);
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + "\n\n" + (this.isNot ? `Expected: not ${formatValue(expected)}
+` : `Expected: ${formatValue(expected)}
+`) + `Received: ${formatValue(actualBody)}` + (diff ? `
+
+Difference:
+${diff}` : "");
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected,
+    actual: actualBody
+  };
+}
+
+// src/matchers/api/toMatchSchema.ts
+async function toMatchSchema(response, schema) {
+  const assertionName = "toMatchSchema";
+  let pass = false;
+  let actualBody;
+  let parseError = null;
+  let validationErrors = [];
+  try {
+    actualBody = await response.json();
+  } catch (error) {
+    parseError = error instanceof Error ? error.message : String(error);
+  }
+  if (parseError) {
+    pass = false;
+  } else {
+    const result = schema.safeParse(actualBody);
+    pass = result.success;
+    if (!result.success) {
+      validationErrors = formatZodErrors(result.error);
+    }
+  }
+  const message = () => {
+    if (parseError) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Failed to parse response body as JSON:
+${parseError}`;
+    }
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: response to NOT match schema
+Received: response matches schema
+
+Body: ${formatValue(actualBody)}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: response to match schema
+Received: validation failed
+
+Validation errors:
+${validationErrors.map((e) => `  \u2022 ${e}`).join("\n")}
+
+Body: ${formatValue(actualBody)}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: "valid schema",
+    actual: actualBody
+  };
+}
+function formatZodErrors(error) {
+  return error.errors.map((e) => {
+    const path = e.path.length > 0 ? `${e.path.join(".")}: ` : "";
+    return `${path}${e.message}`;
+  });
+}
+
+// src/matchers/api/toHaveStatus.ts
+async function toHaveStatus(response, expected) {
+  const assertionName = "toHaveStatus";
+  const actualStatus = response.status();
+  let pass = false;
+  if (typeof expected === "number") {
+    pass = actualStatus === expected;
+  } else {
+    pass = actualStatus >= expected.min && actualStatus <= expected.max;
+  }
+  const expectedDesc = typeof expected === "number" ? `${expected}` : `${expected.min}-${expected.max}`;
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: status NOT to be ${expectedDesc}
+Received: ${actualStatus}`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: status ${expectedDesc}
+Received: ${actualStatus}`;
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: expectedDesc,
+    actual: actualStatus
+  };
+}
+
+// src/matchers/api/toHaveHeader.ts
+async function toHaveHeader(response, name, options = {}) {
+  const assertionName = "toHaveHeader";
+  const { value } = options;
+  const headers = response.headers();
+  const lowerName = name.toLowerCase();
+  const actualValue = Object.entries(headers).find(
+    ([key]) => key.toLowerCase() === lowerName
+  )?.[1];
+  let pass = actualValue !== void 0;
+  if (pass && value !== void 0) {
+    if (typeof value === "string") {
+      pass = actualValue === value;
+    } else {
+      pass = value.test(actualValue);
+    }
+  }
+  const expectedDesc = value ? `header "${name}" with value ${value instanceof RegExp ? value : `"${value}"`}` : `header "${name}"`;
+  const message = () => {
+    if (this.isNot) {
+      return this.utils.matcherHint(assertionName, void 0, void 0, {
+        isNot: this.isNot
+      }) + `
+
+Expected: NOT to have ${expectedDesc}
+Received: header found with value "${actualValue}"`;
+    }
+    return this.utils.matcherHint(assertionName, void 0, void 0, {
+      isNot: this.isNot
+    }) + `
+
+Expected: ${expectedDesc}
+` + (actualValue !== void 0 ? `Received: header found with value "${actualValue}"` : `Received: header not found`);
+  };
+  return {
+    pass,
+    message,
+    name: assertionName,
+    expected: value ?? name,
+    actual: actualValue
+  };
+}
+
+// src/matchers/api/toRespondWithin.ts
+async function toRespondWithin(response, timeout) {
+  if (!(response instanceof Promise) && typeof response !== "function") {
+    return {
+      message: () => `toRespondWithin: expected received value to be a Promise or async function, but got ${typeof response}. Did you await the request? Remove 'wait' to allow measurement.`,
+      pass: false
+    };
+  }
+  const start = Date.now();
+  try {
+    if (typeof response === "function") {
+      await response();
+    } else {
+      await response;
+    }
+  } catch (e) {
+  }
+  const duration = Date.now() - start;
+  const pass = duration <= timeout;
+  if (pass) {
+    return {
+      message: () => `expected request not to answer within ${timeout}ms, took ${duration}ms`,
+      pass: true
+    };
+  } else {
+    return {
+      message: () => `expected request to answer within ${timeout}ms, but took ${duration}ms`,
+      pass: false
+    };
+  }
+}
+
+// src/matchers/api/index.ts
+var apiMatchers = {
+  toMatchJSON,
+  toMatchSchema,
+  toHaveStatus,
+  toHaveHeader,
+  toRespondWithin
+};
+
+// src/matchers/asymmetric/toBeWithinRange.ts
+function toBeWithinRange(received, min, max) {
+  const pass = typeof received === "number" && received >= min && received <= max;
+  return {
+    message: () => pass ? `expected ${received} not to be within range ${min} - ${max}` : `expected ${received} to be within range ${min} - ${max}`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeUUID.ts
+var UUID_PATTERNS = {
+  v1: /^[0-9a-f]{8}-[0-9a-f]{4}-1[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  v4: /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  v5: /^[0-9a-f]{8}-[0-9a-f]{4}-5[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i,
+  any: /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+};
+function toBeUUID(received, version) {
+  const pattern = version ? UUID_PATTERNS[version] : UUID_PATTERNS.any;
+  const versionLabel = version || "any";
+  const pass = typeof received === "string" && pattern.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be a valid UUID (${versionLabel})` : `expected ${received} to be a valid UUID (${versionLabel})`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeISODate.ts
+var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,3})?(Z|[+-]\d{2}:?\d{2})?$/;
+function toBeISODate(received) {
+  let pass = false;
+  if (typeof received === "string" && ISO_DATE_PATTERN.test(received)) {
+    const date = new Date(received);
+    if (!isNaN(date.getTime())) {
+      pass = true;
+    }
+  }
+  return {
+    message: () => pass ? `expected ${received} not to be a valid ISO date` : `expected ${received} to be a valid ISO date`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeDateString.ts
+var FORMAT_PATTERNS = {
+  "YYYY-MM-DD": /^\d{4}-\d{2}-\d{2}$/,
+  "MM/DD/YYYY": /^\d{2}\/\d{2}\/\d{4}$/,
+  "DD/MM/YYYY": /^\d{2}\/\d{2}\/\d{4}$/,
+  "YYYY/MM/DD": /^\d{4}\/\d{2}\/\d{2}$/,
+  "MM-DD-YYYY": /^\d{2}-\d{2}-\d{4}$/,
+  "DD-MM-YYYY": /^\d{2}-\d{2}-\d{4}$/,
+  "YYYYMMDD": /^\d{8}$/
+};
+function toBeDateString(received, format) {
+  const pattern = FORMAT_PATTERNS[format];
+  if (!pattern) {
+    throw new Error(
+      `Unsupported date format: ${format}. Supported formats: ${Object.keys(FORMAT_PATTERNS).join(", ")}`
+    );
+  }
+  const pass = typeof received === "string" && pattern.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be a date string (${format})` : `expected ${received} to be a date string (${format})`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeEmail.ts
+var EMAIL_PATTERN = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
+function toBeEmail(received) {
+  const pass = typeof received === "string" && EMAIL_PATTERN.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be a valid email` : `expected ${received} to be a valid email`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeURL.ts
+function toBeURL(received, options = {}) {
+  const { protocol } = options;
+  let pass = false;
+  if (typeof received === "string") {
+    try {
+      const url = new URL(received);
+      pass = true;
+      if (protocol) {
+        const urlProtocol = url.protocol.replace(":", "");
+        const allowedProtocols = Array.isArray(protocol) ? protocol : [protocol];
+        if (!allowedProtocols.includes(urlProtocol)) {
+          pass = false;
+        }
+      }
+    } catch {
+      pass = false;
+    }
+  }
+  const protocolMsg = protocol ? ` (protocol: ${Array.isArray(protocol) ? protocol.join("|") : protocol})` : "";
+  return {
+    message: () => pass ? `expected ${received} not to be a valid URL${protocolMsg}` : `expected ${received} to be a valid URL${protocolMsg}`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeJSON.ts
+function toBeJSON(received) {
+  let pass = false;
+  if (typeof received === "string") {
+    try {
+      JSON.parse(received);
+      pass = true;
+    } catch {
+      pass = false;
+    }
+  }
+  return {
+    message: () => pass ? `expected ${received} not to be valid JSON` : `expected ${received} to be valid JSON`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toStartWith.ts
+function toStartWith(received, expected) {
+  const pass = typeof received === "string" && received.startsWith(expected);
+  return {
+    message: () => pass ? `expected ${received} not to start with ${expected}` : `expected ${received} to start with ${expected}`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toEndWith.ts
+function toEndWith(received, expected) {
+  const pass = typeof received === "string" && received.endsWith(expected);
+  return {
+    message: () => pass ? `expected ${received} not to end with ${expected}` : `expected ${received} to end with ${expected}`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeUpperCase.ts
+function toBeUpperCase(received) {
+  const pass = typeof received === "string" && received === received.toUpperCase() && received !== received.toLowerCase();
+  return {
+    message: () => pass ? `expected ${received} not to be upper case` : `expected ${received} to be upper case`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeLowerCase.ts
+function toBeLowerCase(received) {
+  const pass = typeof received === "string" && received === received.toLowerCase() && received !== received.toUpperCase();
+  return {
+    message: () => pass ? `expected ${received} not to be lower case` : `expected ${received} to be lower case`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeKebabCase.ts
+function toBeKebabCase(received) {
+  const pass = typeof received === "string" && /^[a-z0-9]+(-[a-z0-9]+)*$/.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be kebab-case` : `expected ${received} to be kebab-case`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeCamelCase.ts
+function toBeCamelCase(received) {
+  const pass = typeof received === "string" && /^[a-z][a-zA-Z0-9]*$/.test(received) && !/[_\-]/.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be camelCase` : `expected ${received} to be camelCase`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBeSnakeCase.ts
+function toBeSnakeCase(received) {
+  const pass = typeof received === "string" && /^[a-z0-9]+(_[a-z0-9]+)*$/.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be snake_case` : `expected ${received} to be snake_case`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/toBePascalCase.ts
+function toBePascalCase(received) {
+  const pass = typeof received === "string" && /^[A-Z][a-zA-Z0-9]*$/.test(received) && !/[_\-]/.test(received);
+  return {
+    message: () => pass ? `expected ${received} not to be PascalCase` : `expected ${received} to be PascalCase`,
+    pass
+  };
+}
+
+// src/matchers/asymmetric/index.ts
+var asymmetricMatchers = {
+  toBeWithinRange,
+  toBeUUID,
+  toBeISODate,
+  toBeDateString,
+  toBeEmail,
+  toBeURL,
+  toBeJSON,
+  toStartWith,
+  toEndWith,
+  toBeUpperCase,
+  toBeLowerCase,
+  toBeKebabCase,
+  toBeCamelCase,
+  toBeSnakeCase,
+  toBePascalCase
+};
+
+// src/matchers/general/toBeSorted.ts
+import { expect as expect17 } from "@playwright/test";
+function isLocator(value) {
+  return value !== null && typeof value === "object" && "allInnerTexts" in value;
+}
+function checkSorted(values, descending, key) {
+  return values.every((item, index) => {
+    if (index === 0) return true;
+    const prev = values[index - 1];
+    let a = key ? typeof key === "function" ? key(prev) : prev[key] : prev;
+    let b = key ? typeof key === "function" ? key(item) : item[key] : item;
+    if (a instanceof Date) a = a.getTime();
+    if (b instanceof Date) b = b.getTime();
+    if (descending) {
+      return a >= b;
+    }
+    return a <= b;
+  });
+}
+async function toBeSorted(received, options) {
+  const {
+    descending = false,
+    key,
+    useTextContent = false,
+    compareAsNumbers = false,
+    timeout = this.timeout,
+    intervals
+  } = options || {};
+  if (Array.isArray(received)) {
+    const pass = checkSorted(received, descending, key);
+    return {
+      message: () => pass ? `expected array not to be sorted ${descending ? "descending" : "ascending"}` : `expected array to be sorted ${descending ? "descending" : "ascending"}, but received: [${received.join(", ")}]`,
+      pass
+    };
+  }
+  if (isLocator(received)) {
+    const locator = received;
+    let values = [];
+    let pass = false;
+    try {
+      await expect17.poll(
+        async () => {
+          values = useTextContent ? await locator.allTextContents() : await locator.allInnerTexts();
+          const compareValues = compareAsNumbers ? values.map((v) => parseFloat(v.replace(/[^0-9.-]/g, ""))) : values;
+          return checkSorted(compareValues, descending);
+        },
+        { timeout, intervals }
+      ).toBe(true);
+      pass = true;
+    } catch {
+      pass = false;
+    }
+    return {
+      message: () => pass ? `expected locator elements not to be sorted ${descending ? "descending" : "ascending"}` : `expected locator elements to be sorted ${descending ? "descending" : "ascending"}, but received: [${values.join(", ")}]`,
+      pass
+    };
+  }
+  return {
+    message: () => `expected an array or Locator, but received: ${typeof received}`,
+    pass: false
+  };
+}
+
+// src/matchers/general/index.ts
+var generalMatchers = {
+  toBeSorted
+};
+
+// src/matchers/index.ts
+var allMatchers = {
+  ...locatorMatchers,
+  ...pageMatchers,
+  ...apiMatchers,
+  ...generalMatchers,
+  ...asymmetricMatchers
+};
+
+// src/index.ts
+var exPwExpect = playwrightExpect.extend(allMatchers);
+var expect18 = exPwExpect;
+var exPw = {
+  ...allMatchers
+};
+var index_default = exPw;
+export {
+  apiMatchers,
+  asymmetricMatchers,
+  index_default as default,
+  expect18 as expect,
+  generalMatchers,
+  locatorMatchers,
+  pageMatchers,
+  toBeCamelCase,
+  toBeCheckable,
+  toBeClickable,
+  toBeDateString,
+  toBeEmail,
+  toBeISODate,
+  toBeInvalid,
+  toBeJSON,
+  toBeKebabCase,
+  toBeLowerCase,
+  toBePascalCase,
+  toBeRequired,
+  toBeSnakeCase,
+  toBeSorted,
+  toBeURL,
+  toBeUUID,
+  toBeUpperCase,
+  toBeValid,
+  toBeWithinRange,
+  toEndWith,
+  toHaveClipboardText,
+  toHaveConsoleMessage,
+  toHaveCookie,
+  toHaveCountGreaterThan,
+  toHaveCountGreaterThanOrEqual,
+  toHaveCountLessThan,
+  toHaveCountLessThanOrEqual,
+  toHaveHeader,
+  toHaveHeight,
+  toHaveLoadedImage,
+  toHaveLocalStorage,
+  toHaveNoErrors,
+  toHavePageError,
+  toHaveRequest,
+  toHaveSessionStorage,
+  toHaveSize,
+  toHaveStatus,
+  toHaveWidth,
+  toMatchJSON,
+  toMatchSchema,
+  toRespondWithin,
+  toStartWith
+};