@voidzero-dev/vite-plus-test 0.0.0-0bfcc90f.20260209-0731

package/dist/@vitest/browser/context.js

@@ -0,0 +1,541 @@
+import { __INTERNAL, stringify } from '../../browser.js';
+
+function ensureAwaited(promise) {
+  const test = getWorkerState().current;
+  if (!test || test.type !== "test") {
+    return promise();
+  }
+  let awaited = false;
+  const sourceError = new Error("STACK_TRACE_ERROR");
+  test.onFinished ??= [];
+  test.onFinished.push(() => {
+    if (!awaited) {
+      const error = new Error(`The call was not awaited. This method is asynchronous and must be awaited; otherwise, the call will not start to avoid unhandled rejections.`);
+      error.stack = sourceError.stack?.replace(sourceError.message, error.message);
+      throw error;
+    }
+  });
+  // don't even start the promise if it's not awaited to not cause any unhanded promise rejections
+  let promiseResult;
+  return {
+    then(onFulfilled, onRejected) {
+      awaited = true;
+      return (promiseResult ||= promise(sourceError)).then(onFulfilled, onRejected);
+    },
+    catch(onRejected) {
+      return (promiseResult ||= promise(sourceError)).catch(onRejected);
+    },
+    finally(onFinally) {
+      return (promiseResult ||= promise(sourceError)).finally(onFinally);
+    },
+    [Symbol.toStringTag]: "Promise"
+  };
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getBrowserState() {
+  // @ts-expect-error not typed global
+  return window.__vitest_browser_runner__;
+}
+/* @__NO_SIDE_EFFECTS__ */
+function getWorkerState() {
+  // @ts-expect-error not typed global
+  const state = window.__vitest_worker__;
+  if (!state) {
+    throw new Error("Worker state is not found. This is an issue with Vitest. Please, open an issue.");
+  }
+  return state;
+}
+
+const provider$1 = getBrowserState().provider;
+/* @__NO_SIDE_EFFECTS__ */
+function convertElementToCssSelector(element) {
+  if (!element || !(element instanceof Element)) {
+    throw new Error(`Expected DOM element to be an instance of Element, received ${typeof element}`);
+  }
+  return getUniqueCssSelector(element);
+}
+function escapeIdForCSSSelector(id) {
+  return id.split("").map((char) => {
+    const code = char.charCodeAt(0);
+    if (char === " " || char === "#" || char === "." || char === ":" || char === "[" || char === "]" || char === ">" || char === "+" || char === "~" || char === "\\") {
+      // Escape common special characters with backslashes
+      return `\\${char}`;
+    } else if (code >= 65536) {
+      // Unicode escape for characters outside the BMP
+      return `\\${code.toString(16).toUpperCase().padStart(6, "0")} `;
+    } else if (code < 32 || code === 127) {
+      // Non-printable ASCII characters (0x00-0x1F and 0x7F) are escaped
+      return `\\${code.toString(16).toUpperCase().padStart(2, "0")} `;
+    } else if (code >= 128) {
+      // Non-ASCII characters (0x80 and above) are escaped
+      return `\\${code.toString(16).toUpperCase().padStart(2, "0")} `;
+    } else {
+      // Allowable characters are used directly
+      return char;
+    }
+  }).join("");
+}
+function getUniqueCssSelector(el) {
+  const path = [];
+  let parent;
+  let hasShadowRoot = false;
+  // eslint-disable-next-line no-cond-assign
+  while (parent = getParent(el)) {
+    if (parent.shadowRoot) {
+      hasShadowRoot = true;
+    }
+    const tag = el.tagName;
+    if (el.id) {
+      path.push(`#${escapeIdForCSSSelector(el.id)}`);
+    } else if (!el.nextElementSibling && !el.previousElementSibling) {
+      path.push(tag.toLowerCase());
+    } else {
+      let index = 0;
+      let sameTagSiblings = 0;
+      let elementIndex = 0;
+      for (const sibling of parent.children) {
+        index++;
+        if (sibling.tagName === tag) {
+          sameTagSiblings++;
+        }
+        if (sibling === el) {
+          elementIndex = index;
+        }
+      }
+      if (sameTagSiblings > 1) {
+        path.push(`${tag.toLowerCase()}:nth-child(${elementIndex})`);
+      } else {
+        path.push(tag.toLowerCase());
+      }
+    }
+    el = parent;
+  }
+  return `${getBrowserState().provider === "webdriverio" && hasShadowRoot ? ">>>" : ""}${path.reverse().join(" > ")}`;
+}
+function getParent(el) {
+  const parent = el.parentNode;
+  if (parent instanceof ShadowRoot) {
+    return parent.host;
+  }
+  return parent;
+}
+const now = Date.now;
+function processTimeoutOptions(options_) {
+  if (options_ && options_.timeout != null || provider$1 !== "playwright") {
+    return options_;
+  }
+  // if there is a default action timeout, use it
+  if (getWorkerState().config.browser.providerOptions.actionTimeout != null) {
+    return options_;
+  }
+  const runner = getBrowserState().runner;
+  const startTime = runner._currentTaskStartTime;
+  // ignore timeout if this is called outside of a test
+  if (!startTime) {
+    return options_;
+  }
+  const timeout = runner._currentTaskTimeout;
+  if (timeout === 0 || timeout == null || timeout === Number.POSITIVE_INFINITY) {
+    return options_;
+  }
+  options_ = options_ || {};
+  const currentTime = now();
+  const endTime = startTime + timeout;
+  const remainingTime = endTime - currentTime;
+  if (remainingTime <= 0) {
+    return options_;
+  }
+  // give us some time to process the timeout
+  options_.timeout = remainingTime - 100;
+  return options_;
+}
+function convertToSelector(elementOrLocator) {
+  if (!elementOrLocator) {
+    throw new Error("Expected element or locator to be defined.");
+  }
+  if (elementOrLocator instanceof Element) {
+    return convertElementToCssSelector(elementOrLocator);
+  }
+  if (isLocator(elementOrLocator)) {
+    return elementOrLocator.selector;
+  }
+  throw new Error("Expected element or locator to be an instance of Element or Locator.");
+}
+const kLocator = Symbol.for("$$vitest:locator");
+function isLocator(element) {
+  return !!element && typeof element === "object" && kLocator in element;
+}
+
+// this file should not import anything directly, only types and utils
+// @ts-expect-error not typed global
+const provider = __vitest_browser_runner__.provider;
+const sessionId = getBrowserState().sessionId;
+const channel = new BroadcastChannel(`vitest:${sessionId}`);
+function triggerCommand(command, args, error) {
+  return getBrowserState().commands.triggerCommand(command, args, error);
+}
+function createUserEvent(__tl_user_event_base__, options) {
+  if (__tl_user_event_base__) {
+    return createPreviewUserEvent(__tl_user_event_base__, options ?? {});
+  }
+  const keyboard = { unreleased: [] };
+  // https://playwright.dev/docs/api/class-keyboard
+  // https://webdriver.io/docs/api/browser/keys/
+  const modifier = provider === "playwright" ? "ControlOrMeta" : provider === "webdriverio" ? "Ctrl" : "Control";
+  const userEvent = {
+    setup() {
+      return createUserEvent();
+    },
+    async cleanup() {
+      // avoid cleanup rpc call if there is nothing to cleanup
+      if (!keyboard.unreleased.length) {
+        return;
+      }
+      return ensureAwaited(async (error) => {
+        await triggerCommand("__vitest_cleanup", [keyboard], error);
+        keyboard.unreleased = [];
+      });
+    },
+    click(element, options) {
+      return convertToLocator(element).click(options);
+    },
+    dblClick(element, options) {
+      return convertToLocator(element).dblClick(options);
+    },
+    tripleClick(element, options) {
+      return convertToLocator(element).tripleClick(options);
+    },
+    selectOptions(element, value, options) {
+      return convertToLocator(element).selectOptions(value, options);
+    },
+    clear(element, options) {
+      return convertToLocator(element).clear(options);
+    },
+    hover(element, options) {
+      return convertToLocator(element).hover(options);
+    },
+    unhover(element, options) {
+      return convertToLocator(element).unhover(options);
+    },
+    upload(element, files, options) {
+      return convertToLocator(element).upload(files, options);
+    },
+    fill(element, text, options) {
+      return convertToLocator(element).fill(text, options);
+    },
+    dragAndDrop(source, target, options) {
+      const sourceLocator = convertToLocator(source);
+      const targetLocator = convertToLocator(target);
+      return sourceLocator.dropTo(targetLocator, options);
+    },
+    async type(element, text, options) {
+      return ensureAwaited(async (error) => {
+        const selector = convertToSelector(element);
+        const { unreleased } = await triggerCommand("__vitest_type", [
+          selector,
+          text,
+          {
+            ...options,
+            unreleased: keyboard.unreleased
+          }
+        ], error);
+        keyboard.unreleased = unreleased;
+      });
+    },
+    tab(options = {}) {
+      return ensureAwaited((error) => triggerCommand("__vitest_tab", [options], error));
+    },
+    async keyboard(text) {
+      return ensureAwaited(async (error) => {
+        const { unreleased } = await triggerCommand("__vitest_keyboard", [text, keyboard], error);
+        keyboard.unreleased = unreleased;
+      });
+    },
+    async copy() {
+      await userEvent.keyboard(`{${modifier}>}{c}{/${modifier}}`);
+    },
+    async cut() {
+      await userEvent.keyboard(`{${modifier}>}{x}{/${modifier}}`);
+    },
+    async paste() {
+      await userEvent.keyboard(`{${modifier}>}{v}{/${modifier}}`);
+    }
+  };
+  return userEvent;
+}
+function createPreviewUserEvent(userEventBase, options) {
+  let userEvent = userEventBase.setup(options);
+  let clipboardData;
+  function toElement(element) {
+    return element instanceof Element ? element : element.element();
+  }
+  const vitestUserEvent = {
+    setup(options) {
+      return createPreviewUserEvent(userEventBase, options);
+    },
+    async cleanup() {
+      userEvent = userEventBase.setup(options ?? {});
+    },
+    async click(element) {
+      await userEvent.click(toElement(element));
+    },
+    async dblClick(element) {
+      await userEvent.dblClick(toElement(element));
+    },
+    async tripleClick(element) {
+      await userEvent.tripleClick(toElement(element));
+    },
+    async selectOptions(element, value) {
+      const options = (Array.isArray(value) ? value : [value]).map((option) => {
+        if (typeof option !== "string") {
+          return toElement(option);
+        }
+        return option;
+      });
+      await userEvent.selectOptions(toElement(element), options);
+    },
+    async clear(element) {
+      await userEvent.clear(toElement(element));
+    },
+    async hover(element) {
+      await userEvent.hover(toElement(element));
+    },
+    async unhover(element) {
+      await userEvent.unhover(toElement(element));
+    },
+    async upload(element, files) {
+      const uploadPromise = (Array.isArray(files) ? files : [files]).map(async (file) => {
+        if (typeof file !== "string") {
+          return file;
+        }
+        const { content: base64, basename, mime } = await triggerCommand("__vitest_fileInfo", [file, "base64"]);
+        const fileInstance = fetch(`data:${mime};base64,${base64}`).then((r) => r.blob()).then((blob) => new File([blob], basename, { type: mime }));
+        return fileInstance;
+      });
+      const uploadFiles = await Promise.all(uploadPromise);
+      return userEvent.upload(toElement(element), uploadFiles);
+    },
+    async fill(element, text) {
+      await userEvent.clear(toElement(element));
+      return userEvent.type(toElement(element), text);
+    },
+    async dragAndDrop() {
+      throw new Error(`The "preview" provider doesn't support 'userEvent.dragAndDrop'`);
+    },
+    async type(element, text, options) {
+      await userEvent.type(toElement(element), text, options);
+    },
+    async tab(options) {
+      await userEvent.tab(options);
+    },
+    async keyboard(text) {
+      await userEvent.keyboard(text);
+    },
+    async copy() {
+      clipboardData = await userEvent.copy();
+    },
+    async cut() {
+      clipboardData = await userEvent.cut();
+    },
+    async paste() {
+      await userEvent.paste(clipboardData);
+    }
+  };
+  for (const [name, fn] of Object.entries(vitestUserEvent)) {
+    if (name !== "setup") {
+      vitestUserEvent[name] = function(...args) {
+        return ensureAwaited(() => fn.apply(this, args));
+      };
+    }
+  }
+  return vitestUserEvent;
+}
+function cdp() {
+  return getBrowserState().cdp;
+}
+const screenshotIds = {};
+const page = {
+  viewport(width, height) {
+    const id = getBrowserState().iframeId;
+    channel.postMessage({
+      event: "viewport",
+      width,
+      height,
+      iframeId: id
+    });
+    return new Promise((resolve, reject) => {
+      channel.addEventListener("message", function handler(e) {
+        if (e.data.event === "viewport:done" && e.data.iframeId === id) {
+          channel.removeEventListener("message", handler);
+          resolve();
+        }
+        if (e.data.event === "viewport:fail" && e.data.iframeId === id) {
+          channel.removeEventListener("message", handler);
+          reject(new Error(e.data.error));
+        }
+      });
+    });
+  },
+  async screenshot(options = {}) {
+    const currentTest = getWorkerState().current;
+    if (!currentTest) {
+      throw new Error("Cannot take a screenshot outside of a test.");
+    }
+    if (currentTest.concurrent) {
+      throw new Error("Cannot take a screenshot in a concurrent test because " + "concurrent tests run at the same time in the same iframe and affect each other's environment. " + "Use a non-concurrent test to take a screenshot.");
+    }
+    const repeatCount = currentTest.result?.repeatCount ?? 0;
+    const taskName = getTaskFullName(currentTest);
+    const number = screenshotIds[repeatCount]?.[taskName] ?? 1;
+    screenshotIds[repeatCount] ??= {};
+    screenshotIds[repeatCount][taskName] = number + 1;
+    const name = options.path || `${taskName.replace(/[^a-z0-9]/gi, "-")}-${number}.png`;
+    const normalizedOptions = "mask" in options ? {
+      ...options,
+      mask: options.mask.map(convertToSelector)
+    } : options;
+    return ensureAwaited((error) => triggerCommand("__vitest_screenshot", [name, processTimeoutOptions(
+      {
+        ...normalizedOptions,
+        element: options.element ? convertToSelector(options.element) : undefined
+      }
+      /** TODO */
+    )], error));
+  },
+  getByRole() {
+    throw new Error(`Method "getByRole" is not supported by the "${provider}" provider.`);
+  },
+  getByLabelText() {
+    throw new Error(`Method "getByLabelText" is not supported by the "${provider}" provider.`);
+  },
+  getByTestId() {
+    throw new Error(`Method "getByTestId" is not supported by the "${provider}" provider.`);
+  },
+  getByAltText() {
+    throw new Error(`Method "getByAltText" is not supported by the "${provider}" provider.`);
+  },
+  getByPlaceholder() {
+    throw new Error(`Method "getByPlaceholder" is not supported by the "${provider}" provider.`);
+  },
+  getByText() {
+    throw new Error(`Method "getByText" is not supported by the "${provider}" provider.`);
+  },
+  getByTitle() {
+    throw new Error(`Method "getByTitle" is not supported by the "${provider}" provider.`);
+  },
+  elementLocator() {
+    throw new Error(`Method "elementLocator" is not supported by the "${provider}" provider.`);
+  },
+  frameLocator() {
+    throw new Error(`Method "frameLocator" is not supported by the "${provider}" provider.`);
+  },
+  extend(methods) {
+    for (const key in methods) {
+      page[key] = methods[key].bind(page);
+    }
+    return page;
+  }
+};
+function convertToLocator(element) {
+  if (element instanceof Element) {
+    return page.elementLocator(element);
+  }
+  return element;
+}
+function getTaskFullName(task) {
+  return task.suite ? `${getTaskFullName(task.suite)} ${task.name}` : task.name;
+}
+const locators = {
+  createElementLocators: getElementLocatorSelectors,
+  extend(methods) {
+    const Locator = __INTERNAL._createLocator("css=body").constructor;
+    for (const method in methods) {
+      __INTERNAL._extendedMethods.add(method);
+      const cb = methods[method];
+      // @ts-expect-error types are hard to make work
+      Locator.prototype[method] = function(...args) {
+        const selectorOrLocator = cb.call(this, ...args);
+        if (typeof selectorOrLocator === "string") {
+          return this.locator(selectorOrLocator);
+        }
+        return selectorOrLocator;
+      };
+      page[method] = function(...args) {
+        const selectorOrLocator = cb.call(this, ...args);
+        if (typeof selectorOrLocator === "string") {
+          return __INTERNAL._createLocator(selectorOrLocator);
+        }
+        return selectorOrLocator;
+      };
+    }
+  }
+};
+function getElementLocatorSelectors(element) {
+  const locator = page.elementLocator(element);
+  return {
+    getByAltText: (altText, options) => locator.getByAltText(altText, options),
+    getByLabelText: (labelText, options) => locator.getByLabelText(labelText, options),
+    getByPlaceholder: (placeholderText, options) => locator.getByPlaceholder(placeholderText, options),
+    getByRole: (role, options) => locator.getByRole(role, options),
+    getByTestId: (testId) => locator.getByTestId(testId),
+    getByText: (text, options) => locator.getByText(text, options),
+    getByTitle: (title, options) => locator.getByTitle(title, options),
+    ...Array.from(__INTERNAL._extendedMethods).reduce((methods, method) => {
+      methods[method] = (...args) => locator[method](...args);
+      return methods;
+    }, {})
+  };
+}
+let defaultOptions;
+function debug(el, maxLength, options) {
+  if (Array.isArray(el)) {
+    // eslint-disable-next-line no-console
+    el.forEach((e) => console.log(prettyDOM(e, maxLength, options)));
+  } else {
+    // eslint-disable-next-line no-console
+    console.log(prettyDOM(el, maxLength, options));
+  }
+}
+function prettyDOM(dom, maxLength = Number(defaultOptions?.maxLength ?? import.meta.env.DEBUG_PRINT_LIMIT ?? 7e3), prettyFormatOptions = {}) {
+  if (maxLength === 0) {
+    return "";
+  }
+  if (!dom) {
+    dom = document.body;
+  }
+  if ("element" in dom && "all" in dom) {
+    dom = dom.element();
+  }
+  const type = typeof dom;
+  if (type !== "object" || !dom.outerHTML) {
+    const typeName = type === "object" ? dom.constructor.name : type;
+    throw new TypeError(`Expecting a valid DOM element, but got ${typeName}.`);
+  }
+  const pretty = stringify(dom, Number.POSITIVE_INFINITY, {
+    maxLength,
+    highlight: true,
+    ...defaultOptions,
+    ...prettyFormatOptions
+  });
+  return dom.outerHTML.length > maxLength ? `${pretty.slice(0, maxLength)}...` : pretty;
+}
+function getElementError(selector, container) {
+  const error = new Error(`Cannot find element with locator: ${__INTERNAL._asLocator("javascript", selector)}\n\n${prettyDOM(container)}`);
+  error.name = "VitestBrowserElementError";
+  return error;
+}
+/**
+* @experimental
+*/
+function configurePrettyDOM(options) {
+  defaultOptions = options;
+}
+const utils = {
+  getElementError,
+  prettyDOM,
+  debug,
+  getElementLocatorSelectors,
+  configurePrettyDOM
+};
+
+export { cdp, createUserEvent, locators, page, utils };

package/dist/@vitest/browser/expect-element.js

@@ -0,0 +1,32 @@
+import{recordArtifact,expect,chai}from'../../index.js';import{getType}from'../../browser.js';import{k as kAriaCheckedRoles,L as Locator,g as getAriaChecked,a as getAriaRole,b as getAriaDisabled,c as beginAriaCaches,e as endAriaCaches,i as isElementVisible$1,d as getElementAccessibleDescription,f as getElementAccessibleErrorMessage,h as getElementAccessibleName,j as cssEscape,l as convertToSelector,m as getBrowserState,p as processTimeoutOptions}from"./index-D6m36C6U.js";const server = {
+  get browser() { return window.__vitest_browser_runner__?.config?.browser?.name; },
+  get config() { return window.__vitest_browser_runner__?.config || {}; },
+  get commands() { return window.__vitest_browser_runner__?.commands || {}; },
+  get provider() { return window.__vitest_browser_runner__?.provider; },
+};function getAriaCheckedRoles(){return[...kAriaCheckedRoles]}function queryElementFromUserInput(_,K,q){return _ instanceof Locator&&(_=_.query()),_==null?null:getElementFromUserInput(_,K,q)}function getElementFromUserInput(_,K,q){_ instanceof Locator&&(_=_.element());let J=_?.ownerDocument?.defaultView||window;if(_ instanceof J.HTMLElement||_ instanceof J.SVGElement)return _;throw new UserInputElementTypeError(_,K,q)}function getNodeFromUserInput(_,K,q){_ instanceof Locator&&(_=_.element());let J=_.ownerDocument?.defaultView||window;if(_ instanceof J.Node)return _;throw new UserInputNodeTypeError(_,K,q)}function getMessage(_,K,q,J,Y,X){return[`${K}\n`,`${q}:\n${_.utils.EXPECTED_COLOR(redent(display(_,J),2))}`,`${Y}:\n${_.utils.RECEIVED_COLOR(redent(display(_,X),2))}`].join(`
+`)}function redent(_,K){return indentString(stripIndent(_),K)}function indentString(_,K){return _.replace(/^(?!\s*$)/gm,` `.repeat(K))}function minIndent(_){let K=_.match(/^[ \t]*(?=\S)/gm);return K?K.reduce((_,K)=>Math.min(_,K.length),1/0):0}function stripIndent(_){let K=minIndent(_);if(K===0)return _;let q=RegExp(`^[ \\t]{${K}}`,`gm`);return _.replace(q,``)}function display(_,K){return typeof K==`string`?K:_.utils.stringify(K)}function toSentence(_,{wordConnector:K=`, `,lastWordConnector:q=` and `}={}){return[_.slice(0,-1).join(K),_.at(-1)].join(_.length>1?q:``)}class GenericTypeError extends Error{constructor(_,K,q,J){super(),Error.captureStackTrace&&Error.captureStackTrace(this,q);let Y=``;try{Y=J.utils.printWithType(`Received`,K,J.utils.printReceived)}catch{}this.message=[J.utils.matcherHint(`${J.isNot?`.not`:``}.${q.name}`,`received`,``),``,`${J.utils.RECEIVED_COLOR(`received`)} value must ${_} or a Locator that returns ${_}.`,Y].join(`
+`)}}class UserInputElementTypeError extends GenericTypeError{constructor(_,K,q){super(`an HTMLElement or an SVGElement`,_,K,q)}}class UserInputNodeTypeError extends GenericTypeError{constructor(_,K,q){super(`a Node`,_,K,q)}}function getTag(_){return _ instanceof HTMLFormElement?`FORM`:_.tagName.toUpperCase()}function isInputElement(_){return getTag(_)===`INPUT`}function getSingleElementValue(_){if(_)switch(getTag(_)){case`INPUT`:return getInputValue(_);case`SELECT`:return getSelectValue(_);default:return _.value??getAccessibleValue(_)}}function getSelectValue({multiple:_,options:K}){let q=[...K].filter(_=>_.selected);if(_)return[...q].map(_=>_.value);if(q.length!==0)return q[0].value}function getInputValue(_){switch(_.type){case`number`:return _.value===``?null:Number(_.value);case`checkbox`:return _.checked;default:return _.value}}const rolesSupportingValues=[`meter`,`progressbar`,`slider`,`spinbutton`];function getAccessibleValue(_){if(rolesSupportingValues.includes(_.getAttribute(`role`)||``))return Number(_.getAttribute(`aria-valuenow`))}function normalize(_){return _.replace(/\s+/g,` `).trim()}function matches(_,K){return K instanceof RegExp?K.test(_):_.includes(String(K))}function arrayAsSetComparison(_,K){if(Array.isArray(_)&&Array.isArray(K)){let q=new Set(K);for(let K of new Set(_))if(!q.has(K))return!1;return!0}}const supportedRoles=getAriaCheckedRoles();function toBeChecked(_){let K=getElementFromUserInput(_,toBeChecked,this);if(!(()=>isInputElement(K)&&[`checkbox`,`radio`].includes(K.type))()&&!(()=>supportedRoles.includes(getAriaRole(K)||``)&&[`true`,`false`].includes(K.getAttribute(`aria-checked`)||``))())return{pass:!1,message:()=>`only inputs with type="checkbox" or type="radio" or elements with ${supportedRolesSentence()} and a valid aria-checked attribute can be used with .toBeChecked(). Use .toHaveValue() instead`};let q=getAriaChecked(K)===!0;return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeChecked`,`element`,``),``,`Received element ${_} checked:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function supportedRolesSentence(){return toSentence(supportedRoles.map(_=>`role="${_}"`),{lastWordConnector:` or `})}function toBeEmptyDOMElement(_){let K=getElementFromUserInput(_,toBeEmptyDOMElement,this);return{pass:isEmptyElement(K),message:()=>[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeEmptyDOMElement`,`element`,``),``,`Received:`,`  ${this.utils.printReceived(K.innerHTML)}`].join(`
+`)}}function isEmptyElement(_){return[..._.childNodes].filter(_=>_.nodeType!==Node.COMMENT_NODE).length===0}function toBeDisabled(_){let K=getElementFromUserInput(_,toBeDisabled,this),q=isElementDisabled(K);return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeDisabled`,`element`,``),``,`Received element ${_} disabled:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function toBeEnabled(_){let K=getElementFromUserInput(_,toBeEnabled,this),q=isElementDisabled(K);return{pass:!q,message:()=>{let _=q?`is not`:`is`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeEnabled`,`element`,``),``,`Received element ${_} enabled:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function isElementDisabled(_){return getTag(_).includes(`-`)?_.hasAttribute(`disabled`):getAriaDisabled(_)}function toBeInTheDocument(_){let K=null;(_!==null||!this.isNot)&&(K=queryElementFromUserInput(_,toBeInTheDocument,this));let q=K===null?!1:K.ownerDocument===K.getRootNode({composed:!0}),J=()=>`expected document not to contain element, found ${this.utils.stringify(K?.cloneNode(!0))} instead`,Y=()=>`element could not be found in the document`;return{pass:q,message:()=>[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeInTheDocument`,`element`,``),``,this.utils.RECEIVED_COLOR(this.isNot?J():Y())].join(`
+`)}}const FORM_TAGS$1=[`FORM`,`INPUT`,`SELECT`,`TEXTAREA`];function isElementHavingAriaInvalid(_){return _.hasAttribute(`aria-invalid`)&&_.getAttribute(`aria-invalid`)!==`false`}function isSupportsValidityMethod(_){return FORM_TAGS$1.includes(getTag(_))}function isElementInvalid(_){let K=isElementHavingAriaInvalid(_);return isSupportsValidityMethod(_)?K||!_.checkValidity():K}function toBeInvalid(_){let K=getElementFromUserInput(_,toBeInvalid,this),q=isElementInvalid(K);return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeInvalid`,`element`,``),``,`Received element ${_} currently invalid:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function toBeValid(_){let K=getElementFromUserInput(_,toBeInvalid,this),q=!isElementInvalid(K);return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeValid`,`element`,``),``,`Received element ${_} currently valid:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function toBeInViewport(_,K){let q=getElementFromUserInput(_,toBeInViewport,this),J=K?.ratio??0;return getViewportIntersection(q,J).then(({pass:_,ratio:K})=>({pass:_,message:()=>{let Y=_?`is`:`is not`,X=J>0?` with ratio ${J}`:``,Z=K===void 0?``:` (actual ratio: ${K.toFixed(3)})`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeInViewport`,`element`,``),``,`Received element ${Y} in viewport${X}${Z}:`,`  ${this.utils.printReceived(q.cloneNode(!1))}`].join(`
+`)}}))}async function getViewportIntersection(_,K){let q=await new Promise(K=>{let q=new IntersectionObserver(_=>{_.length>0?K(_[0].intersectionRatio):K(0),q.disconnect()});q.observe(_),requestAnimationFrame(()=>{})});return{pass:q>0&&q>K-1e-9,ratio:q}}function toBePartiallyChecked(_){let K=getElementFromUserInput(_,toBePartiallyChecked,this);if(!(()=>isInputElement(K)&&K.type===`checkbox`)()&&!(()=>K.getAttribute(`role`)===`checkbox`)())return{pass:!1,message:()=>`only inputs with type="checkbox" or elements with role="checkbox" and a valid aria-checked attribute can be used with .toBePartiallyChecked(). Use .toHaveValue() instead`};let q=isAriaMixed(K);return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBePartiallyChecked`,`element`,``),``,`Received element ${_} partially checked:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function isAriaMixed(_){let K=getAriaChecked(_)===`mixed`;return!K&&isInputElement(_)&&[`checkbox`,`radio`].includes(_.type)&&_.getAttribute(`aria-checked`)===`mixed`?!0:K}const FORM_TAGS=[`SELECT`,`TEXTAREA`],ARIA_FORM_TAGS=[`INPUT`,`SELECT`,`TEXTAREA`],UNSUPPORTED_INPUT_TYPES=[`color`,`hidden`,`range`,`submit`,`image`,`reset`],SUPPORTED_ARIA_ROLES=[`checkbox`,`combobox`,`gridcell`,`listbox`,`radiogroup`,`spinbutton`,`textbox`,`tree`];function isRequiredOnFormTagsExceptInput(_){return FORM_TAGS.includes(getTag(_))&&_.hasAttribute(`required`)}function isRequiredOnSupportedInput(_){return getTag(_)===`INPUT`&&_.hasAttribute(`required`)&&(_.hasAttribute(`type`)&&!UNSUPPORTED_INPUT_TYPES.includes(_.getAttribute(`type`)||``)||!_.hasAttribute(`type`))}function isElementRequiredByARIA(_){return _.hasAttribute(`aria-required`)&&_.getAttribute(`aria-required`)===`true`&&(ARIA_FORM_TAGS.includes(getTag(_))||_.hasAttribute(`role`)&&SUPPORTED_ARIA_ROLES.includes(_.getAttribute(`role`)||``))}function toBeRequired(_){let K=getElementFromUserInput(_,toBeRequired,this),q=isRequiredOnFormTagsExceptInput(K)||isRequiredOnSupportedInput(K)||isElementRequiredByARIA(K);return{pass:q,message:()=>{let _=q?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeRequired`,`element`,``),``,`Received element ${_} required:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function toBeVisible(_){let K=getElementFromUserInput(_,toBeVisible,this),q=K.ownerDocument===K.getRootNode({composed:!0});beginAriaCaches();let J=q&&isElementVisible(K);return endAriaCaches(),{pass:J,message:()=>{let _=J?`is`:`is not`;return[this.utils.matcherHint(`${this.isNot?`.not`:``}.toBeVisible`,`element`,``),``,`Received element ${_} visible${q?``:` (element is not in the document)`}:`,`  ${this.utils.printReceived(K.cloneNode(!1))}`].join(`
+`)}}}function isElementVisible(_){let K=isElementVisible$1(_);if(server.browser!==`webkit`)return K;let q=_.closest(`details`);return!q||_===q?K:isElementVisibleInDetails(_)}function isElementVisibleInDetails(_){let K=_;for(;K;){if(K.tagName===`DETAILS`){let q=K.querySelector(`summary`)===_;if(!K.open&&!q)return!1}K=K.parentElement}return _.offsetParent!==null}function toContainElement(_,K){let q=getElementFromUserInput(_,toContainElement,this),J=K===null?null:getElementFromUserInput(K,toContainElement,this);return{pass:q.contains(J),message:()=>[this.utils.matcherHint(`${this.isNot?`.not`:``}.toContainElement`,`element`,`element`),``,this.utils.RECEIVED_COLOR(`${this.utils.stringify(q.cloneNode(!1))} ${this.isNot?`contains:`:`does not contain:`} ${this.utils.stringify(J?J.cloneNode(!1):null)}
+        `)].join(`
+`)}}function getNormalizedHtml(_,K){let q=_.ownerDocument.createElement(`div`);return q.innerHTML=K,q.innerHTML}function toContainHTML(_,K){let q=getElementFromUserInput(_,toContainHTML,this);if(typeof K!=`string`)throw TypeError(`.toContainHTML() expects a string value, got ${K}`);return{pass:q.outerHTML.includes(getNormalizedHtml(q,K)),message:()=>[this.utils.matcherHint(`${this.isNot?`.not`:``}.toContainHTML`,`element`,``),`Expected:`,`  ${this.utils.EXPECTED_COLOR(K)}`,`Received:`,`  ${this.utils.printReceived(q.cloneNode(!0))}`].join(`
+`)}}function toHaveAccessibleDescription(_,K){let q=getElementFromUserInput(_,toHaveAccessibleDescription,this),J=getElementAccessibleDescription(q,!1),Y=q.ownerDocument.defaultView||window,X=arguments.length===1,Z=!1;return Z=X?J!==``:K instanceof Y.RegExp?K.test(J):this.equals(J,K,this.customTesters),{pass:Z,message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveAccessibleDescription`,`element`,``),`Expected element ${_} have accessible description`,K,`Received`,J)}}}function toHaveAccessibleErrorMessage(_,K){let q=getElementFromUserInput(_,toHaveAccessibleErrorMessage,this),J=getElementAccessibleErrorMessage(q)??``,Y=q.ownerDocument.defaultView||window,X=arguments.length===1,Z=!1;return Z=X?J!==``:K instanceof Y.RegExp?K.test(J):this.equals(J,K,this.customTesters),{pass:Z,message:()=>{let _=this.isNot?`not to`:`to`;return K==null?[this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveAccessibleErrorMessage`,`element`,``),`Expected element ${_} have accessible error message, but got${this.isNot?``:` nothing`}`,this.isNot?this.utils.RECEIVED_COLOR(redent(J,2)):``].filter(Boolean).join(`
+
+`):getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveAccessibleErrorMessage`,`element`,``),`Expected element ${_} have accessible error message`,K,`Received`,J)}}}function toHaveAccessibleName(_,K){let q=getElementFromUserInput(_,toHaveAccessibleName,this),J=getElementAccessibleName(q,!1),Y=arguments.length===1,X=q.ownerDocument.defaultView||window,Z=!1;return Z=Y?J!==``:K instanceof X.RegExp?K.test(J):this.equals(J,K,this.customTesters),{pass:Z,message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.${toHaveAccessibleName.name}`,`element`,``),`Expected element ${_} have accessible name`,K,`Received`,J)}}}function toHaveAttribute(_,K,q){let J=getElementFromUserInput(_,toHaveAttribute,this),Y=q!==void 0,X=J.hasAttribute(K),Z=J.getAttribute(K);return{pass:Y?X&&this.equals(Z,q,this.customTesters):X,message:()=>{let _=this.isNot?`not to`:`to`,J=X?printAttribute(this.utils.stringify,K,Z):null,Q=this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveAttribute`,`element`,this.utils.printExpected(K),{secondArgument:Y?this.utils.printExpected(q):void 0,comment:getAttributeComment(this.utils.stringify,K,q)});return getMessage(this,Q,`Expected the element ${_} have attribute`,printAttribute(this.utils.stringify,K,q),`Received`,J)}}}function printAttribute(_,K,q){return q===void 0?K:`${K}=${_(q)}`}function getAttributeComment(_,K,q){return q===void 0?`element.hasAttribute(${_(K)})`:`element.getAttribute(${_(K)}) === ${_(q)}`}function toHaveClass(_,...K){let q=getElementFromUserInput(_,toHaveClass,this),{expectedClassNames:J,options:Y}=getExpectedClassNamesAndOptions(K),X=splitClassNames(q.getAttribute(`class`)),Z=J.reduce((_,K)=>_.concat(typeof K==`string`||!K?splitClassNames(K):K),[]),Q=Z.some(_=>_ instanceof RegExp);if(Y.exact&&Q)throw Error(`Exact option does not support RegExp expected class names`);return Y.exact?{pass:isSubset$1(Z,X)&&Z.length===X.length,message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveClass`,`element`,this.utils.printExpected(Z.join(` `))),`Expected the element ${_} have EXACTLY defined classes`,Z.join(` `),`Received`,X.join(` `))}}:Z.length>0?{pass:isSubset$1(Z,X),message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveClass`,`element`,this.utils.printExpected(Z.join(` `))),`Expected the element ${_} have class`,Z.join(` `),`Received`,X.join(` `))}}:{pass:this.isNot?X.length>0:!1,message:()=>this.isNot?getMessage(this,this.utils.matcherHint(`.not.toHaveClass`,`element`,``),`Expected the element to have classes`,`(none)`,`Received`,X.join(` `)):[this.utils.matcherHint(`.toHaveClass`,`element`),`At least one expected class must be provided.`].join(`
+`)}}function getExpectedClassNamesAndOptions(_){let K=_.pop(),q,J;return typeof K==`object`&&!(K instanceof RegExp)?(q=_,J=K):(q=_.concat(K),J={exact:!1}),{expectedClassNames:q,options:J}}function splitClassNames(_){return _?_.split(/\s+/).filter(_=>_.length>0):[]}function isSubset$1(_,K){return _.every(_=>typeof _==`string`?K.includes(_):K.some(K=>_.test(K)))}function toHaveDisplayValue(_,K){let q=getElementFromUserInput(_,toHaveDisplayValue,this),J=getTag(q);if(![`SELECT`,`INPUT`,`TEXTAREA`].includes(J))throw Error(`.toHaveDisplayValue() currently supports only input, textarea or select elements, try with another matcher instead.`);if(isInputElement(q)&&[`radio`,`checkbox`].includes(q.type))throw Error(`.toHaveDisplayValue() currently does not support input[type="${q.type}"], try with another matcher instead.`);let Y=getValues(J,q),X=getExpectedValues(K),Z=X.filter(_=>Y.some(K=>_ instanceof RegExp?_.test(K):this.equals(K,String(_),this.customTesters))).length,Q=Z===Y.length,$=Z===X.length;return{pass:Q&&$,message:()=>getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveDisplayValue`,`element`,``),`Expected element ${this.isNot?`not `:``}to have display value`,K,`Received`,Y)}}function getValues(_,K){return _===`SELECT`?Array.from(K).filter(_=>_.selected).map(_=>_.textContent||``):[K.value]}function getExpectedValues(_){return Array.isArray(_)?_:[_]}function toHaveFocus(_){let K=getElementFromUserInput(_,toHaveFocus,this);return{pass:K.ownerDocument.activeElement===K,message:()=>[this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveFocus`,`element`,``),``,...this.isNot?[`Received element is focused:`,`  ${this.utils.printReceived(K)}`]:[`Expected element with focus:`,`  ${this.utils.printExpected(K)}`,`Received element with focus:`,`  ${this.utils.printReceived(K.ownerDocument.activeElement)}`]].join(`
+`)}}function toHaveFormValues(_,K){let q=getElementFromUserInput(_,toHaveFormValues,this),J=q.ownerDocument.defaultView||window;if(!(q instanceof J.HTMLFieldSetElement)&&!(q instanceof J.HTMLFormElement))throw TypeError(`toHaveFormValues must be called on a form or a fieldset, instead got ${getTag(q)}`);if(!K||typeof K!=`object`)throw TypeError(`toHaveFormValues must be called with an object of expected form values. Got ${K}`);let Y=getAllFormValues(q);return{pass:Object.entries(K).every(([_,K])=>this.equals(Y[_],K,[arrayAsSetComparison,...this.customTesters])),message:()=>{let _=this.isNot?`not to`:`to`,q=`${this.isNot?`.not`:``}.toHaveFormValues`,J={};for(let _ in Y)Object.hasOwn(K,_)&&(J[_]=Y[_]);return[this.utils.matcherHint(q,`element`,``),`Expected the element ${_} have form values`,this.utils.diff(K,J)].join(`
+
+`)}}}function getMultiElementValue(_){let K=``;for(let q of _){if(K&&K!==q.type)throw Error(`Multiple form elements with the same name must be of the same type`);K=q.type}switch(K){case`radio`:{let K=_.find(_=>_.checked);return K?K.value:void 0}case`checkbox`:return _.filter(_=>_.checked).map(_=>_.value);default:return _.map(_=>_.value)}}function getFormValue(_,K){let q=[..._.querySelectorAll(`[name="${cssEscape(K)}"]`)];if(q.length!==0)switch(q.length){case 1:return getSingleElementValue(q[0]);default:return getMultiElementValue(q)}}function getPureName(_){return/\[\]$/.test(_)?_.slice(0,-2):_}function getAllFormValues(_){let K={};for(let q of _.elements){if(!(`name`in q))continue;let J=q.name;K[getPureName(J)]=getFormValue(_,J)}return K}function toHaveRole(_,K){let q=getElementFromUserInput(_,toHaveRole,this);beginAriaCaches();let J=getAriaRole(q);return endAriaCaches(),{pass:J===K,message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveRole`,`element`,``),`Expected element ${_} have role`,K,`Received`,J)}}}function toHaveSelection(_,K){let q=getElementFromUserInput(_,toHaveSelection,this),J=K!==void 0;if(J&&typeof K!=`string`)throw Error(`expected selection must be a string or undefined`);let Y=getSelection(q);return{pass:J?this.equals(Y,K,[arrayAsSetComparison,...this.customTesters]):!!Y,message:()=>{let _=this.isNot?`not to`:`to`,q=this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveSelection`,`element`,K);return getMessage(this,q,`Expected the element ${_} have selection`,J?K:`(any)`,`Received`,Y)}}}function getSelection(_){let K=_.ownerDocument.getSelection();if(!K)return``;if([`INPUT`,`TEXTAREA`].includes(getTag(_))){let K=_;return[`radio`,`checkbox`].includes(K.type)||K.selectionStart==null||K.selectionEnd==null?``:K.value.toString().substring(K.selectionStart,K.selectionEnd)}if(K.anchorNode===null||K.focusNode===null)return``;let q=K.getRangeAt(0),J=_.ownerDocument.createRange();if(K.containsNode(_,!1))J.selectNodeContents(_),K.removeAllRanges(),K.addRange(J);else if(!(_.contains(K.anchorNode)&&_.contains(K.focusNode))){let Y=_===q.startContainer||_.contains(q.startContainer),X=_===q.endContainer||_.contains(q.endContainer);K.removeAllRanges(),(Y||X)&&(J.selectNodeContents(_),Y&&J.setStart(q.startContainer,q.startOffset),X&&J.setEnd(q.endContainer,q.endOffset),K.addRange(J))}let Y=K.toString();return K.removeAllRanges(),K.addRange(q),Y}const browser=server.config.browser.name,usedValuesProps=new Set(`backgroundPosition.background-position.bottom.left.right.top.height.width.margin-bottom.marginBottom.margin-left.marginLeft.margin-right.marginRight.margin-top.marginTop.min-height.minHeight.min-width.minWidth.padding-bottom.padding-left.padding-right.padding-top.text-indent.paddingBottom.paddingLeft.paddingRight.paddingTop.textIndent`.split(`.`));function toHaveStyle(_,K){let q=getElementFromUserInput(_,toHaveStyle,this),{getComputedStyle:J}=q.ownerDocument.defaultView,Y=typeof K==`object`?getStyleFromObjectCSS(K):computeCSSStyleDeclaration(K),X=J(q),Z=new Set(Array.from(q.style));return{pass:isSubset(Y,q,X,Z),message:()=>{let _=`${this.isNot?`.not`:``}.toHaveStyle`,K=new Set(Object.keys(Y)),J=printoutObjectStyles(Array.from(X).filter(_=>K.has(_)).reduce((_,K)=>(_[K]=(Z.has(K)&&usedValuesProps.has(K)?q.style:X)[K],_),{})),Q=J===``?`Expected styles could not be parsed by the browser. Did you make a typo?`:this.utils.diff(printoutObjectStyles(Y),J);return[this.utils.matcherHint(_,`element`,``),Q].join(`
+
+`)}}}function getStyleFromObjectCSS(_){let K=browser===`chrome`||browser===`chromium`?document:document.implementation.createHTMLDocument(``),q=K.createElement(`div`);K.body.appendChild(q);let J=Object.keys(_);J.forEach(K=>{q.style[K]=_[K]});let Y={},X=window.getComputedStyle(q);return J.forEach(_=>{let K=(usedValuesProps.has(_)?q.style:X)[_];K!=null&&(Y[_]=K)}),q.remove(),Y}function computeCSSStyleDeclaration(_){let K=browser===`chrome`||browser===`chromium`||browser===`webkit`?document:document.implementation.createHTMLDocument(``),q=K.createElement(`div`);q.setAttribute(`style`,_.replace(/\n/g,``)),K.body.appendChild(q);let J=window.getComputedStyle(q),Y=Array.from(q.style).reduce((_,K)=>(_[K]=usedValuesProps.has(K)?q.style.getPropertyValue(K):J.getPropertyValue(K),_),{});return q.remove(),Y}function printoutObjectStyles(_){return Object.keys(_).sort().map(K=>`${K}: ${_[K]};`).join(`
+`)}function isSubset(_,K,q,J){let Y=Object.keys(_);return Y.length?Y.every(Y=>{let X=_[Y],Z=Y.startsWith(`--`),Q=[Y];return Z||Q.push(Y.toLowerCase()),Q.some(_=>{let Z=J.has(Y)&&usedValuesProps.has(Y)?K.style:q;return Z[_]===X||Z.getPropertyValue(_)===X})}):!1}function toHaveTextContent(_,K,q={normalizeWhitespace:!0}){let J=getNodeFromUserInput(_,toHaveTextContent,this),Y=q.normalizeWhitespace?normalize(J.textContent||``):(J.textContent||``).replace(/\u00A0/g,` `),X=Y!==``&&K===``;return{pass:!X&&matches(Y,K),message:()=>{let _=this.isNot?`not to`:`to`;return getMessage(this,this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveTextContent`,`element`,``),X?`Checking with empty string will always match, use .toBeEmptyDOMElement() instead`:`Expected element ${_} have text content`,K,`Received`,Y)}}}function toHaveValue(_,K){let q=getElementFromUserInput(_,toHaveValue,this);if(isInputElement(q)&&[`checkbox`,`radio`].includes(q.type))throw Error(`input with type=checkbox or type=radio cannot be used with .toHaveValue(). Use .toBeChecked() for type=checkbox or .toHaveFormValues() instead`);let J=getSingleElementValue(q),Y=K!==void 0,X=K,Z=J;return K==J&&K!==J&&(X=`${K} (${typeof K})`,Z=`${J} (${typeof J})`),{pass:Y?this.equals(J,K,[arrayAsSetComparison,...this.customTesters]):!!J,message:()=>{let _=this.isNot?`not to`:`to`,q=this.utils.matcherHint(`${this.isNot?`.not`:``}.toHaveValue`,`element`,K);return getMessage(this,q,`Expected the element ${_} have value`,Y?X:`(any)`,`Received`,Z)}}}const counters=new Map([]);async function toMatchScreenshot(K,q,J=typeof q==`object`?q:{}){if(this.isNot)throw Error(`'toMatchScreenshot' cannot be used with "not"`);if(this.task===void 0||this.currentTestName===void 0)throw Error(`'toMatchScreenshot' cannot be used without test context`);let Y=`${this.task.result?.repeatCount??0}${this.testPath}${this.currentTestName}`,X=counters.get(Y);X===void 0&&(X={current:0},counters.set(Y,X)),X.current+=1;let Z=typeof q==`string`?q:`${this.currentTestName} ${X.current}`,Q=J.screenshotOptions&&`mask`in J.screenshotOptions?{...J,screenshotOptions:{...J.screenshotOptions,mask:J.screenshotOptions.mask.map(convertToSelector)}}:J,$=await getBrowserState().commands.triggerCommand(`__vitest_screenshotMatcher`,[Z,this.currentTestName,{element:convertToSelector(K),...Q}]);if($.pass===!1){let K=[];$.reference&&K.push({name:`reference`,...$.reference}),$.actual&&K.push({name:`actual`,...$.actual}),$.diff&&K.push({name:`diff`,...$.diff}),K.length>0&&await recordArtifact(this.task,{type:`internal:toMatchScreenshot`,kind:`visual-regression`,message:$.message,attachments:K})}return{pass:$.pass,message:()=>$.pass?``:[this.utils.matcherHint(`toMatchScreenshot`,`element`,``),``,$.message,$.reference?`\nReference screenshot:\n  ${this.utils.EXPECTED_COLOR($.reference.path)}`:null,$.actual?`\nActual screenshot:\n  ${this.utils.RECEIVED_COLOR($.actual.path)}`:null,$.diff?this.utils.DIM_COLOR(`\nDiff image:\n  ${$.diff.path}`):null,``].filter(_=>_!==null).join(`
+`)}}const matchers={toBeDisabled,toBeEnabled,toBeEmptyDOMElement,toBeInTheDocument,toBeInViewport,toBeInvalid,toBeRequired,toBeValid,toBeVisible,toContainElement,toContainHTML,toHaveAccessibleDescription,toHaveAccessibleErrorMessage,toHaveAccessibleName,toHaveAttribute,toHaveClass,toHaveFocus,toHaveFormValues,toHaveStyle,toHaveTextContent,toHaveValue,toHaveDisplayValue,toBeChecked,toBePartiallyChecked,toHaveRole,toHaveSelection,toMatchScreenshot},kLocator=Symbol.for(`$$vitest:locator`);function element(_,Y){if(_!=null&&!(_ instanceof HTMLElement)&&!(_ instanceof SVGElement)&&!(kLocator in _))throw Error(`Invalid element or locator: ${_}. Expected an instance of HTMLElement, SVGElement or Locator, received ${getType(_)}`);let X=expect.poll(function(){if(_ instanceof Element||_==null)return _;let K=chai.util.flag(this,`negate`),J=chai.util.flag(this,`_name`);if(K&&J===`toBeInTheDocument`)return _.query();if(J===`toHaveLength`)return _.elements();if(J===`toMatchScreenshot`&&!chai.util.flag(this,`_poll.assert_once`)&&chai.util.flag(this,`_poll.assert_once`,!0),chai.util.flag(this,`_isLastPollAttempt`))return _.element();let Y=_.query();if(!Y)throw Error(`Cannot find element with locator: ${JSON.stringify(_)}`);return Y},processTimeoutOptions(Y));return chai.util.flag(X,`_poll.element`,!0),X}expect.extend(matchers),expect.element=element;