@manifest-network/manifest-mcp-core 0.1.0

package/dist/node_modules/@vitest/expect/dist/index.js

@@ -0,0 +1,1457 @@
+import { y } from "../../../tinyrainbow/dist/index.js";
+import { stringify } from "../../utils/dist/display.js";
+import { assertTypes, getType, isObject, noop, ordinal } from "../../utils/dist/helpers.js";
+import { diff, printDiffOrStringify } from "../../utils/dist/diff.js";
+import { processError } from "../../utils/dist/error.js";
+import { isMockFunction } from "../../spy/dist/index.js";
+import { use, utils_exports } from "../../../chai/index.js";
+//#region ../../node_modules/@vitest/expect/dist/index.js
+const ChaiStyleAssertions = (chai, utils) => {
+	function defProperty(name, delegateTo) {
+		utils.addProperty(chai.Assertion.prototype, name, function() {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			return jestMethod.call(this);
+		});
+	}
+	function defPropertyWithArgs(name, delegateTo, ...args) {
+		utils.addProperty(chai.Assertion.prototype, name, function() {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			return jestMethod.call(this, ...args);
+		});
+	}
+	function defMethod(name, delegateTo) {
+		utils.addChainableMethod(chai.Assertion.prototype, name, function(...args) {
+			const jestMethod = chai.Assertion.prototype[delegateTo];
+			if (!jestMethod) throw new Error(`Cannot delegate to ${String(delegateTo)}: method not found. Ensure JestChaiExpect plugin is loaded first.`);
+			return jestMethod.call(this, ...args);
+		}, () => {});
+	}
+	defProperty("called", "toHaveBeenCalled");
+	defProperty("calledOnce", "toHaveBeenCalledOnce");
+	defProperty("returned", "toHaveReturned");
+	defPropertyWithArgs("calledTwice", "toHaveBeenCalledTimes", 2);
+	defPropertyWithArgs("calledThrice", "toHaveBeenCalledTimes", 3);
+	defMethod("callCount", "toHaveBeenCalledTimes");
+	defMethod("calledWith", "toHaveBeenCalledWith");
+	defMethod("calledOnceWith", "toHaveBeenCalledExactlyOnceWith");
+	defMethod("lastCalledWith", "toHaveBeenLastCalledWith");
+	defMethod("nthCalledWith", "toHaveBeenNthCalledWith");
+	defMethod("returnedWith", "toHaveReturnedWith");
+	defMethod("returnedTimes", "toHaveReturnedTimes");
+	defMethod("lastReturnedWith", "toHaveLastReturnedWith");
+	defMethod("nthReturnedWith", "toHaveNthReturnedWith");
+	defMethod("calledBefore", "toHaveBeenCalledBefore");
+	defMethod("calledAfter", "toHaveBeenCalledAfter");
+};
+const MATCHERS_OBJECT = Symbol.for("matchers-object");
+const JEST_MATCHERS_OBJECT = Symbol.for("$$jest-matchers-object");
+const GLOBAL_EXPECT = Symbol.for("expect-global");
+const ASYMMETRIC_MATCHERS_OBJECT = Symbol.for("asymmetric-matchers-object");
+const customMatchers = {
+	toSatisfy(actual, expected, message) {
+		const { printReceived, printExpected, matcherHint } = this.utils;
+		const pass = expected(actual);
+		return {
+			pass,
+			message: () => pass ? `\
+${matcherHint(".not.toSatisfy", "received", "")}
+
+Expected value to not satisfy:
+${message || printExpected(expected)}
+Received:
+${printReceived(actual)}` : `\
+${matcherHint(".toSatisfy", "received", "")}
+
+Expected value to satisfy:
+${message || printExpected(expected)}
+
+Received:
+${printReceived(actual)}`
+		};
+	},
+	toBeOneOf(actual, expected) {
+		const { equals, customTesters } = this;
+		const { printReceived, printExpected, matcherHint } = this.utils;
+		let pass;
+		if (Array.isArray(expected)) pass = expected.length === 0 || expected.some((item) => equals(item, actual, customTesters));
+		else if (expected instanceof Set) pass = expected.size === 0 || expected.has(actual) || [...expected].some((item) => equals(item, actual, customTesters));
+		else throw new TypeError(`You must provide an array or set to ${matcherHint(".toBeOneOf")}, not '${typeof expected}'.`);
+		return {
+			pass,
+			message: () => pass ? `\
+${matcherHint(".not.toBeOneOf", "received", "")}
+
+Expected value to not be one of:
+${printExpected(expected)}
+Received:
+${printReceived(actual)}` : `\
+${matcherHint(".toBeOneOf", "received", "")}
+
+Expected value to be one of:
+${printExpected(expected)}
+
+Received:
+${printReceived(actual)}`
+		};
+	}
+};
+const EXPECTED_COLOR = y.green;
+const RECEIVED_COLOR = y.red;
+const INVERTED_COLOR = y.inverse;
+const BOLD_WEIGHT = y.bold;
+const DIM_COLOR = y.dim;
+function matcherHint(matcherName, received = "received", expected = "expected", options = {}) {
+	const { comment = "", isDirectExpectCall = false, isNot = false, promise = "", secondArgument = "", expectedColor = EXPECTED_COLOR, receivedColor = RECEIVED_COLOR, secondArgumentColor = EXPECTED_COLOR } = options;
+	let hint = "";
+	let dimString = "expect";
+	if (!isDirectExpectCall && received !== "") {
+		hint += DIM_COLOR(`${dimString}(`) + receivedColor(received);
+		dimString = ")";
+	}
+	if (promise !== "") {
+		hint += DIM_COLOR(`${dimString}.`) + promise;
+		dimString = "";
+	}
+	if (isNot) {
+		hint += `${DIM_COLOR(`${dimString}.`)}not`;
+		dimString = "";
+	}
+	if (matcherName.includes(".")) dimString += matcherName;
+	else {
+		hint += DIM_COLOR(`${dimString}.`) + matcherName;
+		dimString = "";
+	}
+	if (expected === "") dimString += "()";
+	else {
+		hint += DIM_COLOR(`${dimString}(`) + expectedColor(expected);
+		if (secondArgument) hint += DIM_COLOR(", ") + secondArgumentColor(secondArgument);
+		dimString = ")";
+	}
+	if (comment !== "") dimString += ` // ${comment}`;
+	if (dimString !== "") hint += DIM_COLOR(dimString);
+	return hint;
+}
+const SPACE_SYMBOL = "·";
+function replaceTrailingSpaces(text) {
+	return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+}
+function printReceived(object) {
+	return RECEIVED_COLOR(replaceTrailingSpaces(stringify(object)));
+}
+function printExpected(value) {
+	return EXPECTED_COLOR(replaceTrailingSpaces(stringify(value)));
+}
+function getMatcherUtils() {
+	return {
+		EXPECTED_COLOR,
+		RECEIVED_COLOR,
+		INVERTED_COLOR,
+		BOLD_WEIGHT,
+		DIM_COLOR,
+		diff,
+		matcherHint,
+		printReceived,
+		printExpected,
+		printDiffOrStringify,
+		printWithType
+	};
+}
+function printWithType(name, value, print) {
+	const type = getType(value);
+	return (type !== "null" && type !== "undefined" ? `${name} has type:  ${type}\n` : "") + `${name} has value: ${print(value)}`;
+}
+function addCustomEqualityTesters(newTesters) {
+	if (!Array.isArray(newTesters)) throw new TypeError(`expect.customEqualityTesters: Must be set to an array of Testers. Was given "${getType(newTesters)}"`);
+	globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters.push(...newTesters);
+}
+function getCustomEqualityTesters() {
+	return globalThis[JEST_MATCHERS_OBJECT].customEqualityTesters;
+}
+function equals(a, b, customTesters, strictCheck) {
+	customTesters = customTesters || [];
+	return eq(a, b, [], [], customTesters, strictCheck ? hasKey : hasDefinedKey);
+}
+Function.prototype.toString;
+function isAsymmetric(obj) {
+	return !!obj && typeof obj === "object" && "asymmetricMatch" in obj && isA("Function", obj.asymmetricMatch);
+}
+function asymmetricMatch(a, b, customTesters) {
+	const asymmetricA = isAsymmetric(a);
+	const asymmetricB = isAsymmetric(b);
+	if (asymmetricA && asymmetricB) return;
+	if (asymmetricA) return a.asymmetricMatch(b, customTesters);
+	if (asymmetricB) return b.asymmetricMatch(a, customTesters);
+}
+function isError(value) {
+	if (typeof Error.isError === "function") return Error.isError(value);
+	switch (Object.prototype.toString.call(value)) {
+		case "[object Error]":
+		case "[object Exception]":
+		case "[object DOMException]": return true;
+		default: return value instanceof Error;
+	}
+}
+function eq(a, b, aStack, bStack, customTesters, hasKey) {
+	let result = true;
+	const asymmetricResult = asymmetricMatch(a, b, customTesters);
+	if (asymmetricResult !== void 0) return asymmetricResult;
+	const testerContext = { equals };
+	for (let i = 0; i < customTesters.length; i++) {
+		const customTesterResult = customTesters[i].call(testerContext, a, b, customTesters);
+		if (customTesterResult !== void 0) return customTesterResult;
+	}
+	if (typeof URL === "function" && a instanceof URL && b instanceof URL) return a.href === b.href;
+	if (Object.is(a, b)) return true;
+	if (a === null || b === null) return a === b;
+	const className = Object.prototype.toString.call(a);
+	if (className !== Object.prototype.toString.call(b)) return false;
+	switch (className) {
+		case "[object Boolean]":
+		case "[object String]":
+		case "[object Number]": if (typeof a !== typeof b) return false;
+		else if (typeof a !== "object" && typeof b !== "object") return Object.is(a, b);
+		else return Object.is(a.valueOf(), b.valueOf());
+		case "[object Date]": {
+			const numA = +a;
+			const numB = +b;
+			return numA === numB || Number.isNaN(numA) && Number.isNaN(numB);
+		}
+		case "[object RegExp]": return a.source === b.source && a.flags === b.flags;
+		case "[object Temporal.Instant]":
+		case "[object Temporal.ZonedDateTime]":
+		case "[object Temporal.PlainDateTime]":
+		case "[object Temporal.PlainDate]":
+		case "[object Temporal.PlainTime]":
+		case "[object Temporal.PlainYearMonth]":
+		case "[object Temporal.PlainMonthDay]": return a.equals(b);
+		case "[object Temporal.Duration]": return a.toString() === b.toString();
+	}
+	if (typeof a !== "object" || typeof b !== "object") return false;
+	if (isDomNode(a) && isDomNode(b)) return a.isEqualNode(b);
+	let length = aStack.length;
+	while (length--) if (aStack[length] === a) return bStack[length] === b;
+	else if (bStack[length] === b) return false;
+	aStack.push(a);
+	bStack.push(b);
+	if (className === "[object Array]" && a.length !== b.length) return false;
+	if (isError(a) && isError(b)) try {
+		return isErrorEqual(a, b, aStack, bStack, customTesters, hasKey);
+	} finally {
+		aStack.pop();
+		bStack.pop();
+	}
+	const aKeys = keys(a, hasKey);
+	let key;
+	let size = aKeys.length;
+	if (keys(b, hasKey).length !== size) return false;
+	while (size--) {
+		key = aKeys[size];
+		result = hasKey(b, key) && eq(a[key], b[key], aStack, bStack, customTesters, hasKey);
+		if (!result) return false;
+	}
+	aStack.pop();
+	bStack.pop();
+	return result;
+}
+function isErrorEqual(a, b, aStack, bStack, customTesters, hasKey) {
+	let result = Object.prototype.toString.call(a) === Object.prototype.toString.call(b) && a.name === b.name && a.message === b.message;
+	if (typeof b.cause !== "undefined") result && (result = eq(a.cause, b.cause, aStack, bStack, customTesters, hasKey));
+	if (a instanceof AggregateError && b instanceof AggregateError) result && (result = eq(a.errors, b.errors, aStack, bStack, customTesters, hasKey));
+	result && (result = eq({ ...a }, { ...b }, aStack, bStack, customTesters, hasKey));
+	return result;
+}
+function keys(obj, hasKey) {
+	const keys = [];
+	for (const key in obj) if (hasKey(obj, key)) keys.push(key);
+	return keys.concat(Object.getOwnPropertySymbols(obj).filter((symbol) => Object.getOwnPropertyDescriptor(obj, symbol).enumerable));
+}
+function hasDefinedKey(obj, key) {
+	return hasKey(obj, key) && obj[key] !== void 0;
+}
+function hasKey(obj, key) {
+	return Object.hasOwn(obj, key);
+}
+function isA(typeName, value) {
+	return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
+}
+function isDomNode(obj) {
+	return obj !== null && typeof obj === "object" && "nodeType" in obj && typeof obj.nodeType === "number" && "nodeName" in obj && typeof obj.nodeName === "string" && "isEqualNode" in obj && typeof obj.isEqualNode === "function";
+}
+const IS_KEYED_SENTINEL = "@@__IMMUTABLE_KEYED__@@";
+const IS_SET_SENTINEL = "@@__IMMUTABLE_SET__@@";
+const IS_LIST_SENTINEL = "@@__IMMUTABLE_LIST__@@";
+const IS_ORDERED_SENTINEL = "@@__IMMUTABLE_ORDERED__@@";
+const IS_RECORD_SYMBOL = "@@__IMMUTABLE_RECORD__@@";
+function isImmutableUnorderedKeyed(maybeKeyed) {
+	return !!(maybeKeyed && maybeKeyed[IS_KEYED_SENTINEL] && !maybeKeyed[IS_ORDERED_SENTINEL]);
+}
+function isImmutableUnorderedSet(maybeSet) {
+	return !!(maybeSet && maybeSet[IS_SET_SENTINEL] && !maybeSet[IS_ORDERED_SENTINEL]);
+}
+function isObjectLiteral(source) {
+	return source != null && typeof source === "object" && !Array.isArray(source);
+}
+function isImmutableList(source) {
+	return Boolean(source && isObjectLiteral(source) && source[IS_LIST_SENTINEL]);
+}
+function isImmutableOrderedKeyed(source) {
+	return Boolean(source && isObjectLiteral(source) && source[IS_KEYED_SENTINEL] && source[IS_ORDERED_SENTINEL]);
+}
+function isImmutableOrderedSet(source) {
+	return Boolean(source && isObjectLiteral(source) && source[IS_SET_SENTINEL] && source[IS_ORDERED_SENTINEL]);
+}
+function isImmutableRecord(source) {
+	return Boolean(source && isObjectLiteral(source) && source[IS_RECORD_SYMBOL]);
+}
+/**
+* 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 IteratorSymbol = Symbol.iterator;
+function hasIterator(object) {
+	return !!(object != null && object[IteratorSymbol]);
+}
+function iterableEquality(a, b, customTesters = [], aStack = [], bStack = []) {
+	if (typeof a !== "object" || typeof b !== "object" || Array.isArray(a) || Array.isArray(b) || !hasIterator(a) || !hasIterator(b)) return;
+	if (a.constructor !== b.constructor) return false;
+	let length = aStack.length;
+	while (length--) if (aStack[length] === a) return bStack[length] === b;
+	aStack.push(a);
+	bStack.push(b);
+	const filteredCustomTesters = [...customTesters.filter((t) => t !== iterableEquality), iterableEqualityWithStack];
+	function iterableEqualityWithStack(a, b) {
+		return iterableEquality(a, b, [...customTesters], [...aStack], [...bStack]);
+	}
+	if (a.size !== void 0) {
+		if (a.size !== b.size) return false;
+		else if (isA("Set", a) || isImmutableUnorderedSet(a)) {
+			let allFound = true;
+			for (const aValue of a) if (!b.has(aValue)) {
+				let has = false;
+				for (const bValue of b) if (equals(aValue, bValue, filteredCustomTesters) === true) has = true;
+				if (has === false) {
+					allFound = false;
+					break;
+				}
+			}
+			aStack.pop();
+			bStack.pop();
+			return allFound;
+		} else if (isA("Map", a) || isImmutableUnorderedKeyed(a)) {
+			let allFound = true;
+			for (const aEntry of a) if (!b.has(aEntry[0]) || !equals(aEntry[1], b.get(aEntry[0]), filteredCustomTesters)) {
+				let has = false;
+				for (const bEntry of b) {
+					const matchedKey = equals(aEntry[0], bEntry[0], filteredCustomTesters);
+					let matchedValue = false;
+					if (matchedKey === true) matchedValue = equals(aEntry[1], bEntry[1], filteredCustomTesters);
+					if (matchedValue === true) has = true;
+				}
+				if (has === false) {
+					allFound = false;
+					break;
+				}
+			}
+			aStack.pop();
+			bStack.pop();
+			return allFound;
+		}
+	}
+	const bIterator = b[IteratorSymbol]();
+	for (const aValue of a) {
+		const nextB = bIterator.next();
+		if (nextB.done || !equals(aValue, nextB.value, filteredCustomTesters)) return false;
+	}
+	if (!bIterator.next().done) return false;
+	if (!isImmutableList(a) && !isImmutableOrderedKeyed(a) && !isImmutableOrderedSet(a) && !isImmutableRecord(a)) {
+		if (!equals(Object.entries(a), Object.entries(b), filteredCustomTesters)) return false;
+	}
+	aStack.pop();
+	bStack.pop();
+	return true;
+}
+/**
+* Checks if `hasOwnProperty(object, key)` up the prototype chain, stopping at `Object.prototype`.
+*/
+function hasPropertyInObject(object, key) {
+	if (!object || typeof object !== "object" || object === Object.prototype) return false;
+	return Object.hasOwn(object, key) || hasPropertyInObject(Object.getPrototypeOf(object), key);
+}
+function isObjectWithKeys(a) {
+	return isObject(a) && !isError(a) && !Array.isArray(a) && !(a instanceof Date) && !(a instanceof Set) && !(a instanceof Map);
+}
+function subsetEquality(object, subset, customTesters = []) {
+	const filteredCustomTesters = customTesters.filter((t) => t !== subsetEquality);
+	const subsetEqualityWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object, subset) => {
+		if (!isObjectWithKeys(subset)) return;
+		return Object.keys(subset).every((key) => {
+			if (subset[key] != null && typeof subset[key] === "object") {
+				if (seenReferences.has(subset[key])) return equals(object[key], subset[key], filteredCustomTesters);
+				seenReferences.set(subset[key], true);
+			}
+			const result = object != null && hasPropertyInObject(object, key) && equals(object[key], subset[key], [...filteredCustomTesters, subsetEqualityWithContext(seenReferences)]);
+			seenReferences.delete(subset[key]);
+			return result;
+		});
+	};
+	return subsetEqualityWithContext()(object, subset);
+}
+function typeEquality(a, b) {
+	if (a == null || b == null || a.constructor === b.constructor) return;
+	return false;
+}
+function arrayBufferEquality(a, b) {
+	let dataViewA = a;
+	let dataViewB = b;
+	if (!(a instanceof DataView && b instanceof DataView)) {
+		if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) return;
+		try {
+			dataViewA = new DataView(a);
+			dataViewB = new DataView(b);
+		} catch {
+			return;
+		}
+	}
+	if (dataViewA.byteLength !== dataViewB.byteLength) return false;
+	for (let i = 0; i < dataViewA.byteLength; i++) if (dataViewA.getUint8(i) !== dataViewB.getUint8(i)) return false;
+	return true;
+}
+function sparseArrayEquality(a, b, customTesters = []) {
+	if (!Array.isArray(a) || !Array.isArray(b)) return;
+	const aKeys = Object.keys(a);
+	const bKeys = Object.keys(b);
+	return equals(a, b, customTesters.filter((t) => t !== sparseArrayEquality), true) && equals(aKeys, bKeys);
+}
+function generateToBeMessage(deepEqualityName, expected = "#{this}", actual = "#{exp}") {
+	const toBeMessage = `expected ${expected} to be ${actual} // Object.is equality`;
+	if (["toStrictEqual", "toEqual"].includes(deepEqualityName)) return `${toBeMessage}\n\nIf it should pass with deep equality, replace "toBe" with "${deepEqualityName}"\n\nExpected: ${expected}\nReceived: serializes to the same string\n`;
+	return toBeMessage;
+}
+function pluralize(word, count) {
+	return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+function getObjectKeys(object) {
+	return [...Object.keys(object), ...Object.getOwnPropertySymbols(object).filter((s) => Object.getOwnPropertyDescriptor(object, s)?.enumerable)];
+}
+function getObjectSubset(object, subset, customTesters) {
+	let stripped = 0;
+	const getObjectSubsetWithContext = (seenReferences = /* @__PURE__ */ new WeakMap()) => (object, subset) => {
+		if (Array.isArray(object)) {
+			if (Array.isArray(subset) && subset.length === object.length) return subset.map((sub, i) => getObjectSubsetWithContext(seenReferences)(object[i], sub));
+		} else if (object instanceof Date) return object;
+		else if (isObject(object) && isObject(subset)) {
+			if (equals(object, subset, [
+				...customTesters,
+				iterableEquality,
+				subsetEquality
+			])) return subset;
+			const trimmed = {};
+			seenReferences.set(object, trimmed);
+			if (typeof object.constructor === "function" && typeof object.constructor.name === "string") Object.defineProperty(trimmed, "constructor", {
+				enumerable: false,
+				value: object.constructor
+			});
+			for (const key of getObjectKeys(object)) if (hasPropertyInObject(subset, key)) trimmed[key] = seenReferences.has(object[key]) ? seenReferences.get(object[key]) : getObjectSubsetWithContext(seenReferences)(object[key], subset[key]);
+			else if (!seenReferences.has(object[key])) {
+				stripped += 1;
+				if (isObject(object[key])) stripped += getObjectKeys(object[key]).length;
+				getObjectSubsetWithContext(seenReferences)(object[key], subset[key]);
+			}
+			if (getObjectKeys(trimmed).length > 0) return trimmed;
+		}
+		return object;
+	};
+	return {
+		subset: getObjectSubsetWithContext()(object, subset),
+		stripped
+	};
+}
+/**
+* Detects if an object is a Standard Schema V1 compatible schema
+*/
+function isStandardSchema(obj) {
+	return !!obj && (typeof obj === "object" || typeof obj === "function") && obj["~standard"] && typeof obj["~standard"].validate === "function";
+}
+if (!Object.hasOwn(globalThis, MATCHERS_OBJECT)) {
+	const globalState = /* @__PURE__ */ new WeakMap();
+	const matchers = Object.create(null);
+	const customEqualityTesters = [];
+	const asymmetricMatchers = Object.create(null);
+	Object.defineProperty(globalThis, MATCHERS_OBJECT, { get: () => globalState });
+	Object.defineProperty(globalThis, JEST_MATCHERS_OBJECT, {
+		configurable: true,
+		get: () => ({
+			state: globalState.get(globalThis[GLOBAL_EXPECT]),
+			matchers,
+			customEqualityTesters
+		})
+	});
+	Object.defineProperty(globalThis, ASYMMETRIC_MATCHERS_OBJECT, { get: () => asymmetricMatchers });
+}
+function getState(expect) {
+	return globalThis[MATCHERS_OBJECT].get(expect);
+}
+function setState(state, expect) {
+	const map = globalThis[MATCHERS_OBJECT];
+	const current = map.get(expect) || {};
+	const results = Object.defineProperties(current, {
+		...Object.getOwnPropertyDescriptors(current),
+		...Object.getOwnPropertyDescriptors(state)
+	});
+	map.set(expect, results);
+}
+var AsymmetricMatcher = class {
+	constructor(sample, inverse = false) {
+		this.$$typeof = Symbol.for("jest.asymmetricMatcher");
+		this.sample = sample;
+		this.inverse = inverse;
+	}
+	getMatcherContext(expect) {
+		return {
+			...getState(expect || globalThis[GLOBAL_EXPECT]),
+			equals,
+			isNot: this.inverse,
+			customTesters: getCustomEqualityTesters(),
+			utils: {
+				...getMatcherUtils(),
+				diff,
+				stringify,
+				iterableEquality,
+				subsetEquality
+			}
+		};
+	}
+};
+AsymmetricMatcher.prototype[Symbol.for("chai/inspect")] = function(options) {
+	const result = stringify(this, options.depth, { min: true });
+	if (result.length <= options.truncate) return result;
+	return `${this.toString()}{…}`;
+};
+var StringContaining = class extends AsymmetricMatcher {
+	constructor(sample, inverse = false) {
+		if (!isA("String", sample)) throw new Error("Expected is not a string");
+		super(sample, inverse);
+	}
+	asymmetricMatch(other) {
+		const result = isA("String", other) && other.includes(this.sample);
+		return this.inverse ? !result : result;
+	}
+	toString() {
+		return `String${this.inverse ? "Not" : ""}Containing`;
+	}
+	getExpectedType() {
+		return "string";
+	}
+};
+var Anything = class extends AsymmetricMatcher {
+	asymmetricMatch(other) {
+		return other != null;
+	}
+	toString() {
+		return "Anything";
+	}
+	toAsymmetricMatcher() {
+		return "Anything";
+	}
+};
+var ObjectContaining = class extends AsymmetricMatcher {
+	constructor(sample, inverse = false) {
+		super(sample, inverse);
+	}
+	getPrototype(obj) {
+		if (Object.getPrototypeOf) return Object.getPrototypeOf(obj);
+		if (obj.constructor.prototype === obj) return null;
+		return obj.constructor.prototype;
+	}
+	hasProperty(obj, property) {
+		if (!obj) return false;
+		if (Object.hasOwn(obj, property)) return true;
+		return this.hasProperty(this.getPrototype(obj), property);
+	}
+	getProperties(obj) {
+		return [...Object.keys(obj), ...Object.getOwnPropertySymbols(obj).filter((s) => Object.getOwnPropertyDescriptor(obj, s)?.enumerable)];
+	}
+	asymmetricMatch(other, customTesters) {
+		if (typeof this.sample !== "object") throw new TypeError(`You must provide an object to ${this.toString()}, not '${typeof this.sample}'.`);
+		let result = true;
+		const properties = this.getProperties(this.sample);
+		for (const property of properties) {
+			if (!this.hasProperty(other, property)) {
+				result = false;
+				break;
+			}
+			const value = this.sample[property];
+			const otherValue = other[property];
+			if (!equals(value, otherValue, customTesters)) {
+				result = false;
+				break;
+			}
+		}
+		return this.inverse ? !result : result;
+	}
+	toString() {
+		return `Object${this.inverse ? "Not" : ""}Containing`;
+	}
+	getExpectedType() {
+		return "object";
+	}
+};
+var ArrayContaining = class extends AsymmetricMatcher {
+	constructor(sample, inverse = false) {
+		super(sample, inverse);
+	}
+	asymmetricMatch(other, customTesters) {
+		if (!Array.isArray(this.sample)) throw new TypeError(`You must provide an array to ${this.toString()}, not '${typeof this.sample}'.`);
+		const result = this.sample.length === 0 || Array.isArray(other) && this.sample.every((item) => other.some((another) => equals(item, another, customTesters)));
+		return this.inverse ? !result : result;
+	}
+	toString() {
+		return `Array${this.inverse ? "Not" : ""}Containing`;
+	}
+	getExpectedType() {
+		return "array";
+	}
+};
+var Any = class extends AsymmetricMatcher {
+	constructor(sample) {
+		if (typeof sample === "undefined") throw new TypeError("any() expects to be passed a constructor function. Please pass one or use anything() to match any object.");
+		super(sample);
+	}
+	fnNameFor(func) {
+		if (func.name) return func.name;
+		const matches = Function.prototype.toString.call(func).match(/^(?:async)?\s*function\s*(?:\*\s*)?([\w$]+)\s*\(/);
+		return matches ? matches[1] : "<anonymous>";
+	}
+	asymmetricMatch(other) {
+		if (this.sample === String) return typeof other == "string" || other instanceof String;
+		if (this.sample === Number) return typeof other == "number" || other instanceof Number;
+		if (this.sample === Function) return typeof other == "function" || typeof other === "function";
+		if (this.sample === Boolean) return typeof other == "boolean" || other instanceof Boolean;
+		if (this.sample === BigInt) return typeof other == "bigint" || other instanceof BigInt;
+		if (this.sample === Symbol) return typeof other == "symbol" || other instanceof Symbol;
+		if (this.sample === Object) return typeof other == "object";
+		return other instanceof this.sample;
+	}
+	toString() {
+		return "Any";
+	}
+	getExpectedType() {
+		if (this.sample === String) return "string";
+		if (this.sample === Number) return "number";
+		if (this.sample === Function) return "function";
+		if (this.sample === Object) return "object";
+		if (this.sample === Boolean) return "boolean";
+		return this.fnNameFor(this.sample);
+	}
+	toAsymmetricMatcher() {
+		return `Any<${this.fnNameFor(this.sample)}>`;
+	}
+};
+var StringMatching = class extends AsymmetricMatcher {
+	constructor(sample, inverse = false) {
+		if (!isA("String", sample) && !isA("RegExp", sample)) throw new Error("Expected is not a String or a RegExp");
+		super(new RegExp(sample), inverse);
+	}
+	asymmetricMatch(other) {
+		const result = isA("String", other) && this.sample.test(other);
+		return this.inverse ? !result : result;
+	}
+	toString() {
+		return `String${this.inverse ? "Not" : ""}Matching`;
+	}
+	getExpectedType() {
+		return "string";
+	}
+};
+var CloseTo = class extends AsymmetricMatcher {
+	constructor(sample, precision = 2, inverse = false) {
+		if (!isA("Number", sample)) throw new Error("Expected is not a Number");
+		if (!isA("Number", precision)) throw new Error("Precision is not a Number");
+		super(sample);
+		this.inverse = inverse;
+		this.precision = precision;
+	}
+	asymmetricMatch(other) {
+		if (!isA("Number", other)) return false;
+		let result = false;
+		if (other === Number.POSITIVE_INFINITY && this.sample === Number.POSITIVE_INFINITY) result = true;
+		else if (other === Number.NEGATIVE_INFINITY && this.sample === Number.NEGATIVE_INFINITY) result = true;
+		else result = Math.abs(this.sample - other) < 10 ** -this.precision / 2;
+		return this.inverse ? !result : result;
+	}
+	toString() {
+		return `Number${this.inverse ? "Not" : ""}CloseTo`;
+	}
+	getExpectedType() {
+		return "number";
+	}
+	toAsymmetricMatcher() {
+		return [
+			this.toString(),
+			this.sample,
+			`(${pluralize("digit", this.precision)})`
+		].join(" ");
+	}
+};
+var SchemaMatching = class extends AsymmetricMatcher {
+	constructor(sample, inverse = false) {
+		if (!isStandardSchema(sample)) throw new TypeError("SchemaMatching expected to receive a Standard Schema.");
+		super(sample, inverse);
+	}
+	asymmetricMatch(other) {
+		const result = this.sample["~standard"].validate(other);
+		if (result instanceof Promise) throw new TypeError("Async schema validation is not supported in asymmetric matchers.");
+		this.result = result;
+		const pass = !this.result.issues || this.result.issues.length === 0;
+		return this.inverse ? !pass : pass;
+	}
+	toString() {
+		return `Schema${this.inverse ? "Not" : ""}Matching`;
+	}
+	getExpectedType() {
+		return "object";
+	}
+	toAsymmetricMatcher() {
+		const { utils } = this.getMatcherContext();
+		if ((this.result?.issues || []).length > 0) return `${this.toString()} ${utils.stringify(this.result, void 0, { printBasicPrototype: false })}`;
+		return this.toString();
+	}
+};
+const JestAsymmetricMatchers = (chai, utils) => {
+	utils.addMethod(chai.expect, "anything", () => new Anything());
+	utils.addMethod(chai.expect, "any", (expected) => new Any(expected));
+	utils.addMethod(chai.expect, "stringContaining", (expected) => new StringContaining(expected));
+	utils.addMethod(chai.expect, "objectContaining", (expected) => new ObjectContaining(expected));
+	utils.addMethod(chai.expect, "arrayContaining", (expected) => new ArrayContaining(expected));
+	utils.addMethod(chai.expect, "stringMatching", (expected) => new StringMatching(expected));
+	utils.addMethod(chai.expect, "closeTo", (expected, precision) => new CloseTo(expected, precision));
+	utils.addMethod(chai.expect, "schemaMatching", (expected) => new SchemaMatching(expected));
+	chai.expect.not = {
+		stringContaining: (expected) => new StringContaining(expected, true),
+		objectContaining: (expected) => new ObjectContaining(expected, true),
+		arrayContaining: (expected) => new ArrayContaining(expected, true),
+		stringMatching: (expected) => new StringMatching(expected, true),
+		closeTo: (expected, precision) => new CloseTo(expected, precision, true),
+		schemaMatching: (expected) => new SchemaMatching(expected, true)
+	};
+};
+function createAssertionMessage(util, assertion, hasArgs) {
+	const soft = util.flag(assertion, "soft") ? ".soft" : "";
+	const not = util.flag(assertion, "negate") ? "not." : "";
+	const name = `${util.flag(assertion, "_name")}(${hasArgs ? "expected" : ""})`;
+	const promiseName = util.flag(assertion, "promise");
+	return `expect${soft}(actual)${promiseName ? `.${promiseName}` : ""}.${not}${name}`;
+}
+function recordAsyncExpect(_test, promise, assertion, error, isSoft) {
+	const test = _test;
+	if (test && promise instanceof Promise) {
+		promise = promise.finally(() => {
+			if (!test.promises) return;
+			const index = test.promises.indexOf(promise);
+			if (index !== -1) test.promises.splice(index, 1);
+		});
+		if (!test.promises) test.promises = [];
+		if (isSoft) promise = promise.then(noop, (err) => {
+			handleTestError(test, err);
+		});
+		test.promises.push(promise);
+		let resolved = false;
+		test.onFinished ?? (test.onFinished = []);
+		test.onFinished.push(() => {
+			if (!resolved) {
+				const stack = (globalThis.__vitest_worker__?.onFilterStackTrace || ((s) => s || ""))(error.stack);
+				console.warn([
+					`Promise returned by \`${assertion}\` was not awaited. `,
+					"Vitest currently auto-awaits hanging assertions at the end of the test, but this will cause the test to fail in the next Vitest major. ",
+					"Please remember to await the assertion.\n",
+					stack
+				].join(""));
+			}
+		});
+		return {
+			then(onFulfilled, onRejected) {
+				resolved = true;
+				return promise.then(onFulfilled, onRejected);
+			},
+			catch(onRejected) {
+				resolved = true;
+				return promise.catch(onRejected);
+			},
+			finally(onFinally) {
+				resolved = true;
+				return promise.finally(onFinally);
+			},
+			[Symbol.toStringTag]: "Promise"
+		};
+	}
+	return promise;
+}
+function handleTestError(test, err) {
+	var _test$result;
+	test.result || (test.result = { state: "fail" });
+	test.result.state = "fail";
+	(_test$result = test.result).errors || (_test$result.errors = []);
+	test.result.errors.push(processError(err));
+}
+function wrapAssertion(utils, name, fn) {
+	return function(...args) {
+		if (name !== "withTest") utils.flag(this, "_name", name);
+		if (!utils.flag(this, "soft")) try {
+			return fn.apply(this, args);
+		} finally {}
+		const test = utils.flag(this, "vitest-test");
+		if (!test) throw new Error("expect.soft() can only be used inside a test");
+		try {
+			const result = fn.apply(this, args);
+			if (result && typeof result === "object" && typeof result.then === "function") return result.then(noop, (err) => {
+				handleTestError(test, err);
+			});
+			return result;
+		} catch (err) {
+			handleTestError(test, err);
+		}
+	};
+}
+const JestChaiExpect = (chai, utils) => {
+	const { AssertionError } = chai;
+	const customTesters = getCustomEqualityTesters();
+	function def(name, fn) {
+		const addMethod = (n) => {
+			const softWrapper = wrapAssertion(utils, n, fn);
+			utils.addMethod(chai.Assertion.prototype, n, softWrapper);
+			utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, n, softWrapper);
+		};
+		if (Array.isArray(name)) name.forEach((n) => addMethod(n));
+		else addMethod(name);
+	}
+	[
+		"throw",
+		"throws",
+		"Throw"
+	].forEach((m) => {
+		utils.overwriteMethod(chai.Assertion.prototype, m, (_super) => {
+			return function(...args) {
+				const promise = utils.flag(this, "promise");
+				const object = utils.flag(this, "object");
+				const isNot = utils.flag(this, "negate");
+				if (promise === "rejects") utils.flag(this, "object", () => {
+					throw object;
+				});
+				else if (promise === "resolves" && typeof object !== "function") if (!isNot) throw new AssertionError(utils.flag(this, "message") || "expected promise to throw an error, but it didn't", { showDiff: false }, utils.flag(this, "ssfi"));
+				else return;
+				_super.apply(this, args);
+			};
+		});
+	});
+	def("withTest", function(test) {
+		utils.flag(this, "vitest-test", test);
+		return this;
+	});
+	def("toEqual", function(expected) {
+		const actual = utils.flag(this, "object");
+		const equal = equals(actual, expected, [...customTesters, iterableEquality]);
+		return this.assert(equal, "expected #{this} to deeply equal #{exp}", "expected #{this} to not deeply equal #{exp}", expected, actual);
+	});
+	def("toStrictEqual", function(expected) {
+		const obj = utils.flag(this, "object");
+		const equal = equals(obj, expected, [
+			...customTesters,
+			iterableEquality,
+			typeEquality,
+			sparseArrayEquality,
+			arrayBufferEquality
+		], true);
+		return this.assert(equal, "expected #{this} to strictly equal #{exp}", "expected #{this} to not strictly equal #{exp}", expected, obj);
+	});
+	def("toBe", function(expected) {
+		const actual = this._obj;
+		const pass = Object.is(actual, expected);
+		let deepEqualityName = "";
+		if (!pass) {
+			if (equals(actual, expected, [
+				...customTesters,
+				iterableEquality,
+				typeEquality,
+				sparseArrayEquality,
+				arrayBufferEquality
+			], true)) deepEqualityName = "toStrictEqual";
+			else if (equals(actual, expected, [...customTesters, iterableEquality])) deepEqualityName = "toEqual";
+		}
+		return this.assert(pass, generateToBeMessage(deepEqualityName), "expected #{this} not to be #{exp} // Object.is equality", expected, actual);
+	});
+	def("toMatchObject", function(expected) {
+		const actual = this._obj;
+		const pass = equals(actual, expected, [
+			...customTesters,
+			iterableEquality,
+			subsetEquality
+		]);
+		const isNot = utils.flag(this, "negate");
+		const { subset: actualSubset, stripped } = getObjectSubset(actual, expected, customTesters);
+		if (pass && isNot || !pass && !isNot) {
+			const msg = utils.getMessage(this, [
+				pass,
+				"expected #{this} to match object #{exp}",
+				"expected #{this} to not match object #{exp}",
+				expected,
+				actualSubset,
+				false
+			]);
+			throw new AssertionError(stripped === 0 ? msg : `${msg}\n(${stripped} matching ${stripped === 1 ? "property" : "properties"} omitted from actual)`, {
+				showDiff: true,
+				expected,
+				actual: actualSubset
+			});
+		}
+	});
+	def("toMatch", function(expected) {
+		const actual = this._obj;
+		if (typeof actual !== "string") throw new TypeError(`.toMatch() expects to receive a string, but got ${typeof actual}`);
+		return this.assert(typeof expected === "string" ? actual.includes(expected) : actual.match(expected), `expected #{this} to match #{exp}`, `expected #{this} not to match #{exp}`, expected, actual);
+	});
+	def("toContain", function(item) {
+		const actual = this._obj;
+		if (typeof Node !== "undefined" && actual instanceof Node) {
+			if (!(item instanceof Node)) throw new TypeError(`toContain() expected a DOM node as the argument, but got ${typeof item}`);
+			return this.assert(actual.contains(item), "expected #{this} to contain element #{exp}", "expected #{this} not to contain element #{exp}", item, actual);
+		}
+		if (typeof DOMTokenList !== "undefined" && actual instanceof DOMTokenList) {
+			assertTypes(item, "class name", ["string"]);
+			const expectedClassList = utils.flag(this, "negate") ? actual.value.replace(item, "").trim() : `${actual.value} ${item}`;
+			return this.assert(actual.contains(item), `expected "${actual.value}" to contain "${item}"`, `expected "${actual.value}" not to contain "${item}"`, expectedClassList, actual.value);
+		}
+		if (typeof actual === "string" && typeof item === "string") return this.assert(actual.includes(item), `expected #{this} to contain #{exp}`, `expected #{this} not to contain #{exp}`, item, actual);
+		if (actual != null && typeof actual !== "string") utils.flag(this, "object", Array.from(actual));
+		return this.contain(item);
+	});
+	def("toContainEqual", function(expected) {
+		const obj = utils.flag(this, "object");
+		const index = Array.from(obj).findIndex((item) => {
+			return equals(item, expected, customTesters);
+		});
+		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", true, obj);
+	});
+	def("toBeFalsy", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(!obj, "expected #{this} to be falsy", "expected #{this} to not be falsy", false, obj);
+	});
+	def("toBeGreaterThan", function(expected) {
+		const actual = this._obj;
+		assertTypes(actual, "actual", ["number", "bigint"]);
+		assertTypes(expected, "expected", ["number", "bigint"]);
+		return this.assert(actual > expected, `expected ${actual} to be greater than ${expected}`, `expected ${actual} to be not greater than ${expected}`, expected, actual, false);
+	});
+	def("toBeGreaterThanOrEqual", function(expected) {
+		const actual = this._obj;
+		assertTypes(actual, "actual", ["number", "bigint"]);
+		assertTypes(expected, "expected", ["number", "bigint"]);
+		return this.assert(actual >= expected, `expected ${actual} to be greater than or equal to ${expected}`, `expected ${actual} to be not greater than or equal to ${expected}`, expected, actual, false);
+	});
+	def("toBeLessThan", function(expected) {
+		const actual = this._obj;
+		assertTypes(actual, "actual", ["number", "bigint"]);
+		assertTypes(expected, "expected", ["number", "bigint"]);
+		return this.assert(actual < expected, `expected ${actual} to be less than ${expected}`, `expected ${actual} to be not less than ${expected}`, expected, actual, false);
+	});
+	def("toBeLessThanOrEqual", function(expected) {
+		const actual = this._obj;
+		assertTypes(actual, "actual", ["number", "bigint"]);
+		assertTypes(expected, "expected", ["number", "bigint"]);
+		return this.assert(actual <= expected, `expected ${actual} to be less than or equal to ${expected}`, `expected ${actual} to be not less than or equal to ${expected}`, expected, actual, false);
+	});
+	def("toBeNaN", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(Number.isNaN(obj), "expected #{this} to be NaN", "expected #{this} not to be NaN", NaN, obj);
+	});
+	def("toBeUndefined", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(void 0 === obj, "expected #{this} to be undefined", "expected #{this} not to be undefined", void 0, obj);
+	});
+	def("toBeNull", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(obj === null, "expected #{this} to be null", "expected #{this} not to be null", null, obj);
+	});
+	def("toBeNullable", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(obj == null, "expected #{this} to be nullish", "expected #{this} not to be nullish", null, obj);
+	});
+	def("toBeDefined", function() {
+		const obj = utils.flag(this, "object");
+		this.assert(typeof obj !== "undefined", "expected #{this} to be defined", "expected #{this} to be undefined", obj);
+	});
+	def("toBeTypeOf", function(expected) {
+		const actual = typeof this._obj;
+		const equal = expected === actual;
+		return this.assert(equal, "expected #{this} to be type of #{exp}", "expected #{this} not to be type of #{exp}", expected, actual);
+	});
+	def("toBeInstanceOf", function(obj) {
+		return this.instanceOf(obj);
+	});
+	def("toHaveLength", function(length) {
+		return this.have.length(length);
+	});
+	def("toHaveProperty", function(...args) {
+		if (Array.isArray(args[0])) args[0] = args[0].map((key) => String(key).replace(/([.[\]])/g, "\\$1")).join(".");
+		const actual = this._obj;
+		const [propertyName, expected] = args;
+		const getValue = () => {
+			if (Object.hasOwn(actual, propertyName)) return {
+				value: actual[propertyName],
+				exists: true
+			};
+			return utils.getPathInfo(actual, propertyName);
+		};
+		const { value, exists } = getValue();
+		const pass = exists && (args.length === 1 || equals(expected, value, customTesters));
+		const valueString = args.length === 1 ? "" : ` with value ${utils.objDisplay(expected)}`;
+		return this.assert(pass, `expected #{this} to have property "${propertyName}"${valueString}`, `expected #{this} to not have property "${propertyName}"${valueString}`, expected, exists ? value : void 0);
+	});
+	def("toBeCloseTo", function(received, precision = 2) {
+		const expected = this._obj;
+		let pass = false;
+		let expectedDiff = 0;
+		let receivedDiff = 0;
+		if (received === Number.POSITIVE_INFINITY && expected === Number.POSITIVE_INFINITY) pass = true;
+		else if (received === Number.NEGATIVE_INFINITY && expected === Number.NEGATIVE_INFINITY) pass = true;
+		else {
+			expectedDiff = 10 ** -precision / 2;
+			receivedDiff = Math.abs(expected - received);
+			pass = receivedDiff < expectedDiff;
+		}
+		return this.assert(pass, `expected #{this} to be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, `expected #{this} to not be close to #{exp}, received difference is ${receivedDiff}, but expected ${expectedDiff}`, received, expected, false);
+	});
+	function assertIsMock(assertion) {
+		if (!isMockFunction(assertion._obj)) throw new TypeError(`${utils.inspect(assertion._obj)} is not a spy or a call to a spy!`);
+	}
+	function getSpy(assertion) {
+		assertIsMock(assertion);
+		return assertion._obj;
+	}
+	def(["toHaveBeenCalledTimes", "toBeCalledTimes"], function(number) {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const callCount = spy.mock.calls.length;
+		return this.assert(callCount === number, `expected "${spyName}" to be called #{exp} times, but got ${callCount} times`, `expected "${spyName}" to not be called #{exp} times`, number, callCount, false);
+	});
+	def("toHaveBeenCalledOnce", function() {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const callCount = spy.mock.calls.length;
+		return this.assert(callCount === 1, `expected "${spyName}" to be called once, but got ${callCount} times`, `expected "${spyName}" to not be called once`, 1, callCount, false);
+	});
+	def(["toHaveBeenCalled", "toBeCalled"], function() {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const callCount = spy.mock.calls.length;
+		const called = callCount > 0;
+		const isNot = utils.flag(this, "negate");
+		let msg = utils.getMessage(this, [
+			called,
+			`expected "${spyName}" to be called at least once`,
+			`expected "${spyName}" to not be called at all, but actually been called ${callCount} times`,
+			true,
+			called
+		]);
+		if (called && isNot) msg = formatCalls(spy, msg);
+		if (called && isNot || !called && !isNot) throw new AssertionError(msg);
+	});
+	function equalsArgumentArray(a, b) {
+		return a.length === b.length && a.every((aItem, i) => equals(aItem, b[i], [...customTesters, iterableEquality]));
+	}
+	def(["toHaveBeenCalledWith", "toBeCalledWith"], function(...args) {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const pass = spy.mock.calls.some((callArg) => equalsArgumentArray(callArg, args));
+		const isNot = utils.flag(this, "negate");
+		const msg = utils.getMessage(this, [
+			pass,
+			`expected "${spyName}" to be called with arguments: #{exp}`,
+			`expected "${spyName}" to not be called with arguments: #{exp}`,
+			args
+		]);
+		if (pass && isNot || !pass && !isNot) throw new AssertionError(formatCalls(spy, msg, args));
+	});
+	def("toHaveBeenCalledExactlyOnceWith", function(...args) {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const callCount = spy.mock.calls.length;
+		const pass = spy.mock.calls.some((callArg) => equalsArgumentArray(callArg, args)) && callCount === 1;
+		const isNot = utils.flag(this, "negate");
+		const msg = utils.getMessage(this, [
+			pass,
+			`expected "${spyName}" to be called once with arguments: #{exp}`,
+			`expected "${spyName}" to not be called once with arguments: #{exp}`,
+			args
+		]);
+		if (pass && isNot || !pass && !isNot) throw new AssertionError(formatCalls(spy, msg, args));
+	});
+	def("toHaveBeenNthCalledWith", function(times, ...args) {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const nthCall = spy.mock.calls[times - 1];
+		const callCount = spy.mock.calls.length;
+		const isCalled = times <= callCount;
+		this.assert(nthCall && equalsArgumentArray(nthCall, args), `expected ${ordinal(times)} "${spyName}" call to have been called with #{exp}${isCalled ? `` : `, but called only ${callCount} times`}`, `expected ${ordinal(times)} "${spyName}" call to not have been called with #{exp}`, args, nthCall, isCalled);
+	});
+	def("toHaveBeenLastCalledWith", function(...args) {
+		const spy = getSpy(this);
+		const spyName = spy.getMockName();
+		const lastCall = spy.mock.calls.at(-1);
+		this.assert(lastCall && equalsArgumentArray(lastCall, args), `expected last "${spyName}" call to have been called with #{exp}`, `expected last "${spyName}" call to not have been called with #{exp}`, args, lastCall);
+	});
+	/**
+	* Used for `toHaveBeenCalledBefore` and `toHaveBeenCalledAfter` to determine if the expected spy was called before the result spy.
+	*/
+	function isSpyCalledBeforeAnotherSpy(beforeSpy, afterSpy, failIfNoFirstInvocation) {
+		const beforeInvocationCallOrder = beforeSpy.mock.invocationCallOrder;
+		const afterInvocationCallOrder = afterSpy.mock.invocationCallOrder;
+		if (beforeInvocationCallOrder.length === 0) return !failIfNoFirstInvocation;
+		if (afterInvocationCallOrder.length === 0) return false;
+		return beforeInvocationCallOrder[0] < afterInvocationCallOrder[0];
+	}
+	def(["toHaveBeenCalledBefore"], function(resultSpy, failIfNoFirstInvocation = true) {
+		const expectSpy = getSpy(this);
+		if (!isMockFunction(resultSpy)) throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
+		this.assert(isSpyCalledBeforeAnotherSpy(expectSpy, resultSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called before "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called before "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
+	});
+	def(["toHaveBeenCalledAfter"], function(resultSpy, failIfNoFirstInvocation = true) {
+		const expectSpy = getSpy(this);
+		if (!isMockFunction(resultSpy)) throw new TypeError(`${utils.inspect(resultSpy)} is not a spy or a call to a spy`);
+		this.assert(isSpyCalledBeforeAnotherSpy(resultSpy, expectSpy, failIfNoFirstInvocation), `expected "${expectSpy.getMockName()}" to have been called after "${resultSpy.getMockName()}"`, `expected "${expectSpy.getMockName()}" to not have been called after "${resultSpy.getMockName()}"`, resultSpy, expectSpy);
+	});
+	def(["toThrow", "toThrowError"], function(expected) {
+		if (typeof expected === "string" || typeof expected === "undefined" || expected instanceof RegExp) return this.throws(expected === "" ? /^$/ : expected);
+		const obj = this._obj;
+		const promise = utils.flag(this, "promise");
+		const isNot = utils.flag(this, "negate");
+		let thrown = null;
+		if (promise === "rejects") thrown = obj;
+		else if (promise === "resolves" && typeof obj !== "function") if (!isNot) throw new AssertionError(utils.flag(this, "message") || "expected promise to throw an error, but it didn't", { showDiff: false }, utils.flag(this, "ssfi"));
+		else return;
+		else {
+			let isThrow = false;
+			try {
+				obj();
+			} catch (err) {
+				isThrow = true;
+				thrown = err;
+			}
+			if (!isThrow && !isNot) throw new AssertionError(utils.flag(this, "message") || "expected function to throw an error, but it didn't", { showDiff: false }, utils.flag(this, "ssfi"));
+		}
+		if (typeof expected === "function") {
+			const name = expected.name || expected.prototype.constructor.name;
+			return this.assert(thrown && thrown instanceof expected, `expected error to be instance of ${name}`, `expected error not to be instance of ${name}`, expected, thrown);
+		}
+		if (isError(expected)) {
+			const equal = equals(thrown, expected, [...customTesters, iterableEquality]);
+			return this.assert(equal, "expected a thrown error to be #{exp}", "expected a thrown error not to be #{exp}", expected, thrown);
+		}
+		if (typeof expected === "object" && "asymmetricMatch" in expected && typeof expected.asymmetricMatch === "function") {
+			const matcher = expected;
+			return this.assert(thrown && matcher.asymmetricMatch(thrown), "expected error to match asymmetric matcher", "expected error not to match asymmetric matcher", matcher, thrown);
+		}
+		const equal = equals(thrown, expected, [...customTesters, iterableEquality]);
+		return this.assert(equal, "expected a thrown value to equal #{exp}", "expected a thrown value not to equal #{exp}", expected, thrown);
+	});
+	[{
+		name: "toHaveResolved",
+		condition: (spy) => spy.mock.settledResults.length > 0 && spy.mock.settledResults.some(({ type }) => type === "fulfilled"),
+		action: "resolved"
+	}, {
+		name: ["toHaveReturned", "toReturn"],
+		condition: (spy) => spy.mock.calls.length > 0 && spy.mock.results.some(({ type }) => type !== "throw"),
+		action: "called"
+	}].forEach(({ name, condition, action }) => {
+		def(name, function() {
+			const spy = getSpy(this);
+			const spyName = spy.getMockName();
+			const pass = condition(spy);
+			this.assert(pass, `expected "${spyName}" to be successfully ${action} at least once`, `expected "${spyName}" to not be successfully ${action}`, pass, !pass, false);
+		});
+	});
+	[{
+		name: "toHaveResolvedTimes",
+		condition: (spy, times) => spy.mock.settledResults.reduce((s, { type }) => type === "fulfilled" ? ++s : s, 0) === times,
+		action: "resolved"
+	}, {
+		name: ["toHaveReturnedTimes", "toReturnTimes"],
+		condition: (spy, times) => spy.mock.results.reduce((s, { type }) => type === "throw" ? s : ++s, 0) === times,
+		action: "called"
+	}].forEach(({ name, condition, action }) => {
+		def(name, function(times) {
+			const spy = getSpy(this);
+			const spyName = spy.getMockName();
+			const pass = condition(spy, times);
+			this.assert(pass, `expected "${spyName}" to be successfully ${action} ${times} times`, `expected "${spyName}" to not be successfully ${action} ${times} times`, `expected resolved times: ${times}`, `received resolved times: ${pass}`, false);
+		});
+	});
+	[{
+		name: "toHaveResolvedWith",
+		condition: (spy, value) => spy.mock.settledResults.some(({ type, value: result }) => type === "fulfilled" && equals(value, result)),
+		action: "resolve"
+	}, {
+		name: ["toHaveReturnedWith", "toReturnWith"],
+		condition: (spy, value) => spy.mock.results.some(({ type, value: result }) => type === "return" && equals(value, result)),
+		action: "return"
+	}].forEach(({ name, condition, action }) => {
+		def(name, function(value) {
+			const spy = getSpy(this);
+			const pass = condition(spy, value);
+			const isNot = utils.flag(this, "negate");
+			if (pass && isNot || !pass && !isNot) {
+				const spyName = spy.getMockName();
+				const msg = utils.getMessage(this, [
+					pass,
+					`expected "${spyName}" to ${action} with: #{exp} at least once`,
+					`expected "${spyName}" to not ${action} with: #{exp}`,
+					value
+				]);
+				throw new AssertionError(formatReturns(spy, action === "return" ? spy.mock.results : spy.mock.settledResults, msg, value));
+			}
+		});
+	});
+	[{
+		name: "toHaveLastResolvedWith",
+		condition: (spy, value) => {
+			const result = spy.mock.settledResults.at(-1);
+			return Boolean(result && result.type === "fulfilled" && equals(result.value, value));
+		},
+		action: "resolve"
+	}, {
+		name: "toHaveLastReturnedWith",
+		condition: (spy, value) => {
+			const result = spy.mock.results.at(-1);
+			return Boolean(result && result.type === "return" && equals(result.value, value));
+		},
+		action: "return"
+	}].forEach(({ name, condition, action }) => {
+		def(name, function(value) {
+			const spy = getSpy(this);
+			const result = (action === "return" ? spy.mock.results : spy.mock.settledResults).at(-1);
+			const spyName = spy.getMockName();
+			this.assert(condition(spy, value), `expected last "${spyName}" call to ${action} #{exp}`, `expected last "${spyName}" call to not ${action} #{exp}`, value, result?.value);
+		});
+	});
+	[{
+		name: "toHaveNthResolvedWith",
+		condition: (spy, index, value) => {
+			const result = spy.mock.settledResults[index - 1];
+			return result && result.type === "fulfilled" && equals(result.value, value);
+		},
+		action: "resolve"
+	}, {
+		name: "toHaveNthReturnedWith",
+		condition: (spy, index, value) => {
+			const result = spy.mock.results[index - 1];
+			return result && result.type === "return" && equals(result.value, value);
+		},
+		action: "return"
+	}].forEach(({ name, condition, action }) => {
+		def(name, function(nthCall, value) {
+			const spy = getSpy(this);
+			const spyName = spy.getMockName();
+			const result = (action === "return" ? spy.mock.results : spy.mock.settledResults)[nthCall - 1];
+			const ordinalCall = `${ordinal(nthCall)} call`;
+			this.assert(condition(spy, nthCall, value), `expected ${ordinalCall} "${spyName}" call to ${action} #{exp}`, `expected ${ordinalCall} "${spyName}" call to not ${action} #{exp}`, value, result?.value);
+		});
+	});
+	def("withContext", function(context) {
+		for (const key in context) utils.flag(this, key, context[key]);
+		return this;
+	});
+	utils.addProperty(chai.Assertion.prototype, "resolves", function __VITEST_RESOLVES__() {
+		const error = /* @__PURE__ */ new Error("resolves");
+		utils.flag(this, "promise", "resolves");
+		utils.flag(this, "error", error);
+		const test = utils.flag(this, "vitest-test");
+		const obj = utils.flag(this, "object");
+		if (utils.flag(this, "poll")) throw new SyntaxError(`expect.poll() is not supported in combination with .resolves`);
+		if (typeof obj?.then !== "function") throw new TypeError(`You must provide a Promise to expect() when using .resolves, not '${typeof obj}'.`);
+		const proxy = new Proxy(this, { get: (target, key, receiver) => {
+			const result = Reflect.get(target, key, receiver);
+			if (typeof result !== "function") return result instanceof chai.Assertion ? proxy : result;
+			return (...args) => {
+				utils.flag(this, "_name", key);
+				return recordAsyncExpect(test, Promise.resolve(obj).then((value) => {
+					utils.flag(this, "object", value);
+					return result.call(this, ...args);
+				}, (err) => {
+					const _error = new AssertionError(`promise rejected "${utils.inspect(err)}" instead of resolving`, { showDiff: false });
+					_error.cause = err;
+					throw _error;
+				}).catch((err) => {
+					if (isError(err) && error.stack) err.stack = error.stack.replace(error.message, err.message);
+					throw err;
+				}), createAssertionMessage(utils, this, !!args.length), error);
+			};
+		} });
+		return proxy;
+	});
+	utils.addProperty(chai.Assertion.prototype, "rejects", function __VITEST_REJECTS__() {
+		const error = /* @__PURE__ */ new Error("rejects");
+		utils.flag(this, "promise", "rejects");
+		utils.flag(this, "error", error);
+		const test = utils.flag(this, "vitest-test");
+		const obj = utils.flag(this, "object");
+		const wrapper = typeof obj === "function" ? obj() : obj;
+		if (utils.flag(this, "poll")) throw new SyntaxError(`expect.poll() is not supported in combination with .rejects`);
+		if (typeof wrapper?.then !== "function") throw new TypeError(`You must provide a Promise to expect() when using .rejects, not '${typeof wrapper}'.`);
+		const proxy = new Proxy(this, { get: (target, key, receiver) => {
+			const result = Reflect.get(target, key, receiver);
+			if (typeof result !== "function") return result instanceof chai.Assertion ? proxy : result;
+			return (...args) => {
+				utils.flag(this, "_name", key);
+				return recordAsyncExpect(test, Promise.resolve(wrapper).then((value) => {
+					throw new AssertionError(`promise resolved "${utils.inspect(value)}" instead of rejecting`, {
+						showDiff: true,
+						expected: /* @__PURE__ */ new Error("rejected promise"),
+						actual: value
+					});
+				}, (err) => {
+					utils.flag(this, "object", err);
+					return result.call(this, ...args);
+				}).catch((err) => {
+					if (isError(err) && error.stack) err.stack = error.stack.replace(error.message, err.message);
+					throw err;
+				}), createAssertionMessage(utils, this, !!args.length), error);
+			};
+		} });
+		return proxy;
+	});
+};
+function formatCalls(spy, msg, showActualCall) {
+	if (spy.mock.calls.length) msg += y.gray(`\n\nReceived:\n\n${spy.mock.calls.map((callArg, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call:\n\n`);
+		if (showActualCall) methodCall += diff(showActualCall, callArg, { omitAnnotationLines: true });
+		else methodCall += stringify(callArg).split("\n").map((line) => `    ${line}`).join("\n");
+		methodCall += "\n";
+		return methodCall;
+	}).join("\n")}`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
+	return msg;
+}
+function formatReturns(spy, results, msg, showActualReturn) {
+	if (results.length) msg += y.gray(`\n\nReceived:\n\n${results.map((callReturn, i) => {
+		let methodCall = y.bold(`  ${ordinal(i + 1)} ${spy.getMockName()} call return:\n\n`);
+		if (showActualReturn) methodCall += diff(showActualReturn, callReturn.value, { omitAnnotationLines: true });
+		else methodCall += stringify(callReturn).split("\n").map((line) => `    ${line}`).join("\n");
+		methodCall += "\n";
+		return methodCall;
+	}).join("\n")}`);
+	msg += y.gray(`\n\nNumber of calls: ${y.bold(spy.mock.calls.length)}\n`);
+	return msg;
+}
+function getMatcherState(assertion, expect) {
+	const obj = assertion._obj;
+	const isNot = utils_exports.flag(assertion, "negate");
+	const promise = utils_exports.flag(assertion, "promise") || "";
+	const customMessage = utils_exports.flag(assertion, "message");
+	const jestUtils = {
+		...getMatcherUtils(),
+		diff,
+		stringify,
+		iterableEquality,
+		subsetEquality
+	};
+	let task = utils_exports.flag(assertion, "vitest-test");
+	const currentTestName = task?.fullTestName ?? "";
+	if (task?.type !== "test") task = void 0;
+	return {
+		state: {
+			...getState(expect),
+			task,
+			currentTestName,
+			customTesters: getCustomEqualityTesters(),
+			isNot,
+			utils: jestUtils,
+			promise,
+			equals,
+			suppressedErrors: [],
+			soft: utils_exports.flag(assertion, "soft"),
+			poll: utils_exports.flag(assertion, "poll")
+		},
+		isNot,
+		obj,
+		customMessage
+	};
+}
+var JestExtendError = class extends Error {
+	constructor(message, actual, expected) {
+		super(message);
+		this.actual = actual;
+		this.expected = expected;
+	}
+};
+function JestExtendPlugin(c, expect, matchers) {
+	return (_, utils) => {
+		Object.entries(matchers).forEach(([expectAssertionName, expectAssertion]) => {
+			function expectWrapper(...args) {
+				const { state, isNot, obj, customMessage } = getMatcherState(this, expect);
+				const result = expectAssertion.call(state, obj, ...args);
+				if (result && typeof result === "object" && typeof result.then === "function") return result.then(({ pass, message, actual, expected }) => {
+					if (pass && isNot || !pass && !isNot) throw new JestExtendError(customMessage != null ? customMessage : message(), actual, expected);
+				});
+				const { pass, message, actual, expected } = result;
+				if (pass && isNot || !pass && !isNot) throw new JestExtendError(customMessage != null ? customMessage : message(), actual, expected);
+			}
+			const softWrapper = wrapAssertion(utils, expectAssertionName, expectWrapper);
+			utils.addMethod(globalThis[JEST_MATCHERS_OBJECT].matchers, expectAssertionName, softWrapper);
+			utils.addMethod(c.Assertion.prototype, expectAssertionName, softWrapper);
+			class CustomMatcher extends AsymmetricMatcher {
+				constructor(inverse = false, ...sample) {
+					super(sample, inverse);
+				}
+				asymmetricMatch(other) {
+					const { pass } = expectAssertion.call(this.getMatcherContext(expect), other, ...this.sample);
+					return this.inverse ? !pass : pass;
+				}
+				toString() {
+					return `${this.inverse ? "not." : ""}${expectAssertionName}`;
+				}
+				getExpectedType() {
+					return "any";
+				}
+				toAsymmetricMatcher() {
+					return `${this.toString()}<${this.sample.map((item) => stringify(item)).join(", ")}>`;
+				}
+			}
+			const customMatcher = (...sample) => new CustomMatcher(false, ...sample);
+			Object.defineProperty(expect, expectAssertionName, {
+				configurable: true,
+				enumerable: true,
+				value: customMatcher,
+				writable: true
+			});
+			Object.defineProperty(expect.not, expectAssertionName, {
+				configurable: true,
+				enumerable: true,
+				value: (...sample) => new CustomMatcher(true, ...sample),
+				writable: true
+			});
+			Object.defineProperty(globalThis[ASYMMETRIC_MATCHERS_OBJECT], expectAssertionName, {
+				configurable: true,
+				enumerable: true,
+				value: customMatcher,
+				writable: true
+			});
+		});
+	};
+}
+const JestExtend = (chai, utils) => {
+	utils.addMethod(chai.expect, "extend", (expect, expects) => {
+		use(JestExtendPlugin(chai, expect, expects));
+	});
+};
+//#endregion
+export { ASYMMETRIC_MATCHERS_OBJECT, ChaiStyleAssertions, GLOBAL_EXPECT, JestAsymmetricMatchers, JestChaiExpect, JestExtend, addCustomEqualityTesters, createAssertionMessage, customMatchers, equals, getState, iterableEquality, recordAsyncExpect, setState, subsetEquality, wrapAssertion };
+
+//# sourceMappingURL=index.js.map