vitest 0.0.66 → 0.0.70

package/dist/entry.js

@@ -0,0 +1,3331 @@
+import { importModule } from 'local-pkg';
+import chai, { expect } from 'chai';
+import SinonChai from 'sinon-chai';
+import Subset from 'chai-subset';
+import path, { basename } from 'path';
+import { g as getNames, i as interpretOnlyMode, p as partitionSuiteChildren, c as hasTests, h as hasFailed } from './utils-9dcc4050.js';
+import fs from 'fs';
+import { performance } from 'perf_hooks';
+import { j as setHooks, c as createSuiteHooks, h as clearContext, d as defaultSuite, k as context, l as getHooks, m as getFn } from './suite-819c135e.js';
+import { n as nanoid } from './index-6427e0f2.js';
+
+var node = {
+  name: "node",
+  async setup() {
+    return {
+      teardown() {
+      }
+    };
+  }
+};
+
+const LIVING_KEYS = [
+  "DOMException",
+  "URL",
+  "URLSearchParams",
+  "EventTarget",
+  "NamedNodeMap",
+  "Node",
+  "Attr",
+  "Element",
+  "DocumentFragment",
+  "DOMImplementation",
+  "Document",
+  "XMLDocument",
+  "CharacterData",
+  "Text",
+  "CDATASection",
+  "ProcessingInstruction",
+  "Comment",
+  "DocumentType",
+  "NodeList",
+  "HTMLCollection",
+  "HTMLOptionsCollection",
+  "DOMStringMap",
+  "DOMTokenList",
+  "StyleSheetList",
+  "HTMLElement",
+  "HTMLHeadElement",
+  "HTMLTitleElement",
+  "HTMLBaseElement",
+  "HTMLLinkElement",
+  "HTMLMetaElement",
+  "HTMLStyleElement",
+  "HTMLBodyElement",
+  "HTMLHeadingElement",
+  "HTMLParagraphElement",
+  "HTMLHRElement",
+  "HTMLPreElement",
+  "HTMLUListElement",
+  "HTMLOListElement",
+  "HTMLLIElement",
+  "HTMLMenuElement",
+  "HTMLDListElement",
+  "HTMLDivElement",
+  "HTMLAnchorElement",
+  "HTMLAreaElement",
+  "HTMLBRElement",
+  "HTMLButtonElement",
+  "HTMLCanvasElement",
+  "HTMLDataElement",
+  "HTMLDataListElement",
+  "HTMLDetailsElement",
+  "HTMLDialogElement",
+  "HTMLDirectoryElement",
+  "HTMLFieldSetElement",
+  "HTMLFontElement",
+  "HTMLFormElement",
+  "HTMLHtmlElement",
+  "HTMLImageElement",
+  "HTMLInputElement",
+  "HTMLLabelElement",
+  "HTMLLegendElement",
+  "HTMLMapElement",
+  "HTMLMarqueeElement",
+  "HTMLMediaElement",
+  "HTMLMeterElement",
+  "HTMLModElement",
+  "HTMLOptGroupElement",
+  "HTMLOptionElement",
+  "HTMLOutputElement",
+  "HTMLPictureElement",
+  "HTMLProgressElement",
+  "HTMLQuoteElement",
+  "HTMLScriptElement",
+  "HTMLSelectElement",
+  "HTMLSlotElement",
+  "HTMLSourceElement",
+  "HTMLSpanElement",
+  "HTMLTableCaptionElement",
+  "HTMLTableCellElement",
+  "HTMLTableColElement",
+  "HTMLTableElement",
+  "HTMLTimeElement",
+  "HTMLTableRowElement",
+  "HTMLTableSectionElement",
+  "HTMLTemplateElement",
+  "HTMLTextAreaElement",
+  "HTMLUnknownElement",
+  "HTMLFrameElement",
+  "HTMLFrameSetElement",
+  "HTMLIFrameElement",
+  "HTMLEmbedElement",
+  "HTMLObjectElement",
+  "HTMLParamElement",
+  "HTMLVideoElement",
+  "HTMLAudioElement",
+  "HTMLTrackElement",
+  "SVGElement",
+  "SVGGraphicsElement",
+  "SVGSVGElement",
+  "SVGTitleElement",
+  "SVGAnimatedString",
+  "SVGNumber",
+  "SVGStringList",
+  "Event",
+  "CloseEvent",
+  "CustomEvent",
+  "MessageEvent",
+  "ErrorEvent",
+  "HashChangeEvent",
+  "PopStateEvent",
+  "StorageEvent",
+  "ProgressEvent",
+  "PageTransitionEvent",
+  "UIEvent",
+  "FocusEvent",
+  "InputEvent",
+  "MouseEvent",
+  "KeyboardEvent",
+  "TouchEvent",
+  "CompositionEvent",
+  "WheelEvent",
+  "BarProp",
+  "External",
+  "Location",
+  "History",
+  "Screen",
+  "Performance",
+  "Navigator",
+  "PluginArray",
+  "MimeTypeArray",
+  "Plugin",
+  "MimeType",
+  "FileReader",
+  "Blob",
+  "File",
+  "FileList",
+  "ValidityState",
+  "DOMParser",
+  "XMLSerializer",
+  "FormData",
+  "XMLHttpRequestEventTarget",
+  "XMLHttpRequestUpload",
+  "XMLHttpRequest",
+  "WebSocket",
+  "NodeFilter",
+  "NodeIterator",
+  "TreeWalker",
+  "AbstractRange",
+  "Range",
+  "StaticRange",
+  "Selection",
+  "Storage",
+  "CustomElementRegistry",
+  "ShadowRoot",
+  "MutationObserver",
+  "MutationRecord",
+  "Headers",
+  "AbortController",
+  "AbortSignal"
+];
+const OTHER_KEYS = [
+  "addEventListener",
+  "alert",
+  "atob",
+  "blur",
+  "btoa",
+  "close",
+  "confirm",
+  "createPopup",
+  "dispatchEvent",
+  "document",
+  "focus",
+  "frames",
+  "getComputedStyle",
+  "history",
+  "innerHeight",
+  "innerWidth",
+  "length",
+  "location",
+  "moveBy",
+  "moveTo",
+  "name",
+  "navigator",
+  "open",
+  "outerHeight",
+  "outerWidth",
+  "pageXOffset",
+  "pageYOffset",
+  "parent",
+  "postMessage",
+  "print",
+  "prompt",
+  "removeEventListener",
+  "resizeBy",
+  "resizeTo",
+  "screen",
+  "screenLeft",
+  "screenTop",
+  "screenX",
+  "screenY",
+  "scroll",
+  "scrollBy",
+  "scrollLeft",
+  "scrollTo",
+  "scrollTop",
+  "scrollX",
+  "scrollY",
+  "self",
+  "stop",
+  "top",
+  "window"
+];
+const KEYS = LIVING_KEYS.concat(OTHER_KEYS);
+
+var jsdom = {
+  name: "jsdom",
+  async setup(global) {
+    const { JSDOM } = await importModule("jsdom");
+    const dom = new JSDOM("<!DOCTYPE html>", {
+      pretendToBeVisual: true,
+      runScripts: "dangerously",
+      url: "http://localhost:3000"
+    });
+    const keys = KEYS.concat(Object.getOwnPropertyNames(dom.window)).filter((k) => !k.startsWith("_")).filter((k) => !(k in global));
+    for (const key of keys)
+      global[key] = dom.window[key];
+    return {
+      teardown(global2) {
+        keys.forEach((key) => delete global2[key]);
+      }
+    };
+  }
+};
+
+var happy = {
+  name: "happy-dom",
+  async setup(global) {
+    const { Window } = await importModule("happy-dom");
+    const win = new Window();
+    const keys = KEYS.concat(Object.getOwnPropertyNames(win)).filter((k) => !k.startsWith("_")).filter((k) => !(k in global));
+    for (const key of keys)
+      global[key] = win[key];
+    return {
+      teardown(global2) {
+        win.happyDOM.cancelAsync();
+        keys.forEach((key) => delete global2[key]);
+      }
+    };
+  }
+};
+
+const environments = {
+  node,
+  jsdom,
+  "happy-dom": happy
+};
+
+const rpc = async (method, ...args) => {
+  var _a;
+  return (_a = process.__vitest_worker__) == null ? void 0 : _a.rpc(method, ...args);
+};
+const send = async (method, ...args) => {
+  var _a;
+  return (_a = process.__vitest_worker__) == null ? void 0 : _a.send(method, ...args);
+};
+
+var naturalCompare$2 = {exports: {}};
+
+/*
+ * @version    1.4.0
+ * @date       2015-10-26
+ * @stability  3 - Stable
+ * @author     Lauri Rooden (https://github.com/litejs/natural-compare-lite)
+ * @license    MIT License
+ */
+
+
+var naturalCompare = function(a, b) {
+	var i, codeA
+	, codeB = 1
+	, posA = 0
+	, posB = 0
+	, alphabet = String.alphabet;
+
+	function getCode(str, pos, code) {
+		if (code) {
+			for (i = pos; code = getCode(str, i), code < 76 && code > 65;) ++i;
+			return +str.slice(pos - 1, i)
+		}
+		code = alphabet && alphabet.indexOf(str.charAt(pos));
+		return code > -1 ? code + 76 : ((code = str.charCodeAt(pos) || 0), code < 45 || code > 127) ? code
+			: code < 46 ? 65               // -
+			: code < 48 ? code - 1
+			: code < 58 ? code + 18        // 0-9
+			: code < 65 ? code - 11
+			: code < 91 ? code + 11        // A-Z
+			: code < 97 ? code - 37
+			: code < 123 ? code + 5        // a-z
+			: code - 63
+	}
+
+
+	if ((a+="") != (b+="")) for (;codeB;) {
+		codeA = getCode(a, posA++);
+		codeB = getCode(b, posB++);
+
+		if (codeA < 76 && codeB < 76 && codeA > 66 && codeB > 66) {
+			codeA = getCode(a, posA, posA);
+			codeB = getCode(b, posB, posA = i);
+			posB = i;
+		}
+
+		if (codeA != codeB) return (codeA < codeB) ? -1 : 1
+	}
+	return 0
+};
+
+try {
+	naturalCompare$2.exports = naturalCompare;
+} catch (e) {
+	String.naturalCompare = naturalCompare;
+}
+
+var naturalCompare$1 = naturalCompare$2.exports;
+
+var build = {};
+
+var ansiStyles = {exports: {}};
+
+(function (module) {
+
+const ANSI_BACKGROUND_OFFSET = 10;
+
+const wrapAnsi256 = (offset = 0) => code => `\u001B[${38 + offset};5;${code}m`;
+
+const wrapAnsi16m = (offset = 0) => (red, green, blue) => `\u001B[${38 + offset};2;${red};${green};${blue}m`;
+
+function assembleStyles() {
+	const codes = new Map();
+	const styles = {
+		modifier: {
+			reset: [0, 0],
+			// 21 isn't widely supported and 22 does the same thing
+			bold: [1, 22],
+			dim: [2, 22],
+			italic: [3, 23],
+			underline: [4, 24],
+			overline: [53, 55],
+			inverse: [7, 27],
+			hidden: [8, 28],
+			strikethrough: [9, 29]
+		},
+		color: {
+			black: [30, 39],
+			red: [31, 39],
+			green: [32, 39],
+			yellow: [33, 39],
+			blue: [34, 39],
+			magenta: [35, 39],
+			cyan: [36, 39],
+			white: [37, 39],
+
+			// Bright color
+			blackBright: [90, 39],
+			redBright: [91, 39],
+			greenBright: [92, 39],
+			yellowBright: [93, 39],
+			blueBright: [94, 39],
+			magentaBright: [95, 39],
+			cyanBright: [96, 39],
+			whiteBright: [97, 39]
+		},
+		bgColor: {
+			bgBlack: [40, 49],
+			bgRed: [41, 49],
+			bgGreen: [42, 49],
+			bgYellow: [43, 49],
+			bgBlue: [44, 49],
+			bgMagenta: [45, 49],
+			bgCyan: [46, 49],
+			bgWhite: [47, 49],
+
+			// Bright color
+			bgBlackBright: [100, 49],
+			bgRedBright: [101, 49],
+			bgGreenBright: [102, 49],
+			bgYellowBright: [103, 49],
+			bgBlueBright: [104, 49],
+			bgMagentaBright: [105, 49],
+			bgCyanBright: [106, 49],
+			bgWhiteBright: [107, 49]
+		}
+	};
+
+	// Alias bright black as gray (and grey)
+	styles.color.gray = styles.color.blackBright;
+	styles.bgColor.bgGray = styles.bgColor.bgBlackBright;
+	styles.color.grey = styles.color.blackBright;
+	styles.bgColor.bgGrey = styles.bgColor.bgBlackBright;
+
+	for (const [groupName, group] of Object.entries(styles)) {
+		for (const [styleName, style] of Object.entries(group)) {
+			styles[styleName] = {
+				open: `\u001B[${style[0]}m`,
+				close: `\u001B[${style[1]}m`
+			};
+
+			group[styleName] = styles[styleName];
+
+			codes.set(style[0], style[1]);
+		}
+
+		Object.defineProperty(styles, groupName, {
+			value: group,
+			enumerable: false
+		});
+	}
+
+	Object.defineProperty(styles, 'codes', {
+		value: codes,
+		enumerable: false
+	});
+
+	styles.color.close = '\u001B[39m';
+	styles.bgColor.close = '\u001B[49m';
+
+	styles.color.ansi256 = wrapAnsi256();
+	styles.color.ansi16m = wrapAnsi16m();
+	styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+	styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+	// From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+	Object.defineProperties(styles, {
+		rgbToAnsi256: {
+			value: (red, green, blue) => {
+				// We use the extended greyscale palette here, with the exception of
+				// black and white. normal palette only has 4 greyscale shades.
+				if (red === green && green === blue) {
+					if (red < 8) {
+						return 16;
+					}
+
+					if (red > 248) {
+						return 231;
+					}
+
+					return Math.round(((red - 8) / 247) * 24) + 232;
+				}
+
+				return 16 +
+					(36 * Math.round(red / 255 * 5)) +
+					(6 * Math.round(green / 255 * 5)) +
+					Math.round(blue / 255 * 5);
+			},
+			enumerable: false
+		},
+		hexToRgb: {
+			value: hex => {
+				const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+				if (!matches) {
+					return [0, 0, 0];
+				}
+
+				let {colorString} = matches.groups;
+
+				if (colorString.length === 3) {
+					colorString = colorString.split('').map(character => character + character).join('');
+				}
+
+				const integer = Number.parseInt(colorString, 16);
+
+				return [
+					(integer >> 16) & 0xFF,
+					(integer >> 8) & 0xFF,
+					integer & 0xFF
+				];
+			},
+			enumerable: false
+		},
+		hexToAnsi256: {
+			value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+			enumerable: false
+		}
+	});
+
+	return styles;
+}
+
+// Make the export immutable
+Object.defineProperty(module, 'exports', {
+	enumerable: true,
+	get: assembleStyles
+});
+}(ansiStyles));
+
+var collections = {};
+
+Object.defineProperty(collections, '__esModule', {
+  value: true
+});
+collections.printIteratorEntries = printIteratorEntries;
+collections.printIteratorValues = printIteratorValues;
+collections.printListItems = printListItems;
+collections.printObjectProperties = printObjectProperties;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const getKeysOfEnumerableProperties = (object, compareKeys) => {
+  const keys = Object.keys(object).sort(compareKeys);
+
+  if (Object.getOwnPropertySymbols) {
+    Object.getOwnPropertySymbols(object).forEach(symbol => {
+      if (Object.getOwnPropertyDescriptor(object, symbol).enumerable) {
+        keys.push(symbol);
+      }
+    });
+  }
+
+  return keys;
+};
+/**
+ * Return entries (for example, of a map)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+
+function printIteratorEntries(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer, // Too bad, so sad that separator for ECMAScript Map has been ' => '
+  // What a distracting diff if you change a data structure to/from
+  // ECMAScript Object or Immutable.Map/OrderedMap which use the default.
+  separator = ': '
+) {
+  let result = '';
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    while (!current.done) {
+      const name = printer(
+        current.value[0],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      const value = printer(
+        current.value[1],
+        config,
+        indentationNext,
+        depth,
+        refs
+      );
+      result += indentationNext + name + separator + value;
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return values (for example, of a set)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (braces or brackets)
+ */
+
+function printIteratorValues(
+  iterator,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) {
+  let result = '';
+  let current = iterator.next();
+
+  if (!current.done) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    while (!current.done) {
+      result +=
+        indentationNext +
+        printer(current.value, config, indentationNext, depth, refs);
+      current = iterator.next();
+
+      if (!current.done) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return items (for example, of an array)
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, brackets)
+ **/
+
+function printListItems(list, config, indentation, depth, refs, printer) {
+  let result = '';
+
+  if (list.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    for (let i = 0; i < list.length; i++) {
+      result += indentationNext;
+
+      if (i in list) {
+        result += printer(list[i], config, indentationNext, depth, refs);
+      }
+
+      if (i < list.length - 1) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+/**
+ * Return properties of an object
+ * with spacing, indentation, and comma
+ * without surrounding punctuation (for example, braces)
+ */
+
+function printObjectProperties(val, config, indentation, depth, refs, printer) {
+  let result = '';
+  const keys = getKeysOfEnumerableProperties(val, config.compareKeys);
+
+  if (keys.length) {
+    result += config.spacingOuter;
+    const indentationNext = indentation + config.indent;
+
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      const name = printer(key, config, indentationNext, depth, refs);
+      const value = printer(val[key], config, indentationNext, depth, refs);
+      result += indentationNext + name + ': ' + value;
+
+      if (i < keys.length - 1) {
+        result += ',' + config.spacingInner;
+      } else if (!config.min) {
+        result += ',';
+      }
+    }
+
+    result += config.spacingOuter + indentation;
+  }
+
+  return result;
+}
+
+var AsymmetricMatcher$1 = {};
+
+Object.defineProperty(AsymmetricMatcher$1, '__esModule', {
+  value: true
+});
+AsymmetricMatcher$1.default = AsymmetricMatcher$1.test = AsymmetricMatcher$1.serialize = void 0;
+
+var _collections$3 = collections;
+
+var global$1 = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global$1 !== 'undefined') {
+    return global$1;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol$2 = global$1['jest-symbol-do-not-touch'] || global$1.Symbol;
+const asymmetricMatcher =
+  typeof Symbol$2 === 'function' && Symbol$2.for
+    ? Symbol$2.for('jest.asymmetricMatcher')
+    : 0x1357a5;
+const SPACE$2 = ' ';
+
+const serialize$7 = (val, config, indentation, depth, refs, printer) => {
+  const stringedValue = val.toString();
+
+  if (
+    stringedValue === 'ArrayContaining' ||
+    stringedValue === 'ArrayNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return '[' + stringedValue + ']';
+    }
+
+    return (
+      stringedValue +
+      SPACE$2 +
+      '[' +
+      (0, _collections$3.printListItems)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      ']'
+    );
+  }
+
+  if (
+    stringedValue === 'ObjectContaining' ||
+    stringedValue === 'ObjectNotContaining'
+  ) {
+    if (++depth > config.maxDepth) {
+      return '[' + stringedValue + ']';
+    }
+
+    return (
+      stringedValue +
+      SPACE$2 +
+      '{' +
+      (0, _collections$3.printObjectProperties)(
+        val.sample,
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      '}'
+    );
+  }
+
+  if (
+    stringedValue === 'StringMatching' ||
+    stringedValue === 'StringNotMatching'
+  ) {
+    return (
+      stringedValue +
+      SPACE$2 +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+
+  if (
+    stringedValue === 'StringContaining' ||
+    stringedValue === 'StringNotContaining'
+  ) {
+    return (
+      stringedValue +
+      SPACE$2 +
+      printer(val.sample, config, indentation, depth, refs)
+    );
+  }
+
+  return val.toAsymmetricMatcher();
+};
+
+AsymmetricMatcher$1.serialize = serialize$7;
+
+const test$6 = val => val && val.$$typeof === asymmetricMatcher;
+
+AsymmetricMatcher$1.test = test$6;
+const plugin$6 = {
+  serialize: serialize$7,
+  test: test$6
+};
+var _default$7 = plugin$6;
+AsymmetricMatcher$1.default = _default$7;
+
+var ConvertAnsi = {};
+
+var ansiRegex = ({onlyFirst = false} = {}) => {
+	const pattern = [
+		'[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+		'(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-ntqry=><~]))'
+	].join('|');
+
+	return new RegExp(pattern, onlyFirst ? undefined : 'g');
+};
+
+Object.defineProperty(ConvertAnsi, '__esModule', {
+  value: true
+});
+ConvertAnsi.default = ConvertAnsi.serialize = ConvertAnsi.test = void 0;
+
+var _ansiRegex = _interopRequireDefault$2(ansiRegex);
+
+var _ansiStyles$1 = _interopRequireDefault$2(ansiStyles.exports);
+
+function _interopRequireDefault$2(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const toHumanReadableAnsi = text =>
+  text.replace((0, _ansiRegex.default)(), match => {
+    switch (match) {
+      case _ansiStyles$1.default.red.close:
+      case _ansiStyles$1.default.green.close:
+      case _ansiStyles$1.default.cyan.close:
+      case _ansiStyles$1.default.gray.close:
+      case _ansiStyles$1.default.white.close:
+      case _ansiStyles$1.default.yellow.close:
+      case _ansiStyles$1.default.bgRed.close:
+      case _ansiStyles$1.default.bgGreen.close:
+      case _ansiStyles$1.default.bgYellow.close:
+      case _ansiStyles$1.default.inverse.close:
+      case _ansiStyles$1.default.dim.close:
+      case _ansiStyles$1.default.bold.close:
+      case _ansiStyles$1.default.reset.open:
+      case _ansiStyles$1.default.reset.close:
+        return '</>';
+
+      case _ansiStyles$1.default.red.open:
+        return '<red>';
+
+      case _ansiStyles$1.default.green.open:
+        return '<green>';
+
+      case _ansiStyles$1.default.cyan.open:
+        return '<cyan>';
+
+      case _ansiStyles$1.default.gray.open:
+        return '<gray>';
+
+      case _ansiStyles$1.default.white.open:
+        return '<white>';
+
+      case _ansiStyles$1.default.yellow.open:
+        return '<yellow>';
+
+      case _ansiStyles$1.default.bgRed.open:
+        return '<bgRed>';
+
+      case _ansiStyles$1.default.bgGreen.open:
+        return '<bgGreen>';
+
+      case _ansiStyles$1.default.bgYellow.open:
+        return '<bgYellow>';
+
+      case _ansiStyles$1.default.inverse.open:
+        return '<inverse>';
+
+      case _ansiStyles$1.default.dim.open:
+        return '<dim>';
+
+      case _ansiStyles$1.default.bold.open:
+        return '<bold>';
+
+      default:
+        return '';
+    }
+  });
+
+const test$5 = val =>
+  typeof val === 'string' && !!val.match((0, _ansiRegex.default)());
+
+ConvertAnsi.test = test$5;
+
+const serialize$6 = (val, config, indentation, depth, refs, printer) =>
+  printer(toHumanReadableAnsi(val), config, indentation, depth, refs);
+
+ConvertAnsi.serialize = serialize$6;
+const plugin$5 = {
+  serialize: serialize$6,
+  test: test$5
+};
+var _default$6 = plugin$5;
+ConvertAnsi.default = _default$6;
+
+var DOMCollection$1 = {};
+
+Object.defineProperty(DOMCollection$1, '__esModule', {
+  value: true
+});
+DOMCollection$1.default = DOMCollection$1.serialize = DOMCollection$1.test = void 0;
+
+var _collections$2 = collections;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const SPACE$1 = ' ';
+const OBJECT_NAMES = ['DOMStringMap', 'NamedNodeMap'];
+const ARRAY_REGEXP = /^(HTML\w*Collection|NodeList)$/;
+
+const testName = name =>
+  OBJECT_NAMES.indexOf(name) !== -1 || ARRAY_REGEXP.test(name);
+
+const test$4 = val =>
+  val &&
+  val.constructor &&
+  !!val.constructor.name &&
+  testName(val.constructor.name);
+
+DOMCollection$1.test = test$4;
+
+const isNamedNodeMap = collection =>
+  collection.constructor.name === 'NamedNodeMap';
+
+const serialize$5 = (collection, config, indentation, depth, refs, printer) => {
+  const name = collection.constructor.name;
+
+  if (++depth > config.maxDepth) {
+    return '[' + name + ']';
+  }
+
+  return (
+    (config.min ? '' : name + SPACE$1) +
+    (OBJECT_NAMES.indexOf(name) !== -1
+      ? '{' +
+        (0, _collections$2.printObjectProperties)(
+          isNamedNodeMap(collection)
+            ? Array.from(collection).reduce((props, attribute) => {
+                props[attribute.name] = attribute.value;
+                return props;
+              }, {})
+            : {...collection},
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}'
+      : '[' +
+        (0, _collections$2.printListItems)(
+          Array.from(collection),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        ']')
+  );
+};
+
+DOMCollection$1.serialize = serialize$5;
+const plugin$4 = {
+  serialize: serialize$5,
+  test: test$4
+};
+var _default$5 = plugin$4;
+DOMCollection$1.default = _default$5;
+
+var DOMElement$1 = {};
+
+var markup = {};
+
+var escapeHTML$1 = {};
+
+Object.defineProperty(escapeHTML$1, '__esModule', {
+  value: true
+});
+escapeHTML$1.default = escapeHTML;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+function escapeHTML(str) {
+  return str.replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+Object.defineProperty(markup, '__esModule', {
+  value: true
+});
+markup.printElementAsLeaf =
+  markup.printElement =
+  markup.printComment =
+  markup.printText =
+  markup.printChildren =
+  markup.printProps =
+    void 0;
+
+var _escapeHTML = _interopRequireDefault$1(escapeHTML$1);
+
+function _interopRequireDefault$1(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// Return empty string if keys is empty.
+const printProps = (keys, props, config, indentation, depth, refs, printer) => {
+  const indentationNext = indentation + config.indent;
+  const colors = config.colors;
+  return keys
+    .map(key => {
+      const value = props[key];
+      let printed = printer(value, config, indentationNext, depth, refs);
+
+      if (typeof value !== 'string') {
+        if (printed.indexOf('\n') !== -1) {
+          printed =
+            config.spacingOuter +
+            indentationNext +
+            printed +
+            config.spacingOuter +
+            indentation;
+        }
+
+        printed = '{' + printed + '}';
+      }
+
+      return (
+        config.spacingInner +
+        indentation +
+        colors.prop.open +
+        key +
+        colors.prop.close +
+        '=' +
+        colors.value.open +
+        printed +
+        colors.value.close
+      );
+    })
+    .join('');
+}; // Return empty string if children is empty.
+
+markup.printProps = printProps;
+
+const printChildren = (children, config, indentation, depth, refs, printer) =>
+  children
+    .map(
+      child =>
+        config.spacingOuter +
+        indentation +
+        (typeof child === 'string'
+          ? printText(child, config)
+          : printer(child, config, indentation, depth, refs))
+    )
+    .join('');
+
+markup.printChildren = printChildren;
+
+const printText = (text, config) => {
+  const contentColor = config.colors.content;
+  return (
+    contentColor.open + (0, _escapeHTML.default)(text) + contentColor.close
+  );
+};
+
+markup.printText = printText;
+
+const printComment = (comment, config) => {
+  const commentColor = config.colors.comment;
+  return (
+    commentColor.open +
+    '<!--' +
+    (0, _escapeHTML.default)(comment) +
+    '-->' +
+    commentColor.close
+  );
+}; // Separate the functions to format props, children, and element,
+// so a plugin could override a particular function, if needed.
+// Too bad, so sad: the traditional (but unnecessary) space
+// in a self-closing tagColor requires a second test of printedProps.
+
+markup.printComment = printComment;
+
+const printElement = (
+  type,
+  printedProps,
+  printedChildren,
+  config,
+  indentation
+) => {
+  const tagColor = config.colors.tag;
+  return (
+    tagColor.open +
+    '<' +
+    type +
+    (printedProps &&
+      tagColor.close +
+        printedProps +
+        config.spacingOuter +
+        indentation +
+        tagColor.open) +
+    (printedChildren
+      ? '>' +
+        tagColor.close +
+        printedChildren +
+        config.spacingOuter +
+        indentation +
+        tagColor.open +
+        '</' +
+        type
+      : (printedProps && !config.min ? '' : ' ') + '/') +
+    '>' +
+    tagColor.close
+  );
+};
+
+markup.printElement = printElement;
+
+const printElementAsLeaf = (type, config) => {
+  const tagColor = config.colors.tag;
+  return (
+    tagColor.open +
+    '<' +
+    type +
+    tagColor.close +
+    ' …' +
+    tagColor.open +
+    ' />' +
+    tagColor.close
+  );
+};
+
+markup.printElementAsLeaf = printElementAsLeaf;
+
+Object.defineProperty(DOMElement$1, '__esModule', {
+  value: true
+});
+DOMElement$1.default = DOMElement$1.serialize = DOMElement$1.test = void 0;
+
+var _markup$2 = markup;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+const ELEMENT_NODE = 1;
+const TEXT_NODE = 3;
+const COMMENT_NODE = 8;
+const FRAGMENT_NODE = 11;
+const ELEMENT_REGEXP = /^((HTML|SVG)\w*)?Element$/;
+
+const testHasAttribute = val => {
+  try {
+    return typeof val.hasAttribute === 'function' && val.hasAttribute('is');
+  } catch {
+    return false;
+  }
+};
+
+const testNode = val => {
+  const constructorName = val.constructor.name;
+  const {nodeType, tagName} = val;
+  const isCustomElement =
+    (typeof tagName === 'string' && tagName.includes('-')) ||
+    testHasAttribute(val);
+  return (
+    (nodeType === ELEMENT_NODE &&
+      (ELEMENT_REGEXP.test(constructorName) || isCustomElement)) ||
+    (nodeType === TEXT_NODE && constructorName === 'Text') ||
+    (nodeType === COMMENT_NODE && constructorName === 'Comment') ||
+    (nodeType === FRAGMENT_NODE && constructorName === 'DocumentFragment')
+  );
+};
+
+const test$3 = val => {
+  var _val$constructor;
+
+  return (
+    (val === null || val === void 0
+      ? void 0
+      : (_val$constructor = val.constructor) === null ||
+        _val$constructor === void 0
+      ? void 0
+      : _val$constructor.name) && testNode(val)
+  );
+};
+
+DOMElement$1.test = test$3;
+
+function nodeIsText(node) {
+  return node.nodeType === TEXT_NODE;
+}
+
+function nodeIsComment(node) {
+  return node.nodeType === COMMENT_NODE;
+}
+
+function nodeIsFragment(node) {
+  return node.nodeType === FRAGMENT_NODE;
+}
+
+const serialize$4 = (node, config, indentation, depth, refs, printer) => {
+  if (nodeIsText(node)) {
+    return (0, _markup$2.printText)(node.data, config);
+  }
+
+  if (nodeIsComment(node)) {
+    return (0, _markup$2.printComment)(node.data, config);
+  }
+
+  const type = nodeIsFragment(node)
+    ? `DocumentFragment`
+    : node.tagName.toLowerCase();
+
+  if (++depth > config.maxDepth) {
+    return (0, _markup$2.printElementAsLeaf)(type, config);
+  }
+
+  return (0, _markup$2.printElement)(
+    type,
+    (0, _markup$2.printProps)(
+      nodeIsFragment(node)
+        ? []
+        : Array.from(node.attributes)
+            .map(attr => attr.name)
+            .sort(),
+      nodeIsFragment(node)
+        ? {}
+        : Array.from(node.attributes).reduce((props, attribute) => {
+            props[attribute.name] = attribute.value;
+            return props;
+          }, {}),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    (0, _markup$2.printChildren)(
+      Array.prototype.slice.call(node.childNodes || node.children),
+      config,
+      indentation + config.indent,
+      depth,
+      refs,
+      printer
+    ),
+    config,
+    indentation
+  );
+};
+
+DOMElement$1.serialize = serialize$4;
+const plugin$3 = {
+  serialize: serialize$4,
+  test: test$3
+};
+var _default$4 = plugin$3;
+DOMElement$1.default = _default$4;
+
+var Immutable$1 = {};
+
+Object.defineProperty(Immutable$1, '__esModule', {
+  value: true
+});
+Immutable$1.default = Immutable$1.test = Immutable$1.serialize = void 0;
+
+var _collections$1 = collections;
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// SENTINEL constants are from https://github.com/facebook/immutable-js
+const IS_ITERABLE_SENTINEL = '@@__IMMUTABLE_ITERABLE__@@';
+const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_MAP_SENTINEL = '@@__IMMUTABLE_MAP__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+const IS_RECORD_SENTINEL = '@@__IMMUTABLE_RECORD__@@'; // immutable v4
+
+const IS_SEQ_SENTINEL = '@@__IMMUTABLE_SEQ__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_STACK_SENTINEL = '@@__IMMUTABLE_STACK__@@';
+
+const getImmutableName = name => 'Immutable.' + name;
+
+const printAsLeaf = name => '[' + name + ']';
+
+const SPACE = ' ';
+const LAZY = '…'; // Seq is lazy if it calls a method like filter
+
+const printImmutableEntries = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : getImmutableName(type) +
+      SPACE +
+      '{' +
+      (0, _collections$1.printIteratorEntries)(
+        val.entries(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      '}'; // Record has an entries method because it is a collection in immutable v3.
+// Return an iterator for Immutable Record from version v3 or v4.
+
+function getRecordEntries(val) {
+  let i = 0;
+  return {
+    next() {
+      if (i < val._keys.length) {
+        const key = val._keys[i++];
+        return {
+          done: false,
+          value: [key, val.get(key)]
+        };
+      }
+
+      return {
+        done: true,
+        value: undefined
+      };
+    }
+  };
+}
+
+const printImmutableRecord = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer
+) => {
+  // _name property is defined only for an Immutable Record instance
+  // which was constructed with a second optional descriptive name arg
+  const name = getImmutableName(val._name || 'Record');
+  return ++depth > config.maxDepth
+    ? printAsLeaf(name)
+    : name +
+        SPACE +
+        '{' +
+        (0, _collections$1.printIteratorEntries)(
+          getRecordEntries(val),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}';
+};
+
+const printImmutableSeq = (val, config, indentation, depth, refs, printer) => {
+  const name = getImmutableName('Seq');
+
+  if (++depth > config.maxDepth) {
+    return printAsLeaf(name);
+  }
+
+  if (val[IS_KEYED_SENTINEL]) {
+    return (
+      name +
+      SPACE +
+      '{' +
+      (val._iter || val._object
+        ? (0, _collections$1.printIteratorEntries)(
+            val.entries(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          )
+        : LAZY) +
+      '}'
+    );
+  }
+
+  return (
+    name +
+    SPACE +
+    '[' +
+    (val._iter || // from Immutable collection of values
+    val._array || // from ECMAScript array
+    val._collection || // from ECMAScript collection in immutable v4
+    val._iterable // from ECMAScript collection in immutable v3
+      ? (0, _collections$1.printIteratorValues)(
+          val.values(),
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        )
+      : LAZY) +
+    ']'
+  );
+};
+
+const printImmutableValues = (
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  printer,
+  type
+) =>
+  ++depth > config.maxDepth
+    ? printAsLeaf(getImmutableName(type))
+    : getImmutableName(type) +
+      SPACE +
+      '[' +
+      (0, _collections$1.printIteratorValues)(
+        val.values(),
+        config,
+        indentation,
+        depth,
+        refs,
+        printer
+      ) +
+      ']';
+
+const serialize$3 = (val, config, indentation, depth, refs, printer) => {
+  if (val[IS_MAP_SENTINEL]) {
+    return printImmutableEntries(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedMap' : 'Map'
+    );
+  }
+
+  if (val[IS_LIST_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'List'
+    );
+  }
+
+  if (val[IS_SET_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      val[IS_ORDERED_SENTINEL] ? 'OrderedSet' : 'Set'
+    );
+  }
+
+  if (val[IS_STACK_SENTINEL]) {
+    return printImmutableValues(
+      val,
+      config,
+      indentation,
+      depth,
+      refs,
+      printer,
+      'Stack'
+    );
+  }
+
+  if (val[IS_SEQ_SENTINEL]) {
+    return printImmutableSeq(val, config, indentation, depth, refs, printer);
+  } // For compatibility with immutable v3 and v4, let record be the default.
+
+  return printImmutableRecord(val, config, indentation, depth, refs, printer);
+}; // Explicitly comparing sentinel properties to true avoids false positive
+// when mock identity-obj-proxy returns the key as the value for any key.
+
+Immutable$1.serialize = serialize$3;
+
+const test$2 = val =>
+  val &&
+  (val[IS_ITERABLE_SENTINEL] === true || val[IS_RECORD_SENTINEL] === true);
+
+Immutable$1.test = test$2;
+const plugin$2 = {
+  serialize: serialize$3,
+  test: test$2
+};
+var _default$3 = plugin$2;
+Immutable$1.default = _default$3;
+
+var ReactElement$1 = {};
+
+var reactIs = {exports: {}};
+
+var reactIs_production_min = {};
+
+/** @license React v17.0.2
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var b=60103,c=60106,d=60107,e=60108,f=60114,g=60109,h=60110,k=60112,l=60113,m=60120,n=60115,p=60116,q=60121,r=60122,u=60117,v=60129,w=60131;
+if("function"===typeof Symbol&&Symbol.for){var x=Symbol.for;b=x("react.element");c=x("react.portal");d=x("react.fragment");e=x("react.strict_mode");f=x("react.profiler");g=x("react.provider");h=x("react.context");k=x("react.forward_ref");l=x("react.suspense");m=x("react.suspense_list");n=x("react.memo");p=x("react.lazy");q=x("react.block");r=x("react.server.block");u=x("react.fundamental");v=x("react.debug_trace_mode");w=x("react.legacy_hidden");}
+function y(a){if("object"===typeof a&&null!==a){var t=a.$$typeof;switch(t){case b:switch(a=a.type,a){case d:case f:case e:case l:case m:return a;default:switch(a=a&&a.$$typeof,a){case h:case k:case p:case n:case g:return a;default:return t}}case c:return t}}}var z=g,A=b,B=k,C=d,D=p,E=n,F=c,G=f,H=e,I=l;reactIs_production_min.ContextConsumer=h;reactIs_production_min.ContextProvider=z;reactIs_production_min.Element=A;reactIs_production_min.ForwardRef=B;reactIs_production_min.Fragment=C;reactIs_production_min.Lazy=D;reactIs_production_min.Memo=E;reactIs_production_min.Portal=F;reactIs_production_min.Profiler=G;reactIs_production_min.StrictMode=H;
+reactIs_production_min.Suspense=I;reactIs_production_min.isAsyncMode=function(){return !1};reactIs_production_min.isConcurrentMode=function(){return !1};reactIs_production_min.isContextConsumer=function(a){return y(a)===h};reactIs_production_min.isContextProvider=function(a){return y(a)===g};reactIs_production_min.isElement=function(a){return "object"===typeof a&&null!==a&&a.$$typeof===b};reactIs_production_min.isForwardRef=function(a){return y(a)===k};reactIs_production_min.isFragment=function(a){return y(a)===d};reactIs_production_min.isLazy=function(a){return y(a)===p};reactIs_production_min.isMemo=function(a){return y(a)===n};
+reactIs_production_min.isPortal=function(a){return y(a)===c};reactIs_production_min.isProfiler=function(a){return y(a)===f};reactIs_production_min.isStrictMode=function(a){return y(a)===e};reactIs_production_min.isSuspense=function(a){return y(a)===l};reactIs_production_min.isValidElementType=function(a){return "string"===typeof a||"function"===typeof a||a===d||a===f||a===v||a===e||a===l||a===m||a===w||"object"===typeof a&&null!==a&&(a.$$typeof===p||a.$$typeof===n||a.$$typeof===g||a.$$typeof===h||a.$$typeof===k||a.$$typeof===u||a.$$typeof===q||a[0]===r)?!0:!1};
+reactIs_production_min.typeOf=y;
+
+var reactIs_development = {};
+
+/** @license React v17.0.2
+ * react-is.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+// ATTENTION
+// When adding new symbols to this file,
+// Please consider also adding to 'react-devtools-shared/src/backend/ReactSymbols'
+// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
+// nor polyfill, then a plain number is used for performance.
+var REACT_ELEMENT_TYPE = 0xeac7;
+var REACT_PORTAL_TYPE = 0xeaca;
+var REACT_FRAGMENT_TYPE = 0xeacb;
+var REACT_STRICT_MODE_TYPE = 0xeacc;
+var REACT_PROFILER_TYPE = 0xead2;
+var REACT_PROVIDER_TYPE = 0xeacd;
+var REACT_CONTEXT_TYPE = 0xeace;
+var REACT_FORWARD_REF_TYPE = 0xead0;
+var REACT_SUSPENSE_TYPE = 0xead1;
+var REACT_SUSPENSE_LIST_TYPE = 0xead8;
+var REACT_MEMO_TYPE = 0xead3;
+var REACT_LAZY_TYPE = 0xead4;
+var REACT_BLOCK_TYPE = 0xead9;
+var REACT_SERVER_BLOCK_TYPE = 0xeada;
+var REACT_FUNDAMENTAL_TYPE = 0xead5;
+var REACT_DEBUG_TRACING_MODE_TYPE = 0xeae1;
+var REACT_LEGACY_HIDDEN_TYPE = 0xeae3;
+
+if (typeof Symbol === 'function' && Symbol.for) {
+  var symbolFor = Symbol.for;
+  REACT_ELEMENT_TYPE = symbolFor('react.element');
+  REACT_PORTAL_TYPE = symbolFor('react.portal');
+  REACT_FRAGMENT_TYPE = symbolFor('react.fragment');
+  REACT_STRICT_MODE_TYPE = symbolFor('react.strict_mode');
+  REACT_PROFILER_TYPE = symbolFor('react.profiler');
+  REACT_PROVIDER_TYPE = symbolFor('react.provider');
+  REACT_CONTEXT_TYPE = symbolFor('react.context');
+  REACT_FORWARD_REF_TYPE = symbolFor('react.forward_ref');
+  REACT_SUSPENSE_TYPE = symbolFor('react.suspense');
+  REACT_SUSPENSE_LIST_TYPE = symbolFor('react.suspense_list');
+  REACT_MEMO_TYPE = symbolFor('react.memo');
+  REACT_LAZY_TYPE = symbolFor('react.lazy');
+  REACT_BLOCK_TYPE = symbolFor('react.block');
+  REACT_SERVER_BLOCK_TYPE = symbolFor('react.server.block');
+  REACT_FUNDAMENTAL_TYPE = symbolFor('react.fundamental');
+  symbolFor('react.scope');
+  symbolFor('react.opaque.id');
+  REACT_DEBUG_TRACING_MODE_TYPE = symbolFor('react.debug_trace_mode');
+  symbolFor('react.offscreen');
+  REACT_LEGACY_HIDDEN_TYPE = symbolFor('react.legacy_hidden');
+}
+
+// Filter certain DOM attributes (e.g. src, href) if their values are empty strings.
+
+var enableScopeAPI = false; // Experimental Create Event Handle API.
+
+function isValidElementType(type) {
+  if (typeof type === 'string' || typeof type === 'function') {
+    return true;
+  } // Note: typeof might be other than 'symbol' or 'number' (e.g. if it's a polyfill).
+
+
+  if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || type === REACT_DEBUG_TRACING_MODE_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || type === REACT_LEGACY_HIDDEN_TYPE || enableScopeAPI ) {
+    return true;
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_BLOCK_TYPE || type[0] === REACT_SERVER_BLOCK_TYPE) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function typeOf(object) {
+  if (typeof object === 'object' && object !== null) {
+    var $$typeof = object.$$typeof;
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        var type = object.type;
+
+        switch (type) {
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+          case REACT_SUSPENSE_LIST_TYPE:
+            return type;
+
+          default:
+            var $$typeofType = type && type.$$typeof;
+
+            switch ($$typeofType) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+              case REACT_PROVIDER_TYPE:
+                return $$typeofType;
+
+              default:
+                return $$typeof;
+            }
+
+        }
+
+      case REACT_PORTAL_TYPE:
+        return $$typeof;
+    }
+  }
+
+  return undefined;
+}
+var ContextConsumer = REACT_CONTEXT_TYPE;
+var ContextProvider = REACT_PROVIDER_TYPE;
+var Element = REACT_ELEMENT_TYPE;
+var ForwardRef = REACT_FORWARD_REF_TYPE;
+var Fragment = REACT_FRAGMENT_TYPE;
+var Lazy = REACT_LAZY_TYPE;
+var Memo = REACT_MEMO_TYPE;
+var Portal = REACT_PORTAL_TYPE;
+var Profiler = REACT_PROFILER_TYPE;
+var StrictMode = REACT_STRICT_MODE_TYPE;
+var Suspense = REACT_SUSPENSE_TYPE;
+var hasWarnedAboutDeprecatedIsAsyncMode = false;
+var hasWarnedAboutDeprecatedIsConcurrentMode = false; // AsyncMode should be deprecated
+
+function isAsyncMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isConcurrentMode(object) {
+  {
+    if (!hasWarnedAboutDeprecatedIsConcurrentMode) {
+      hasWarnedAboutDeprecatedIsConcurrentMode = true; // Using console['warn'] to evade Babel and ESLint
+
+      console['warn']('The ReactIs.isConcurrentMode() alias has been deprecated, ' + 'and will be removed in React 18+.');
+    }
+  }
+
+  return false;
+}
+function isContextConsumer(object) {
+  return typeOf(object) === REACT_CONTEXT_TYPE;
+}
+function isContextProvider(object) {
+  return typeOf(object) === REACT_PROVIDER_TYPE;
+}
+function isElement(object) {
+  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+}
+function isForwardRef(object) {
+  return typeOf(object) === REACT_FORWARD_REF_TYPE;
+}
+function isFragment(object) {
+  return typeOf(object) === REACT_FRAGMENT_TYPE;
+}
+function isLazy(object) {
+  return typeOf(object) === REACT_LAZY_TYPE;
+}
+function isMemo(object) {
+  return typeOf(object) === REACT_MEMO_TYPE;
+}
+function isPortal(object) {
+  return typeOf(object) === REACT_PORTAL_TYPE;
+}
+function isProfiler(object) {
+  return typeOf(object) === REACT_PROFILER_TYPE;
+}
+function isStrictMode(object) {
+  return typeOf(object) === REACT_STRICT_MODE_TYPE;
+}
+function isSuspense(object) {
+  return typeOf(object) === REACT_SUSPENSE_TYPE;
+}
+
+reactIs_development.ContextConsumer = ContextConsumer;
+reactIs_development.ContextProvider = ContextProvider;
+reactIs_development.Element = Element;
+reactIs_development.ForwardRef = ForwardRef;
+reactIs_development.Fragment = Fragment;
+reactIs_development.Lazy = Lazy;
+reactIs_development.Memo = Memo;
+reactIs_development.Portal = Portal;
+reactIs_development.Profiler = Profiler;
+reactIs_development.StrictMode = StrictMode;
+reactIs_development.Suspense = Suspense;
+reactIs_development.isAsyncMode = isAsyncMode;
+reactIs_development.isConcurrentMode = isConcurrentMode;
+reactIs_development.isContextConsumer = isContextConsumer;
+reactIs_development.isContextProvider = isContextProvider;
+reactIs_development.isElement = isElement;
+reactIs_development.isForwardRef = isForwardRef;
+reactIs_development.isFragment = isFragment;
+reactIs_development.isLazy = isLazy;
+reactIs_development.isMemo = isMemo;
+reactIs_development.isPortal = isPortal;
+reactIs_development.isProfiler = isProfiler;
+reactIs_development.isStrictMode = isStrictMode;
+reactIs_development.isSuspense = isSuspense;
+reactIs_development.isValidElementType = isValidElementType;
+reactIs_development.typeOf = typeOf;
+  })();
+}
+
+if (process.env.NODE_ENV === 'production') {
+  reactIs.exports = reactIs_production_min;
+} else {
+  reactIs.exports = reactIs_development;
+}
+
+Object.defineProperty(ReactElement$1, '__esModule', {
+  value: true
+});
+ReactElement$1.default = ReactElement$1.test = ReactElement$1.serialize = void 0;
+
+var ReactIs = _interopRequireWildcard(reactIs.exports);
+
+var _markup$1 = markup;
+
+function _getRequireWildcardCache(nodeInterop) {
+  if (typeof WeakMap !== 'function') return null;
+  var cacheBabelInterop = new WeakMap();
+  var cacheNodeInterop = new WeakMap();
+  return (_getRequireWildcardCache = function (nodeInterop) {
+    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+  })(nodeInterop);
+}
+
+function _interopRequireWildcard(obj, nodeInterop) {
+  if (!nodeInterop && obj && obj.__esModule) {
+    return obj;
+  }
+  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
+    return {default: obj};
+  }
+  var cache = _getRequireWildcardCache(nodeInterop);
+  if (cache && cache.has(obj)) {
+    return cache.get(obj);
+  }
+  var newObj = {};
+  var hasPropertyDescriptor =
+    Object.defineProperty && Object.getOwnPropertyDescriptor;
+  for (var key in obj) {
+    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
+      var desc = hasPropertyDescriptor
+        ? Object.getOwnPropertyDescriptor(obj, key)
+        : null;
+      if (desc && (desc.get || desc.set)) {
+        Object.defineProperty(newObj, key, desc);
+      } else {
+        newObj[key] = obj[key];
+      }
+    }
+  }
+  newObj.default = obj;
+  if (cache) {
+    cache.set(obj, newObj);
+  }
+  return newObj;
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+// Given element.props.children, or subtree during recursive traversal,
+// return flattened array of children.
+const getChildren = (arg, children = []) => {
+  if (Array.isArray(arg)) {
+    arg.forEach(item => {
+      getChildren(item, children);
+    });
+  } else if (arg != null && arg !== false) {
+    children.push(arg);
+  }
+
+  return children;
+};
+
+const getType = element => {
+  const type = element.type;
+
+  if (typeof type === 'string') {
+    return type;
+  }
+
+  if (typeof type === 'function') {
+    return type.displayName || type.name || 'Unknown';
+  }
+
+  if (ReactIs.isFragment(element)) {
+    return 'React.Fragment';
+  }
+
+  if (ReactIs.isSuspense(element)) {
+    return 'React.Suspense';
+  }
+
+  if (typeof type === 'object' && type !== null) {
+    if (ReactIs.isContextProvider(element)) {
+      return 'Context.Provider';
+    }
+
+    if (ReactIs.isContextConsumer(element)) {
+      return 'Context.Consumer';
+    }
+
+    if (ReactIs.isForwardRef(element)) {
+      if (type.displayName) {
+        return type.displayName;
+      }
+
+      const functionName = type.render.displayName || type.render.name || '';
+      return functionName !== ''
+        ? 'ForwardRef(' + functionName + ')'
+        : 'ForwardRef';
+    }
+
+    if (ReactIs.isMemo(element)) {
+      const functionName =
+        type.displayName || type.type.displayName || type.type.name || '';
+      return functionName !== '' ? 'Memo(' + functionName + ')' : 'Memo';
+    }
+  }
+
+  return 'UNDEFINED';
+};
+
+const getPropKeys$1 = element => {
+  const {props} = element;
+  return Object.keys(props)
+    .filter(key => key !== 'children' && props[key] !== undefined)
+    .sort();
+};
+
+const serialize$2 = (element, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup$1.printElementAsLeaf)(getType(element), config)
+    : (0, _markup$1.printElement)(
+        getType(element),
+        (0, _markup$1.printProps)(
+          getPropKeys$1(element),
+          element.props,
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        (0, _markup$1.printChildren)(
+          getChildren(element.props.children),
+          config,
+          indentation + config.indent,
+          depth,
+          refs,
+          printer
+        ),
+        config,
+        indentation
+      );
+
+ReactElement$1.serialize = serialize$2;
+
+const test$1 = val => val != null && ReactIs.isElement(val);
+
+ReactElement$1.test = test$1;
+const plugin$1 = {
+  serialize: serialize$2,
+  test: test$1
+};
+var _default$2 = plugin$1;
+ReactElement$1.default = _default$2;
+
+var ReactTestComponent$1 = {};
+
+Object.defineProperty(ReactTestComponent$1, '__esModule', {
+  value: true
+});
+ReactTestComponent$1.default = ReactTestComponent$1.test = ReactTestComponent$1.serialize = void 0;
+
+var _markup = markup;
+
+var global = (function () {
+  if (typeof globalThis !== 'undefined') {
+    return globalThis;
+  } else if (typeof global !== 'undefined') {
+    return global;
+  } else if (typeof self !== 'undefined') {
+    return self;
+  } else if (typeof window !== 'undefined') {
+    return window;
+  } else {
+    return Function('return this')();
+  }
+})();
+
+var Symbol$1 = global['jest-symbol-do-not-touch'] || global.Symbol;
+const testSymbol =
+  typeof Symbol$1 === 'function' && Symbol$1.for
+    ? Symbol$1.for('react.test.json')
+    : 0xea71357;
+
+const getPropKeys = object => {
+  const {props} = object;
+  return props
+    ? Object.keys(props)
+        .filter(key => props[key] !== undefined)
+        .sort()
+    : [];
+};
+
+const serialize$1 = (object, config, indentation, depth, refs, printer) =>
+  ++depth > config.maxDepth
+    ? (0, _markup.printElementAsLeaf)(object.type, config)
+    : (0, _markup.printElement)(
+        object.type,
+        object.props
+          ? (0, _markup.printProps)(
+              getPropKeys(object),
+              object.props,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        object.children
+          ? (0, _markup.printChildren)(
+              object.children,
+              config,
+              indentation + config.indent,
+              depth,
+              refs,
+              printer
+            )
+          : '',
+        config,
+        indentation
+      );
+
+ReactTestComponent$1.serialize = serialize$1;
+
+const test = val => val && val.$$typeof === testSymbol;
+
+ReactTestComponent$1.test = test;
+const plugin = {
+  serialize: serialize$1,
+  test
+};
+var _default$1 = plugin;
+ReactTestComponent$1.default = _default$1;
+
+Object.defineProperty(build, '__esModule', {
+  value: true
+});
+var format_1 = build.format = format;
+build.default = plugins_1 = build.plugins = build.DEFAULT_OPTIONS = void 0;
+
+var _ansiStyles = _interopRequireDefault(ansiStyles.exports);
+
+var _collections = collections;
+
+var _AsymmetricMatcher = _interopRequireDefault(
+  AsymmetricMatcher$1
+);
+
+var _ConvertAnsi = _interopRequireDefault(ConvertAnsi);
+
+var _DOMCollection = _interopRequireDefault(DOMCollection$1);
+
+var _DOMElement = _interopRequireDefault(DOMElement$1);
+
+var _Immutable = _interopRequireDefault(Immutable$1);
+
+var _ReactElement = _interopRequireDefault(ReactElement$1);
+
+var _ReactTestComponent = _interopRequireDefault(
+  ReactTestComponent$1
+);
+
+function _interopRequireDefault(obj) {
+  return obj && obj.__esModule ? obj : {default: obj};
+}
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/* eslint-disable local/ban-types-eventually */
+const toString = Object.prototype.toString;
+const toISOString = Date.prototype.toISOString;
+const errorToString = Error.prototype.toString;
+const regExpToString = RegExp.prototype.toString;
+/**
+ * Explicitly comparing typeof constructor to function avoids undefined as name
+ * when mock identity-obj-proxy returns the key as the value for any key.
+ */
+
+const getConstructorName = val =>
+  (typeof val.constructor === 'function' && val.constructor.name) || 'Object';
+/* global window */
+
+/** Is val is equal to global window object? Works even if it does not exist :) */
+
+const isWindow = val => typeof window !== 'undefined' && val === window;
+
+const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
+const NEWLINE_REGEXP = /\n/gi;
+
+class PrettyFormatPluginError extends Error {
+  constructor(message, stack) {
+    super(message);
+    this.stack = stack;
+    this.name = this.constructor.name;
+  }
+}
+
+function isToStringedArrayType(toStringed) {
+  return (
+    toStringed === '[object Array]' ||
+    toStringed === '[object ArrayBuffer]' ||
+    toStringed === '[object DataView]' ||
+    toStringed === '[object Float32Array]' ||
+    toStringed === '[object Float64Array]' ||
+    toStringed === '[object Int8Array]' ||
+    toStringed === '[object Int16Array]' ||
+    toStringed === '[object Int32Array]' ||
+    toStringed === '[object Uint8Array]' ||
+    toStringed === '[object Uint8ClampedArray]' ||
+    toStringed === '[object Uint16Array]' ||
+    toStringed === '[object Uint32Array]'
+  );
+}
+
+function printNumber(val) {
+  return Object.is(val, -0) ? '-0' : String(val);
+}
+
+function printBigInt(val) {
+  return String(`${val}n`);
+}
+
+function printFunction(val, printFunctionName) {
+  if (!printFunctionName) {
+    return '[Function]';
+  }
+
+  return '[Function ' + (val.name || 'anonymous') + ']';
+}
+
+function printSymbol(val) {
+  return String(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
+}
+
+function printError(val) {
+  return '[' + errorToString.call(val) + ']';
+}
+/**
+ * The first port of call for printing an object, handles most of the
+ * data-types in JS.
+ */
+
+function printBasicValue(val, printFunctionName, escapeRegex, escapeString) {
+  if (val === true || val === false) {
+    return '' + val;
+  }
+
+  if (val === undefined) {
+    return 'undefined';
+  }
+
+  if (val === null) {
+    return 'null';
+  }
+
+  const typeOf = typeof val;
+
+  if (typeOf === 'number') {
+    return printNumber(val);
+  }
+
+  if (typeOf === 'bigint') {
+    return printBigInt(val);
+  }
+
+  if (typeOf === 'string') {
+    if (escapeString) {
+      return '"' + val.replace(/"|\\/g, '\\$&') + '"';
+    }
+
+    return '"' + val + '"';
+  }
+
+  if (typeOf === 'function') {
+    return printFunction(val, printFunctionName);
+  }
+
+  if (typeOf === 'symbol') {
+    return printSymbol(val);
+  }
+
+  const toStringed = toString.call(val);
+
+  if (toStringed === '[object WeakMap]') {
+    return 'WeakMap {}';
+  }
+
+  if (toStringed === '[object WeakSet]') {
+    return 'WeakSet {}';
+  }
+
+  if (
+    toStringed === '[object Function]' ||
+    toStringed === '[object GeneratorFunction]'
+  ) {
+    return printFunction(val, printFunctionName);
+  }
+
+  if (toStringed === '[object Symbol]') {
+    return printSymbol(val);
+  }
+
+  if (toStringed === '[object Date]') {
+    return isNaN(+val) ? 'Date { NaN }' : toISOString.call(val);
+  }
+
+  if (toStringed === '[object Error]') {
+    return printError(val);
+  }
+
+  if (toStringed === '[object RegExp]') {
+    if (escapeRegex) {
+      // https://github.com/benjamingr/RegExp.escape/blob/main/polyfill.js
+      return regExpToString.call(val).replace(/[\\^$*+?.()|[\]{}]/g, '\\$&');
+    }
+
+    return regExpToString.call(val);
+  }
+
+  if (val instanceof Error) {
+    return printError(val);
+  }
+
+  return null;
+}
+/**
+ * Handles more complex objects ( such as objects with circular references.
+ * maps and sets etc )
+ */
+
+function printComplexValue(
+  val,
+  config,
+  indentation,
+  depth,
+  refs,
+  hasCalledToJSON
+) {
+  if (refs.indexOf(val) !== -1) {
+    return '[Circular]';
+  }
+
+  refs = refs.slice();
+  refs.push(val);
+  const hitMaxDepth = ++depth > config.maxDepth;
+  const min = config.min;
+
+  if (
+    config.callToJSON &&
+    !hitMaxDepth &&
+    val.toJSON &&
+    typeof val.toJSON === 'function' &&
+    !hasCalledToJSON
+  ) {
+    return printer(val.toJSON(), config, indentation, depth, refs, true);
+  }
+
+  const toStringed = toString.call(val);
+
+  if (toStringed === '[object Arguments]') {
+    return hitMaxDepth
+      ? '[Arguments]'
+      : (min ? '' : 'Arguments ') +
+          '[' +
+          (0, _collections.printListItems)(
+            val,
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          ']';
+  }
+
+  if (isToStringedArrayType(toStringed)) {
+    return hitMaxDepth
+      ? '[' + val.constructor.name + ']'
+      : (min
+          ? ''
+          : !config.printBasicPrototype && val.constructor.name === 'Array'
+          ? ''
+          : val.constructor.name + ' ') +
+          '[' +
+          (0, _collections.printListItems)(
+            val,
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          ']';
+  }
+
+  if (toStringed === '[object Map]') {
+    return hitMaxDepth
+      ? '[Map]'
+      : 'Map {' +
+          (0, _collections.printIteratorEntries)(
+            val.entries(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer,
+            ' => '
+          ) +
+          '}';
+  }
+
+  if (toStringed === '[object Set]') {
+    return hitMaxDepth
+      ? '[Set]'
+      : 'Set {' +
+          (0, _collections.printIteratorValues)(
+            val.values(),
+            config,
+            indentation,
+            depth,
+            refs,
+            printer
+          ) +
+          '}';
+  } // Avoid failure to serialize global window object in jsdom test environment.
+  // For example, not even relevant if window is prop of React element.
+
+  return hitMaxDepth || isWindow(val)
+    ? '[' + getConstructorName(val) + ']'
+    : (min
+        ? ''
+        : !config.printBasicPrototype && getConstructorName(val) === 'Object'
+        ? ''
+        : getConstructorName(val) + ' ') +
+        '{' +
+        (0, _collections.printObjectProperties)(
+          val,
+          config,
+          indentation,
+          depth,
+          refs,
+          printer
+        ) +
+        '}';
+}
+
+function isNewPlugin(plugin) {
+  return plugin.serialize != null;
+}
+
+function printPlugin(plugin, val, config, indentation, depth, refs) {
+  let printed;
+
+  try {
+    printed = isNewPlugin(plugin)
+      ? plugin.serialize(val, config, indentation, depth, refs, printer)
+      : plugin.print(
+          val,
+          valChild => printer(valChild, config, indentation, depth, refs),
+          str => {
+            const indentationNext = indentation + config.indent;
+            return (
+              indentationNext +
+              str.replace(NEWLINE_REGEXP, '\n' + indentationNext)
+            );
+          },
+          {
+            edgeSpacing: config.spacingOuter,
+            min: config.min,
+            spacing: config.spacingInner
+          },
+          config.colors
+        );
+  } catch (error) {
+    throw new PrettyFormatPluginError(error.message, error.stack);
+  }
+
+  if (typeof printed !== 'string') {
+    throw new Error(
+      `pretty-format: Plugin must return type "string" but instead returned "${typeof printed}".`
+    );
+  }
+
+  return printed;
+}
+
+function findPlugin(plugins, val) {
+  for (let p = 0; p < plugins.length; p++) {
+    try {
+      if (plugins[p].test(val)) {
+        return plugins[p];
+      }
+    } catch (error) {
+      throw new PrettyFormatPluginError(error.message, error.stack);
+    }
+  }
+
+  return null;
+}
+
+function printer(val, config, indentation, depth, refs, hasCalledToJSON) {
+  const plugin = findPlugin(config.plugins, val);
+
+  if (plugin !== null) {
+    return printPlugin(plugin, val, config, indentation, depth, refs);
+  }
+
+  const basicResult = printBasicValue(
+    val,
+    config.printFunctionName,
+    config.escapeRegex,
+    config.escapeString
+  );
+
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  return printComplexValue(
+    val,
+    config,
+    indentation,
+    depth,
+    refs,
+    hasCalledToJSON
+  );
+}
+
+const DEFAULT_THEME = {
+  comment: 'gray',
+  content: 'reset',
+  prop: 'yellow',
+  tag: 'cyan',
+  value: 'green'
+};
+const DEFAULT_THEME_KEYS = Object.keys(DEFAULT_THEME);
+const DEFAULT_OPTIONS = {
+  callToJSON: true,
+  compareKeys: undefined,
+  escapeRegex: false,
+  escapeString: true,
+  highlight: false,
+  indent: 2,
+  maxDepth: Infinity,
+  min: false,
+  plugins: [],
+  printBasicPrototype: true,
+  printFunctionName: true,
+  theme: DEFAULT_THEME
+};
+build.DEFAULT_OPTIONS = DEFAULT_OPTIONS;
+
+function validateOptions(options) {
+  Object.keys(options).forEach(key => {
+    if (!DEFAULT_OPTIONS.hasOwnProperty(key)) {
+      throw new Error(`pretty-format: Unknown option "${key}".`);
+    }
+  });
+
+  if (options.min && options.indent !== undefined && options.indent !== 0) {
+    throw new Error(
+      'pretty-format: Options "min" and "indent" cannot be used together.'
+    );
+  }
+
+  if (options.theme !== undefined) {
+    if (options.theme === null) {
+      throw new Error(`pretty-format: Option "theme" must not be null.`);
+    }
+
+    if (typeof options.theme !== 'object') {
+      throw new Error(
+        `pretty-format: Option "theme" must be of type "object" but instead received "${typeof options.theme}".`
+      );
+    }
+  }
+}
+
+const getColorsHighlight = options =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    const value =
+      options.theme && options.theme[key] !== undefined
+        ? options.theme[key]
+        : DEFAULT_THEME[key];
+    const color = value && _ansiStyles.default[value];
+
+    if (
+      color &&
+      typeof color.close === 'string' &&
+      typeof color.open === 'string'
+    ) {
+      colors[key] = color;
+    } else {
+      throw new Error(
+        `pretty-format: Option "theme" has a key "${key}" whose value "${value}" is undefined in ansi-styles.`
+      );
+    }
+
+    return colors;
+  }, Object.create(null));
+
+const getColorsEmpty = () =>
+  DEFAULT_THEME_KEYS.reduce((colors, key) => {
+    colors[key] = {
+      close: '',
+      open: ''
+    };
+    return colors;
+  }, Object.create(null));
+
+const getPrintFunctionName = options =>
+  options && options.printFunctionName !== undefined
+    ? options.printFunctionName
+    : DEFAULT_OPTIONS.printFunctionName;
+
+const getEscapeRegex = options =>
+  options && options.escapeRegex !== undefined
+    ? options.escapeRegex
+    : DEFAULT_OPTIONS.escapeRegex;
+
+const getEscapeString = options =>
+  options && options.escapeString !== undefined
+    ? options.escapeString
+    : DEFAULT_OPTIONS.escapeString;
+
+const getConfig = options => {
+  var _options$printBasicPr;
+
+  return {
+    callToJSON:
+      options && options.callToJSON !== undefined
+        ? options.callToJSON
+        : DEFAULT_OPTIONS.callToJSON,
+    colors:
+      options && options.highlight
+        ? getColorsHighlight(options)
+        : getColorsEmpty(),
+    compareKeys:
+      options && typeof options.compareKeys === 'function'
+        ? options.compareKeys
+        : DEFAULT_OPTIONS.compareKeys,
+    escapeRegex: getEscapeRegex(options),
+    escapeString: getEscapeString(options),
+    indent:
+      options && options.min
+        ? ''
+        : createIndent(
+            options && options.indent !== undefined
+              ? options.indent
+              : DEFAULT_OPTIONS.indent
+          ),
+    maxDepth:
+      options && options.maxDepth !== undefined
+        ? options.maxDepth
+        : DEFAULT_OPTIONS.maxDepth,
+    min:
+      options && options.min !== undefined ? options.min : DEFAULT_OPTIONS.min,
+    plugins:
+      options && options.plugins !== undefined
+        ? options.plugins
+        : DEFAULT_OPTIONS.plugins,
+    printBasicPrototype:
+      (_options$printBasicPr =
+        options === null || options === void 0
+          ? void 0
+          : options.printBasicPrototype) !== null &&
+      _options$printBasicPr !== void 0
+        ? _options$printBasicPr
+        : true,
+    printFunctionName: getPrintFunctionName(options),
+    spacingInner: options && options.min ? ' ' : '\n',
+    spacingOuter: options && options.min ? '' : '\n'
+  };
+};
+
+function createIndent(indent) {
+  return new Array(indent + 1).join(' ');
+}
+/**
+ * Returns a presentation string of your `val` object
+ * @param val any potential JavaScript object
+ * @param options Custom settings
+ */
+
+function format(val, options) {
+  if (options) {
+    validateOptions(options);
+
+    if (options.plugins) {
+      const plugin = findPlugin(options.plugins, val);
+
+      if (plugin !== null) {
+        return printPlugin(plugin, val, getConfig(options), '', 0, []);
+      }
+    }
+  }
+
+  const basicResult = printBasicValue(
+    val,
+    getPrintFunctionName(options),
+    getEscapeRegex(options),
+    getEscapeString(options)
+  );
+
+  if (basicResult !== null) {
+    return basicResult;
+  }
+
+  return printComplexValue(val, getConfig(options), '', 0, []);
+}
+
+const plugins = {
+  AsymmetricMatcher: _AsymmetricMatcher.default,
+  ConvertAnsi: _ConvertAnsi.default,
+  DOMCollection: _DOMCollection.default,
+  DOMElement: _DOMElement.default,
+  Immutable: _Immutable.default,
+  ReactElement: _ReactElement.default,
+  ReactTestComponent: _ReactTestComponent.default
+};
+var plugins_1 = build.plugins = plugins;
+var _default = format;
+build.default = _default;
+
+const {
+  DOMCollection,
+  DOMElement,
+  Immutable,
+  ReactElement,
+  ReactTestComponent,
+  AsymmetricMatcher
+} = plugins_1;
+let PLUGINS = [
+  ReactTestComponent,
+  ReactElement,
+  DOMElement,
+  DOMCollection,
+  Immutable,
+  AsymmetricMatcher
+];
+const getSerializers = () => PLUGINS;
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+const SNAPSHOT_VERSION = "1";
+const writeSnapshotVersion = () => `// Vitest Snapshot v${SNAPSHOT_VERSION}`;
+const testNameToKey = (testName, count) => `${testName} ${count}`;
+const keyToTestName = (key) => {
+  if (!/ \d+$/.test(key))
+    throw new Error("Snapshot keys must end with a number.");
+  return key.replace(/ \d+$/, "");
+};
+const getSnapshotData = (snapshotPath, update) => {
+  const data = Object.create(null);
+  let snapshotContents = "";
+  let dirty = false;
+  if (fs.existsSync(snapshotPath)) {
+    try {
+      snapshotContents = fs.readFileSync(snapshotPath, "utf8");
+      const populate = new Function("exports", snapshotContents);
+      populate(data);
+    } catch {
+    }
+  }
+  const isInvalid = snapshotContents;
+  if ((update === "all" || update === "new") && isInvalid)
+    dirty = true;
+  return { data, dirty };
+};
+const addExtraLineBreaks = (string) => string.includes("\n") ? `
+${string}
+` : string;
+const removeExtraLineBreaks = (string) => string.length > 2 && string.startsWith("\n") && string.endsWith("\n") ? string.slice(1, -1) : string;
+const escapeRegex = true;
+const printFunctionName = false;
+function serialize(val, indent = 2, formatOverrides = {}) {
+  return normalizeNewlines(format_1(val, __spreadValues({
+    escapeRegex,
+    indent,
+    plugins: getSerializers(),
+    printFunctionName
+  }, formatOverrides)));
+}
+function escapeBacktickString(str) {
+  return str.replace(/`|\\|\${/g, "\\$&");
+}
+function printBacktickString(str) {
+  return `\`${escapeBacktickString(str)}\``;
+}
+function ensureDirectoryExists(filePath) {
+  try {
+    fs.mkdirSync(path.join(path.dirname(filePath)), { recursive: true });
+  } catch {
+  }
+}
+function normalizeNewlines(string) {
+  return string.replace(/\r\n|\r/g, "\n");
+}
+function saveSnapshotFile(snapshotData, snapshotPath) {
+  const snapshots = Object.keys(snapshotData).sort(naturalCompare$1).map((key) => `exports[${printBacktickString(key)}] = ${printBacktickString(normalizeNewlines(snapshotData[key]))};`);
+  ensureDirectoryExists(snapshotPath);
+  fs.writeFileSync(snapshotPath, `${writeSnapshotVersion()}
+
+${snapshots.join("\n\n")}
+`);
+}
+
+class SnapshotState {
+  constructor(snapshotPath, options) {
+    this._snapshotPath = snapshotPath;
+    const { data, dirty } = getSnapshotData(this._snapshotPath, options.updateSnapshot);
+    this._initialData = data;
+    this._snapshotData = data;
+    this._dirty = dirty;
+    this._uncheckedKeys = new Set(Object.keys(this._snapshotData));
+    this._counters = new Map();
+    this._index = 0;
+    this.expand = options.expand || false;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this._updateSnapshot = options.updateSnapshot;
+    this.updated = 0;
+    this._snapshotFormat = options.snapshotFormat || {};
+  }
+  markSnapshotsAsCheckedForTest(testName) {
+    this._uncheckedKeys.forEach((uncheckedKey) => {
+      if (keyToTestName(uncheckedKey) === testName)
+        this._uncheckedKeys.delete(uncheckedKey);
+    });
+  }
+  _addSnapshot(key, receivedSerialized, options) {
+    this._dirty = true;
+    this._snapshotData[key] = receivedSerialized;
+  }
+  clear() {
+    this._snapshotData = this._initialData;
+    this._counters = new Map();
+    this._index = 0;
+    this.added = 0;
+    this.matched = 0;
+    this.unmatched = 0;
+    this.updated = 0;
+  }
+  save() {
+    const hasExternalSnapshots = Object.keys(this._snapshotData).length;
+    const isEmpty = !hasExternalSnapshots;
+    const status = {
+      deleted: false,
+      saved: false
+    };
+    if ((this._dirty || this._uncheckedKeys.size) && !isEmpty) {
+      if (hasExternalSnapshots)
+        saveSnapshotFile(this._snapshotData, this._snapshotPath);
+      status.saved = true;
+    } else if (!hasExternalSnapshots && fs.existsSync(this._snapshotPath)) {
+      if (this._updateSnapshot === "all")
+        fs.unlinkSync(this._snapshotPath);
+      status.deleted = true;
+    }
+    return status;
+  }
+  getUncheckedCount() {
+    return this._uncheckedKeys.size || 0;
+  }
+  getUncheckedKeys() {
+    return Array.from(this._uncheckedKeys);
+  }
+  removeUncheckedKeys() {
+    if (this._updateSnapshot === "all" && this._uncheckedKeys.size) {
+      this._dirty = true;
+      this._uncheckedKeys.forEach((key) => delete this._snapshotData[key]);
+      this._uncheckedKeys.clear();
+    }
+  }
+  match({
+    testName,
+    received,
+    key,
+    inlineSnapshot,
+    isInline,
+    error
+  }) {
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+    const count = Number(this._counters.get(testName));
+    if (!key)
+      key = testNameToKey(testName, count);
+    if (!(isInline && this._snapshotData[key] !== void 0))
+      this._uncheckedKeys.delete(key);
+    const receivedSerialized = addExtraLineBreaks(serialize(received, void 0, this._snapshotFormat));
+    const expected = isInline ? inlineSnapshot : this._snapshotData[key];
+    const pass = expected === receivedSerialized;
+    const hasSnapshot = expected !== void 0;
+    const snapshotIsPersisted = isInline || fs.existsSync(this._snapshotPath);
+    if (pass && !isInline) {
+      this._snapshotData[key] = receivedSerialized;
+    }
+    if (hasSnapshot && this._updateSnapshot === "all" || (!hasSnapshot || !snapshotIsPersisted) && (this._updateSnapshot === "new" || this._updateSnapshot === "all")) {
+      if (this._updateSnapshot === "all") {
+        if (!pass) {
+          if (hasSnapshot)
+            this.updated++;
+          else
+            this.added++;
+          this._addSnapshot(key, receivedSerialized, { error, isInline });
+        } else {
+          this.matched++;
+        }
+      } else {
+        this._addSnapshot(key, receivedSerialized, { error, isInline });
+        this.added++;
+      }
+      return {
+        actual: "",
+        count,
+        expected: "",
+        key,
+        pass: true
+      };
+    } else {
+      if (!pass) {
+        this.unmatched++;
+        return {
+          actual: removeExtraLineBreaks(receivedSerialized),
+          count,
+          expected: expected !== void 0 ? removeExtraLineBreaks(expected) : void 0,
+          key,
+          pass: false
+        };
+      } else {
+        this.matched++;
+        return {
+          actual: "",
+          count,
+          expected: "",
+          key,
+          pass: true
+        };
+      }
+    }
+  }
+  fail(testName, _received, key) {
+    this._counters.set(testName, (this._counters.get(testName) || 0) + 1);
+    const count = Number(this._counters.get(testName));
+    if (!key)
+      key = testNameToKey(testName, count);
+    this._uncheckedKeys.delete(key);
+    this.unmatched++;
+    return key;
+  }
+}
+
+const resolveSnapshotPath = (testPath) => path.join(path.join(path.dirname(testPath), "__snapshots__"), `${path.basename(testPath)}.snap`);
+class SnapshotClient {
+  constructor() {
+    this.testFile = "";
+  }
+  setTest(test) {
+    this.test = test;
+    if (this.testFile !== this.test.file.filepath) {
+      if (this.snapshotState)
+        this.saveSnap();
+      this.testFile = this.test.file.filepath;
+      this.snapshotState = new SnapshotState(resolveSnapshotPath(this.testFile), process.__vitest_worker__.config.snapshotOptions);
+    }
+  }
+  clearTest() {
+    this.test = void 0;
+  }
+  assert(received, message) {
+    if (!this.test)
+      throw new Error("Snapshot can't not be used outside of test");
+    const { actual, expected, key, pass } = this.snapshotState.match({
+      testName: getNames(this.test).slice(1).join(" > "),
+      received,
+      isInline: false
+    });
+    if (!pass) {
+      expect(actual.trim()).equals(expected ? expected.trim() : "", message || `Snapshot name: \`${key}\``);
+    }
+  }
+  async saveSnap() {
+    if (!this.testFile || !this.snapshotState)
+      return;
+    const result = packSnapshotState(this.testFile, this.snapshotState);
+    await rpc("snapshotSaved", result);
+    this.testFile = "";
+    this.snapshotState = void 0;
+  }
+}
+function packSnapshotState(filepath, state) {
+  const snapshot = {
+    filepath,
+    added: 0,
+    fileDeleted: false,
+    matched: 0,
+    unchecked: 0,
+    uncheckedKeys: [],
+    unmatched: 0,
+    updated: 0
+  };
+  const uncheckedCount = state.getUncheckedCount();
+  const uncheckedKeys = state.getUncheckedKeys();
+  if (uncheckedCount)
+    state.removeUncheckedKeys();
+  const status = state.save();
+  snapshot.fileDeleted = status.deleted;
+  snapshot.added = state.added;
+  snapshot.matched = state.matched;
+  snapshot.unmatched = state.unmatched;
+  snapshot.updated = state.updated;
+  snapshot.unchecked = !status.deleted ? uncheckedCount : 0;
+  snapshot.uncheckedKeys = Array.from(uncheckedKeys);
+  return snapshot;
+}
+
+let _client;
+function getSnapshotClient() {
+  if (!_client)
+    _client = new SnapshotClient();
+  return _client;
+}
+function SnapshotPlugin() {
+  return function(chai, utils) {
+    for (const key of ["matchSnapshot", "toMatchSnapshot"]) {
+      utils.addMethod(chai.Assertion.prototype, key, function(message) {
+        const expected = utils.flag(this, "object");
+        getSnapshotClient().assert(expected, message);
+      });
+    }
+  };
+}
+
+function JestChaiExpect() {
+  return (chai, utils) => {
+    function def(name, fn) {
+      const addMethod = (n) => {
+        utils.addMethod(chai.Assertion.prototype, n, fn);
+      };
+      if (Array.isArray(name))
+        name.forEach((n) => addMethod(n));
+      else
+        addMethod(name);
+    }
+    def("toEqual", function(expected) {
+      return this.eql(expected);
+    });
+    def("toStrictEqual", function(expected) {
+      return this.equal(expected);
+    });
+    def("toBe", function(expected) {
+      return this.equal(expected);
+    });
+    def("toMatchObject", function(expected) {
+      return this.containSubset(expected);
+    });
+    def("toMatch", function(expected) {
+      if (typeof expected === "string")
+        return this.include(expected);
+      else
+        return this.match(expected);
+    });
+    def("toContain", function(item) {
+      return this.contain(item);
+    });
+    def("toContainEqual", function(expected) {
+      const obj = utils.flag(this, "object");
+      const index = Array.from(obj).findIndex((item) => {
+        try {
+          chai.assert.deepEqual(item, expected);
+        } catch {
+          return false;
+        }
+        return true;
+      });
+      this.assert(index !== -1, "expected #{this} to deep equally contain #{exp}", "expected #{this} to not deep equally contain #{exp}", expected);
+    });
+    def("toBeTruthy", function() {
+      const obj = utils.flag(this, "object");
+      this.assert(Boolean(obj), "expected #{this} to be truthy", "expected #{this} to not be truthy", obj);
+    });
+    def("toBeFalsy", function() {
+      const obj = utils.flag(this, "object");
+      this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", obj);
+    });
+    def("toBeGreaterThan", function(expected) {
+      return this.to.greaterThan(expected);
+    });
+    def("toBeGreaterThanOrEqual", function(expected) {
+      return this.to.greaterThanOrEqual(expected);
+    });
+    def("toBeLessThan", function(expected) {
+      return this.to.lessThan(expected);
+    });
+    def("toBeLessThanOrEqual", function(expected) {
+      return this.to.lessThanOrEqual(expected);
+    });
+    def("toBeNaN", function() {
+      return this.be.NaN;
+    });
+    def("toBeUndefined", function() {
+      return this.be.undefined;
+    });
+    def("toBeNull", function() {
+      return this.be.null;
+    });
+    def("toBeDefined", function() {
+      return this.not.be.undefined;
+    });
+    def("toBeInstanceOf", function(obj) {
+      return this.instanceOf(obj);
+    });
+    def("toHaveLength", function(length) {
+      return this.have.length(length);
+    });
+    def("toBeCloseTo", function(number, numDigits = 2) {
+      utils.expectTypes(this, ["number"]);
+      return this.closeTo(number, numDigits);
+    });
+    function isSpy(putativeSpy) {
+      return typeof putativeSpy === "function" && typeof putativeSpy.getCall === "function" && typeof putativeSpy.calledWithExactly === "function";
+    }
+    function isCall(putativeCall) {
+      return putativeCall && isSpy(putativeCall.proxy);
+    }
+    const assertIsMock = (assertion) => {
+      if (!isSpy(assertion._obj) && !isCall(assertion._obj))
+        throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+    };
+    def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
+      assertIsMock(this);
+      return this.callCount(number);
+    });
+    def("toHaveBeenCalledOnce", function() {
+      assertIsMock(this);
+      return this.callCount(1);
+    });
+    def(["toHaveBeenCalled", "toBeCalled"], function() {
+      assertIsMock(this);
+      return this.called;
+    });
+    def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
+      assertIsMock(this);
+      return this.calledWith(...args);
+    });
+    const ordinalOf = (i) => {
+      const j = i % 10;
+      const k = i % 100;
+      if (j === 1 && k !== 11)
+        return `${i}st`;
+      if (j === 2 && k !== 12)
+        return `${i}nd`;
+      if (j === 3 && k !== 13)
+        return `${i}rd`;
+      return `${i}th`;
+    };
+    def(["toHaveBeenNthCalledWith", "nthCalledWith"], function(times, ...args) {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const nthCall = spy.getCall(times - 1);
+      this.assert(nthCall.calledWith(...args), `expected ${ordinalOf(times)} spy call to have been called with #{exp}`, `expected ${ordinalOf(times)} spy call not to have been called with #{exp}`, args, nthCall.args);
+    });
+    def(["toHaveBeenLastCalledWith", "lastCalledWith"], function(...args) {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const lastCall = spy.getCall(spy.returnValues.length - 1);
+      this.assert(lastCall.calledWith(...args), "expected last spy call to have been called with #{exp}", "expected last spy call not to have been called with #{exp}", args, lastCall.args);
+    });
+    def(["toThrow", "toThrowError"], function(expected) {
+      const negate = utils.flag(this, "negate");
+      if (negate)
+        this.not.to.throw(expected);
+      else
+        this.to.throw(expected);
+    });
+    def(["toHaveReturned", "toReturn"], function() {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const calledAndNotThrew = spy.called && !spy.alwaysThrew();
+      this.assert(calledAndNotThrew, "expected spy to be successfully called at least once", "expected spy not to be successfully called", calledAndNotThrew, !calledAndNotThrew);
+    });
+    def(["toHaveReturnedTimes", "toReturnTimes"], function(times) {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const successfullReturns = spy.getCalls().reduce((success, call) => call.threw() ? success : ++success, 0);
+      this.assert(successfullReturns === times, `expected spy to be successfully called ${times} times`, `expected spy not to be successfully called ${times} times`, `expected number of returns: ${times}`, `recieved number of returns: ${successfullReturns}`);
+    });
+    def(["toHaveReturnedWith", "toReturnWith"], function(value) {
+      assertIsMock(this);
+      return this.returned(value);
+    });
+    def(["toHaveLastReturnedWith", "lastReturnedWith"], function(value) {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const lastReturn = spy.lastCall.returned(value);
+      this.assert(lastReturn, "expected last spy call to return #{exp}", "expected last spy call not to return #{exp}", value, spy.lastCall.returnValue);
+    });
+    def(["toHaveNthReturnedWith", "nthReturnedWith"], function(nthCall, value) {
+      assertIsMock(this);
+      const spy = utils.flag(this, "object");
+      const isNot = utils.flag(this, "negate");
+      const call = spy.getCall(nthCall - 1);
+      const ordinalCall = `${ordinalOf(nthCall)} call`;
+      if (!isNot && call.threw())
+        chai.assert.fail(`expected ${ordinalCall} to return #{exp}, but instead it threw an error`);
+      const nthCallReturn = call.returned(value);
+      this.assert(nthCallReturn, `expected ${ordinalCall} spy call to return #{exp}`, `expected ${ordinalCall} spy call not to return #{exp}`, value, call.returnValue);
+    });
+  };
+}
+
+let installed = false;
+async function setupChai() {
+  if (installed)
+    return;
+  chai.use(SinonChai);
+  chai.use(JestChaiExpect());
+  chai.use(Subset);
+  chai.use(SnapshotPlugin());
+  installed = true;
+}
+
+async function setupGlobalEnv(config) {
+  await setupChai();
+  if (config.global)
+    (await import('./global-e40b54d6.js')).registerApiGlobally();
+}
+async function withEnv(name, fn) {
+  const env = await environments[name].setup(globalThis);
+  try {
+    await fn();
+  } finally {
+    await env.teardown(globalThis);
+  }
+}
+
+function processError(err) {
+  if (!err)
+    return err;
+  if (err.stack)
+    err.stackStr = String(err.stack);
+  if (err.name)
+    err.nameStr = String(err.name);
+  return err;
+}
+
+async function collectTests(paths) {
+  const files = [];
+  for (const filepath of paths) {
+    const file = {
+      id: nanoid(),
+      name: basename(filepath),
+      type: "suite",
+      mode: "run",
+      computeMode: "serial",
+      filepath,
+      tasks: []
+    };
+    setHooks(file, createSuiteHooks());
+    clearContext();
+    try {
+      await import(filepath);
+      for (const c of [defaultSuite, ...context.tasks]) {
+        if (c.type === "test") {
+          file.tasks.push(c);
+        } else {
+          const suite = await c.collect(file);
+          if (suite.name || suite.tasks.length)
+            file.tasks.push(suite);
+        }
+      }
+    } catch (e) {
+      file.result = {
+        start: performance.now(),
+        state: "fail",
+        error: processError(e)
+      };
+      process.stdout.write("\0");
+    }
+    files.push(file);
+  }
+  const tasks = files.reduce((tasks2, file) => tasks2.concat(file.tasks), []);
+  interpretOnlyMode(tasks);
+  tasks.forEach((i) => {
+    if (i.type === "suite") {
+      if (i.mode === "skip")
+        i.tasks.forEach((c) => c.mode === "run" && (c.mode = "skip"));
+      else
+        interpretOnlyMode(i.tasks);
+    }
+  });
+  return files;
+}
+
+async function callHook(suite, name, args) {
+  await Promise.all(getHooks(suite)[name].map((fn) => fn(...args)));
+}
+function updateTask(task) {
+  return rpc("onTaskUpdate", [task.id, task.result]);
+}
+async function runTest(test) {
+  if (test.mode !== "run")
+    return;
+  test.result = {
+    start: performance.now(),
+    state: "run"
+  };
+  updateTask(test);
+  getSnapshotClient().setTest(test);
+  try {
+    await callHook(test.suite, "beforeEach", [test, test.suite]);
+    await getFn(test)();
+    test.result.state = "pass";
+  } catch (e) {
+    test.result.state = "fail";
+    test.result.error = processError(e);
+  }
+  try {
+    await callHook(test.suite, "afterEach", [test, test.suite]);
+  } catch (e) {
+    test.result.state = "fail";
+    test.result.error = processError(e);
+  }
+  getSnapshotClient().clearTest();
+  test.result.end = performance.now();
+  updateTask(test);
+}
+async function runSuite(suite) {
+  var _a;
+  if (((_a = suite.result) == null ? void 0 : _a.state) === "fail")
+    return;
+  suite.result = {
+    start: performance.now(),
+    state: "run"
+  };
+  updateTask(suite);
+  if (suite.mode === "skip") {
+    suite.result.state = "skip";
+  } else if (suite.mode === "todo") {
+    suite.result.state = "todo";
+  } else {
+    try {
+      await callHook(suite, "beforeAll", [suite]);
+      for (const tasksGroup of partitionSuiteChildren(suite)) {
+        const computeMode = tasksGroup[0].computeMode;
+        if (computeMode === "serial") {
+          for (const c of tasksGroup)
+            await runSuiteChild(c);
+        } else if (computeMode === "concurrent") {
+          await Promise.all(tasksGroup.map((c) => runSuiteChild(c)));
+        }
+      }
+      await callHook(suite, "afterAll", [suite]);
+    } catch (e) {
+      suite.result.state = "fail";
+      suite.result.error = processError(e);
+    }
+  }
+  suite.result.end = performance.now();
+  if (suite.mode === "run") {
+    if (!hasTests(suite)) {
+      suite.result.state = "fail";
+      if (!suite.result.error)
+        suite.result.error = new Error(`No tests found in suite ${suite.name}`);
+    } else if (hasFailed(suite)) {
+      suite.result.state = "fail";
+    } else {
+      suite.result.state = "pass";
+    }
+  }
+  updateTask(suite);
+}
+async function runSuiteChild(c) {
+  return c.type === "test" ? runTest(c) : runSuite(c);
+}
+async function runSuites(suites) {
+  for (const suite of suites)
+    await runSuite(suite);
+}
+async function startTests(paths) {
+  const files = await collectTests(paths);
+  send("onCollected", files);
+  await runSuites(files);
+  await getSnapshotClient().saveSnap();
+}
+
+async function run(files, config) {
+  await setupGlobalEnv(config);
+  await withEnv(config.environment, async () => {
+    await startTests(files);
+  });
+}
+
+export { run };