vitest 5.0.0-beta.6 → 5.0.0-beta.7

package/dist/chunks/{artifact.BNnEI1sJ.js → artifact.DC5WoEgy.js}

@@ -1,9 +1,1306 @@
-import { processError } from '@vitest/utils/error';
-import { isObject, filterOutComments, ordinal, createDefer, assertTypes, toArray, isNegativeNaN, unique, objectAttr, shuffle } from '@vitest/utils/helpers';
-import { getSafeTimers } from '@vitest/utils/timers';
+import { f as format, p as plugins } from './index.DzTmMrSM.js';
+import { y } from './tinyrainbow.Ht9iggcq.js';
+import { s as stringify, f as format$1, a as formatRegExp, t as truncateString, i as inspect } from './display.CYwyMF4S.js';
+import { q as deepClone, u as getOwnProperties, g as getType$1, v as isObject, w as filterOutComments, x as ordinal, e as createDefer, y as assertTypes, z as isNegativeNaN, t as toArray, A as unique, B as objectAttr } from './pathe.M-eThtNZ.CbK_Vbae.js';
+import { e as diffSequences, b as serializeValue, f as parseSingleStack, a as getSafeTimers } from './source-map.DZdIqpIJ.js';
 import { createTaskName, createFileTask, calculateSuiteHash, interpretTaskModes, someTasksAreOnly, hasTests, hasFailed } from '../task-utils.js';
-import { format, formatRegExp, truncateString, inspect } from '@vitest/utils/display';
-import { parseSingleStack } from '@vitest/utils/source-map';
+
+const RealDate = Date;
+function random(seed) {
+	const x = Math.sin(seed++) * 1e4;
+	return x - Math.floor(x);
+}
+function shuffle(array, seed = RealDate.now()) {
+	let length = array.length;
+	while (length) {
+		const index = Math.floor(random(seed) * length--);
+		const previous = array[length];
+		array[length] = array[index];
+		array[index] = previous;
+		++seed;
+	}
+	return array;
+}
+
+/**
+* Diff Match and Patch
+* Copyright 2018 The diff-match-patch Authors.
+* https://github.com/google/diff-match-patch
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*   http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+/**
+* @fileoverview Computes the difference between two texts to create a patch.
+* Applies the patch onto another text, allowing for errors.
+* @author fraser@google.com (Neil Fraser)
+*/
+/**
+* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
+*
+* 1. Delete anything not needed to use diff_cleanupSemantic method
+* 2. Convert from prototype properties to var declarations
+* 3. Convert Diff to class from constructor and prototype
+* 4. Add type annotations for arguments and return values
+* 5. Add exports
+*/
+/**
+* The data structure representing a diff is an array of tuples:
+* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
+* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
+*/
+const DIFF_DELETE = -1;
+const DIFF_INSERT = 1;
+const DIFF_EQUAL = 0;
+/**
+* Class representing one diff tuple.
+* Attempts to look like a two-element array (which is what this used to be).
+* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
+* @param {string} text Text to be deleted, inserted, or retained.
+* @constructor
+*/
+class Diff {
+	0;
+	1;
+	constructor(op, text) {
+		this[0] = op;
+		this[1] = text;
+	}
+}
+/**
+* Determine the common prefix of two strings.
+* @param {string} text1 First string.
+* @param {string} text2 Second string.
+* @return {number} The number of characters common to the start of each
+*     string.
+*/
+function diff_commonPrefix(text1, text2) {
+	// Quick check for common null cases.
+	if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) return 0;
+	// Binary search.
+	// Performance analysis: https://neil.fraser.name/news/2007/10/09/
+	let pointermin = 0;
+	let pointermax = Math.min(text1.length, text2.length);
+	let pointermid = pointermax;
+	let pointerstart = 0;
+	while (pointermin < pointermid) {
+		if (text1.substring(pointerstart, pointermid) === text2.substring(pointerstart, pointermid)) {
+			pointermin = pointermid;
+			pointerstart = pointermin;
+		} else pointermax = pointermid;
+		pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+	}
+	return pointermid;
+}
+/**
+* Determine the common suffix of two strings.
+* @param {string} text1 First string.
+* @param {string} text2 Second string.
+* @return {number} The number of characters common to the end of each string.
+*/
+function diff_commonSuffix(text1, text2) {
+	// Quick check for common null cases.
+	if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) return 0;
+	// Binary search.
+	// Performance analysis: https://neil.fraser.name/news/2007/10/09/
+	let pointermin = 0;
+	let pointermax = Math.min(text1.length, text2.length);
+	let pointermid = pointermax;
+	let pointerend = 0;
+	while (pointermin < pointermid) {
+		if (text1.substring(text1.length - pointermid, text1.length - pointerend) === text2.substring(text2.length - pointermid, text2.length - pointerend)) {
+			pointermin = pointermid;
+			pointerend = pointermin;
+		} else pointermax = pointermid;
+		pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
+	}
+	return pointermid;
+}
+/**
+* Determine if the suffix of one string is the prefix of another.
+* @param {string} text1 First string.
+* @param {string} text2 Second string.
+* @return {number} The number of characters common to the end of the first
+*     string and the start of the second string.
+* @private
+*/
+function diff_commonOverlap_(text1, text2) {
+	// Cache the text lengths to prevent multiple calls.
+	const text1_length = text1.length;
+	const text2_length = text2.length;
+	// Eliminate the null case.
+	if (text1_length === 0 || text2_length === 0) return 0;
+	// Truncate the longer string.
+	if (text1_length > text2_length) text1 = text1.substring(text1_length - text2_length);
+	else if (text1_length < text2_length) text2 = text2.substring(0, text1_length);
+	const text_length = Math.min(text1_length, text2_length);
+	// Quick check for the worst case.
+	if (text1 === text2) return text_length;
+	// Start by looking for a single character match
+	// and increase length until no match is found.
+	// Performance analysis: https://neil.fraser.name/news/2010/11/04/
+	let best = 0;
+	let length = 1;
+	while (true) {
+		const pattern = text1.substring(text_length - length);
+		const found = text2.indexOf(pattern);
+		if (found === -1) return best;
+		length += found;
+		if (found === 0 || text1.substring(text_length - length) === text2.substring(0, length)) {
+			best = length;
+			length++;
+		}
+	}
+}
+/**
+* Reduce the number of edits by eliminating semantically trivial equalities.
+* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+*/
+function diff_cleanupSemantic(diffs) {
+	let changes = false;
+	const equalities = [];
+	let equalitiesLength = 0;
+	/** @type {?string} */
+	let lastEquality = null;
+	// Always equal to diffs[equalities[equalitiesLength - 1]][1]
+	let pointer = 0;
+	// Number of characters that changed prior to the equality.
+	let length_insertions1 = 0;
+	let length_deletions1 = 0;
+	// Number of characters that changed after the equality.
+	let length_insertions2 = 0;
+	let length_deletions2 = 0;
+	while (pointer < diffs.length) {
+		if (diffs[pointer][0] === DIFF_EQUAL) {
+			// Equality found.
+			equalities[equalitiesLength++] = pointer;
+			length_insertions1 = length_insertions2;
+			length_deletions1 = length_deletions2;
+			length_insertions2 = 0;
+			length_deletions2 = 0;
+			lastEquality = diffs[pointer][1];
+		} else {
+			// An insertion or deletion.
+			if (diffs[pointer][0] === DIFF_INSERT) length_insertions2 += diffs[pointer][1].length;
+			else length_deletions2 += diffs[pointer][1].length;
+			// Eliminate an equality that is smaller or equal to the edits on both
+			// sides of it.
+			if (lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2)) {
+				// Duplicate record.
+				diffs.splice(equalities[equalitiesLength - 1], 0, new Diff(DIFF_DELETE, lastEquality));
+				// Change second copy to insert.
+				diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
+				// Throw away the equality we just deleted.
+				equalitiesLength--;
+				// Throw away the previous equality (it needs to be reevaluated).
+				equalitiesLength--;
+				pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
+				length_insertions1 = 0;
+				length_deletions1 = 0;
+				length_insertions2 = 0;
+				length_deletions2 = 0;
+				lastEquality = null;
+				changes = true;
+			}
+		}
+		pointer++;
+	}
+	// Normalize the diff.
+	if (changes) diff_cleanupMerge(diffs);
+	diff_cleanupSemanticLossless(diffs);
+	// Find any overlaps between deletions and insertions.
+	// e.g: <del>abcxxx</del><ins>xxxdef</ins>
+	//   -> <del>abc</del>xxx<ins>def</ins>
+	// e.g: <del>xxxabc</del><ins>defxxx</ins>
+	//   -> <ins>def</ins>xxx<del>abc</del>
+	// Only extract an overlap if it is as big as the edit ahead or behind it.
+	pointer = 1;
+	while (pointer < diffs.length) {
+		if (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
+			const deletion = diffs[pointer - 1][1];
+			const insertion = diffs[pointer][1];
+			const overlap_length1 = diff_commonOverlap_(deletion, insertion);
+			const overlap_length2 = diff_commonOverlap_(insertion, deletion);
+			if (overlap_length1 >= overlap_length2) {
+				if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
+					// Overlap found.  Insert an equality and trim the surrounding edits.
+					diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1)));
+					diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
+					diffs[pointer + 1][1] = insertion.substring(overlap_length1);
+					pointer++;
+				}
+			} else if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
+				// Reverse overlap found.
+				// Insert an equality and swap and trim the surrounding edits.
+				diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2)));
+				diffs[pointer - 1][0] = DIFF_INSERT;
+				diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+				diffs[pointer + 1][0] = DIFF_DELETE;
+				diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+				pointer++;
+			}
+			pointer++;
+		}
+		pointer++;
+	}
+}
+// Define some regex patterns for matching boundaries.
+const nonAlphaNumericRegex_ = /[^a-z0-9]/i;
+const whitespaceRegex_ = /\s/;
+const linebreakRegex_ = /[\r\n]/;
+const blanklineEndRegex_ = /\n\r?\n$/;
+const blanklineStartRegex_ = /^\r?\n\r?\n/;
+/**
+* Look for single edits surrounded on both sides by equalities
+* which can be shifted sideways to align the edit to a word boundary.
+* e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
+* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+*/
+function diff_cleanupSemanticLossless(diffs) {
+	let pointer = 1;
+	// Intentionally ignore the first and last element (don't need checking).
+	while (pointer < diffs.length - 1) {
+		if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+			// This is a single edit surrounded by equalities.
+			let equality1 = diffs[pointer - 1][1];
+			let edit = diffs[pointer][1];
+			let equality2 = diffs[pointer + 1][1];
+			// First, shift the edit as far left as possible.
+			const commonOffset = diff_commonSuffix(equality1, edit);
+			if (commonOffset) {
+				const commonString = edit.substring(edit.length - commonOffset);
+				equality1 = equality1.substring(0, equality1.length - commonOffset);
+				edit = commonString + edit.substring(0, edit.length - commonOffset);
+				equality2 = commonString + equality2;
+			}
+			// Second, step character by character right, looking for the best fit.
+			let bestEquality1 = equality1;
+			let bestEdit = edit;
+			let bestEquality2 = equality2;
+			let bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+			while (edit.charAt(0) === equality2.charAt(0)) {
+				equality1 += edit.charAt(0);
+				edit = edit.substring(1) + equality2.charAt(0);
+				equality2 = equality2.substring(1);
+				const score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);
+				// The >= encourages trailing rather than leading whitespace on edits.
+				if (score >= bestScore) {
+					bestScore = score;
+					bestEquality1 = equality1;
+					bestEdit = edit;
+					bestEquality2 = equality2;
+				}
+			}
+			if (diffs[pointer - 1][1] !== bestEquality1) {
+				// We have an improvement, save it back to the diff.
+				if (bestEquality1) diffs[pointer - 1][1] = bestEquality1;
+				else {
+					diffs.splice(pointer - 1, 1);
+					pointer--;
+				}
+				diffs[pointer][1] = bestEdit;
+				if (bestEquality2) diffs[pointer + 1][1] = bestEquality2;
+				else {
+					diffs.splice(pointer + 1, 1);
+					pointer--;
+				}
+			}
+		}
+		pointer++;
+	}
+}
+/**
+* Reorder and merge like edit sections.  Merge equalities.
+* Any edit section can move as long as it doesn't cross an equality.
+* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
+*/
+function diff_cleanupMerge(diffs) {
+	// Add a dummy entry at the end.
+	diffs.push(new Diff(DIFF_EQUAL, ""));
+	let pointer = 0;
+	let count_delete = 0;
+	let count_insert = 0;
+	let text_delete = "";
+	let text_insert = "";
+	let commonlength;
+	while (pointer < diffs.length) switch (diffs[pointer][0]) {
+		case DIFF_INSERT:
+			count_insert++;
+			text_insert += diffs[pointer][1];
+			pointer++;
+			break;
+		case DIFF_DELETE:
+			count_delete++;
+			text_delete += diffs[pointer][1];
+			pointer++;
+			break;
+		case DIFF_EQUAL:
+			// Upon reaching an equality, check for prior redundancies.
+			if (count_delete + count_insert > 1) {
+				if (count_delete !== 0 && count_insert !== 0) {
+					// Factor out any common prefixes.
+					commonlength = diff_commonPrefix(text_insert, text_delete);
+					if (commonlength !== 0) {
+						if (pointer - count_delete - count_insert > 0 && diffs[pointer - count_delete - count_insert - 1][0] === DIFF_EQUAL) diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
+						else {
+							diffs.splice(0, 0, new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength)));
+							pointer++;
+						}
+						text_insert = text_insert.substring(commonlength);
+						text_delete = text_delete.substring(commonlength);
+					}
+					// Factor out any common suffixes.
+					commonlength = diff_commonSuffix(text_insert, text_delete);
+					if (commonlength !== 0) {
+						diffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];
+						text_insert = text_insert.substring(0, text_insert.length - commonlength);
+						text_delete = text_delete.substring(0, text_delete.length - commonlength);
+					}
+				}
+				// Delete the offending records and add the merged ones.
+				pointer -= count_delete + count_insert;
+				diffs.splice(pointer, count_delete + count_insert);
+				if (text_delete.length) {
+					diffs.splice(pointer, 0, new Diff(DIFF_DELETE, text_delete));
+					pointer++;
+				}
+				if (text_insert.length) {
+					diffs.splice(pointer, 0, new Diff(DIFF_INSERT, text_insert));
+					pointer++;
+				}
+				pointer++;
+			} else if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {
+				// Merge this equality with the previous one.
+				diffs[pointer - 1][1] += diffs[pointer][1];
+				diffs.splice(pointer, 1);
+			} else pointer++;
+			count_insert = 0;
+			count_delete = 0;
+			text_delete = "";
+			text_insert = "";
+			break;
+	}
+	if (diffs.at(-1)?.[1] === "") diffs.pop();
+	// Second pass: look for single edits surrounded on both sides by equalities
+	// which can be shifted sideways to eliminate an equality.
+	// e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
+	let changes = false;
+	pointer = 1;
+	// Intentionally ignore the first and last element (don't need checking).
+	while (pointer < diffs.length - 1) {
+		if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
+			// This is a single edit surrounded by equalities.
+			if (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {
+				// Shift the edit over the previous equality.
+				diffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length);
+				diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
+				diffs.splice(pointer - 1, 1);
+				changes = true;
+			} else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1]) {
+				// Shift the edit over the next equality.
+				diffs[pointer - 1][1] += diffs[pointer + 1][1];
+				diffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];
+				diffs.splice(pointer + 1, 1);
+				changes = true;
+			}
+		}
+		pointer++;
+	}
+	// If shifts were made, the diff needs reordering and another shift sweep.
+	if (changes) diff_cleanupMerge(diffs);
+}
+/**
+* Given two strings, compute a score representing whether the internal
+* boundary falls on logical boundaries.
+* Scores range from 6 (best) to 0 (worst).
+* Closure, but does not reference any external variables.
+* @param {string} one First string.
+* @param {string} two Second string.
+* @return {number} The score.
+* @private
+*/
+function diff_cleanupSemanticScore_(one, two) {
+	if (!one || !two)
+ // Edges are the best.
+	return 6;
+	// Each port of this function behaves slightly differently due to
+	// subtle differences in each language's definition of things like
+	// 'whitespace'.  Since this function's purpose is largely cosmetic,
+	// the choice has been made to use each language's native features
+	// rather than force total conformity.
+	const char1 = one.charAt(one.length - 1);
+	const char2 = two.charAt(0);
+	const nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);
+	const nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);
+	const whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);
+	const whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);
+	const lineBreak1 = whitespace1 && char1.match(linebreakRegex_);
+	const lineBreak2 = whitespace2 && char2.match(linebreakRegex_);
+	const blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);
+	const blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);
+	if (blankLine1 || blankLine2)
+ // Five points for blank lines.
+	return 5;
+	else if (lineBreak1 || lineBreak2)
+ // Four points for line breaks.
+	return 4;
+	else if (nonAlphaNumeric1 && !whitespace1 && whitespace2)
+ // Three points for end of sentences.
+	return 3;
+	else if (whitespace1 || whitespace2)
+ // Two points for whitespace.
+	return 2;
+	else if (nonAlphaNumeric1 || nonAlphaNumeric2)
+ // One point for non-alphanumeric.
+	return 1;
+	return 0;
+}
+
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+const NO_DIFF_MESSAGE = "Compared values have no visual difference.";
+const SIMILAR_MESSAGE = "Compared values serialize to the same structure.\nPrinting internal object structure without calling `toJSON` instead.";
+
+function formatTrailingSpaces(line, trailingSpaceFormatter) {
+	return line.replace(/\s+$/, (match) => trailingSpaceFormatter(match));
+}
+function printDiffLine(line, isFirstOrLast, color, indicator, trailingSpaceFormatter, emptyFirstOrLastLinePlaceholder) {
+	return line.length !== 0 ? color(`${indicator} ${formatTrailingSpaces(line, trailingSpaceFormatter)}`) : indicator !== " " ? color(indicator) : isFirstOrLast && emptyFirstOrLastLinePlaceholder.length !== 0 ? color(`${indicator} ${emptyFirstOrLastLinePlaceholder}`) : "";
+}
+function printDeleteLine(line, isFirstOrLast, { aColor, aIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {
+	return printDiffLine(line, isFirstOrLast, aColor, aIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);
+}
+function printInsertLine(line, isFirstOrLast, { bColor, bIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {
+	return printDiffLine(line, isFirstOrLast, bColor, bIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);
+}
+function printCommonLine(line, isFirstOrLast, { commonColor, commonIndicator, commonLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {
+	return printDiffLine(line, isFirstOrLast, commonColor, commonIndicator, commonLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);
+}
+// In GNU diff format, indexes are one-based instead of zero-based.
+function createPatchMark(aStart, aEnd, bStart, bEnd, { patchColor }) {
+	return patchColor(`@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`);
+}
+// jest --no-expand
+//
+// Given array of aligned strings with inverse highlight formatting,
+// return joined lines with diff formatting (and patch marks, if needed).
+function joinAlignedDiffsNoExpand(diffs, options) {
+	const iLength = diffs.length;
+	const nContextLines = options.contextLines;
+	const nContextLines2 = nContextLines + nContextLines;
+	// First pass: count output lines and see if it has patches.
+	let jLength = iLength;
+	let hasExcessAtStartOrEnd = false;
+	let nExcessesBetweenChanges = 0;
+	let i = 0;
+	while (i !== iLength) {
+		const iStart = i;
+		while (i !== iLength && diffs[i][0] === DIFF_EQUAL) i += 1;
+		if (iStart !== i) if (iStart === 0) {
+			// at start
+			if (i > nContextLines) {
+				jLength -= i - nContextLines;
+				hasExcessAtStartOrEnd = true;
+			}
+		} else if (i === iLength) {
+			// at end
+			const n = i - iStart;
+			if (n > nContextLines) {
+				jLength -= n - nContextLines;
+				hasExcessAtStartOrEnd = true;
+			}
+		} else {
+			// between changes
+			const n = i - iStart;
+			if (n > nContextLines2) {
+				jLength -= n - nContextLines2;
+				nExcessesBetweenChanges += 1;
+			}
+		}
+		while (i !== iLength && diffs[i][0] !== DIFF_EQUAL) i += 1;
+	}
+	const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
+	if (nExcessesBetweenChanges !== 0) jLength += nExcessesBetweenChanges + 1;
+	else if (hasExcessAtStartOrEnd) jLength += 1;
+	const jLast = jLength - 1;
+	const lines = [];
+	let jPatchMark = 0;
+	if (hasPatch) lines.push("");
+	// Indexes of expected or received lines in current patch:
+	let aStart = 0;
+	let bStart = 0;
+	let aEnd = 0;
+	let bEnd = 0;
+	const pushCommonLine = (line) => {
+		const j = lines.length;
+		lines.push(printCommonLine(line, j === 0 || j === jLast, options));
+		aEnd += 1;
+		bEnd += 1;
+	};
+	const pushDeleteLine = (line) => {
+		const j = lines.length;
+		lines.push(printDeleteLine(line, j === 0 || j === jLast, options));
+		aEnd += 1;
+	};
+	const pushInsertLine = (line) => {
+		const j = lines.length;
+		lines.push(printInsertLine(line, j === 0 || j === jLast, options));
+		bEnd += 1;
+	};
+	// Second pass: push lines with diff formatting (and patch marks, if needed).
+	i = 0;
+	while (i !== iLength) {
+		let iStart = i;
+		while (i !== iLength && diffs[i][0] === DIFF_EQUAL) i += 1;
+		if (iStart !== i) if (iStart === 0) {
+			// at beginning
+			if (i > nContextLines) {
+				iStart = i - nContextLines;
+				aStart = iStart;
+				bStart = iStart;
+				aEnd = aStart;
+				bEnd = bStart;
+			}
+			for (let iCommon = iStart; iCommon !== i; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+		} else if (i === iLength) {
+			// at end
+			const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
+			for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+		} else {
+			// between changes
+			const nCommon = i - iStart;
+			if (nCommon > nContextLines2) {
+				const iEnd = iStart + nContextLines;
+				for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+				lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
+				jPatchMark = lines.length;
+				lines.push("");
+				const nOmit = nCommon - nContextLines2;
+				aStart = aEnd + nOmit;
+				bStart = bEnd + nOmit;
+				aEnd = aStart;
+				bEnd = bStart;
+				for (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+			} else for (let iCommon = iStart; iCommon !== i; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+		}
+		while (i !== iLength && diffs[i][0] === DIFF_DELETE) {
+			pushDeleteLine(diffs[i][1]);
+			i += 1;
+		}
+		while (i !== iLength && diffs[i][0] === DIFF_INSERT) {
+			pushInsertLine(diffs[i][1]);
+			i += 1;
+		}
+	}
+	if (hasPatch) lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
+	return lines.join("\n");
+}
+// jest --expand
+//
+// Given array of aligned strings with inverse highlight formatting,
+// return joined lines with diff formatting.
+function joinAlignedDiffsExpand(diffs, options) {
+	return diffs.map((diff, i, diffs) => {
+		const line = diff[1];
+		const isFirstOrLast = i === 0 || i === diffs.length - 1;
+		switch (diff[0]) {
+			case DIFF_DELETE: return printDeleteLine(line, isFirstOrLast, options);
+			case DIFF_INSERT: return printInsertLine(line, isFirstOrLast, options);
+			default: return printCommonLine(line, isFirstOrLast, options);
+		}
+	}).join("\n");
+}
+
+const noColor = (string) => string;
+const DIFF_CONTEXT_DEFAULT = 5;
+const DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;
+function getDefaultOptions() {
+	return {
+		aAnnotation: "Expected",
+		aColor: y.green,
+		aIndicator: "-",
+		bAnnotation: "Received",
+		bColor: y.red,
+		bIndicator: "+",
+		changeColor: y.inverse,
+		changeLineTrailingSpaceColor: noColor,
+		commonColor: y.dim,
+		commonIndicator: " ",
+		commonLineTrailingSpaceColor: noColor,
+		compareKeys: void 0,
+		contextLines: DIFF_CONTEXT_DEFAULT,
+		emptyFirstOrLastLinePlaceholder: "",
+		expand: false,
+		includeChangeCounts: false,
+		omitAnnotationLines: false,
+		patchColor: y.yellow,
+		printBasicPrototype: false,
+		truncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,
+		truncateAnnotation: "... Diff result is truncated",
+		truncateAnnotationColor: noColor
+	};
+}
+function getCompareKeys(compareKeys) {
+	return compareKeys && typeof compareKeys === "function" ? compareKeys : void 0;
+}
+function getContextLines(contextLines) {
+	return typeof contextLines === "number" && Number.isSafeInteger(contextLines) && contextLines >= 0 ? contextLines : DIFF_CONTEXT_DEFAULT;
+}
+// Pure function returns options with all properties.
+function normalizeDiffOptions(options = {}) {
+	return {
+		...getDefaultOptions(),
+		...options,
+		compareKeys: getCompareKeys(options.compareKeys),
+		contextLines: getContextLines(options.contextLines)
+	};
+}
+
+function isEmptyString(lines) {
+	return lines.length === 1 && lines[0].length === 0;
+}
+function countChanges(diffs) {
+	let a = 0;
+	let b = 0;
+	diffs.forEach((diff) => {
+		switch (diff[0]) {
+			case DIFF_DELETE:
+				a += 1;
+				break;
+			case DIFF_INSERT:
+				b += 1;
+				break;
+		}
+	});
+	return {
+		a,
+		b
+	};
+}
+function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
+	if (omitAnnotationLines) return "";
+	let aRest = "";
+	let bRest = "";
+	if (includeChangeCounts) {
+		const aCount = String(changeCounts.a);
+		const bCount = String(changeCounts.b);
+		// Padding right aligns the ends of the annotations.
+		const baAnnotationLengthDiff = bAnnotation.length - aAnnotation.length;
+		const aAnnotationPadding = " ".repeat(Math.max(0, baAnnotationLengthDiff));
+		const bAnnotationPadding = " ".repeat(Math.max(0, -baAnnotationLengthDiff));
+		// Padding left aligns the ends of the counts.
+		const baCountLengthDiff = bCount.length - aCount.length;
+		const aCountPadding = " ".repeat(Math.max(0, baCountLengthDiff));
+		const bCountPadding = " ".repeat(Math.max(0, -baCountLengthDiff));
+		aRest = `${aAnnotationPadding}  ${aIndicator} ${aCountPadding}${aCount}`;
+		bRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;
+	}
+	const a = `${aIndicator} ${aAnnotation}${aRest}`;
+	const b = `${bIndicator} ${bAnnotation}${bRest}`;
+	return `${aColor(a)}\n${bColor(b)}\n\n`;
+}
+function printDiffLines(diffs, truncated, options) {
+	return printAnnotation(options, countChanges(diffs)) + (options.expand ? joinAlignedDiffsExpand(diffs, options) : joinAlignedDiffsNoExpand(diffs, options)) + (truncated ? options.truncateAnnotationColor(`\n${options.truncateAnnotation}`) : "");
+}
+// Compare two arrays of strings line-by-line. Format as comparison lines.
+function diffLinesUnified(aLines, bLines, options) {
+	const normalizedOptions = normalizeDiffOptions(options);
+	const [diffs, truncated] = diffLinesRaw(isEmptyString(aLines) ? [] : aLines, isEmptyString(bLines) ? [] : bLines, normalizedOptions);
+	return printDiffLines(diffs, truncated, normalizedOptions);
+}
+// Given two pairs of arrays of strings:
+// Compare the pair of comparison arrays line-by-line.
+// Format the corresponding lines in the pair of displayable arrays.
+function diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options) {
+	if (isEmptyString(aLinesDisplay) && isEmptyString(aLinesCompare)) {
+		aLinesDisplay = [];
+		aLinesCompare = [];
+	}
+	if (isEmptyString(bLinesDisplay) && isEmptyString(bLinesCompare)) {
+		bLinesDisplay = [];
+		bLinesCompare = [];
+	}
+	if (aLinesDisplay.length !== aLinesCompare.length || bLinesDisplay.length !== bLinesCompare.length)
+ // Fall back to diff of display lines.
+	return diffLinesUnified(aLinesDisplay, bLinesDisplay, options);
+	const [diffs, truncated] = diffLinesRaw(aLinesCompare, bLinesCompare, options);
+	// Replace comparison lines with displayable lines.
+	let aIndex = 0;
+	let bIndex = 0;
+	diffs.forEach((diff) => {
+		switch (diff[0]) {
+			case DIFF_DELETE:
+				diff[1] = aLinesDisplay[aIndex];
+				aIndex += 1;
+				break;
+			case DIFF_INSERT:
+				diff[1] = bLinesDisplay[bIndex];
+				bIndex += 1;
+				break;
+			default:
+				diff[1] = bLinesDisplay[bIndex];
+				aIndex += 1;
+				bIndex += 1;
+		}
+	});
+	return printDiffLines(diffs, truncated, normalizeDiffOptions(options));
+}
+// Compare two arrays of strings line-by-line.
+function diffLinesRaw(aLines, bLines, options) {
+	const truncate = options?.truncateThreshold ?? false;
+	const truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);
+	const aLength = truncate ? Math.min(aLines.length, truncateThreshold) : aLines.length;
+	const bLength = truncate ? Math.min(bLines.length, truncateThreshold) : bLines.length;
+	const truncated = aLength !== aLines.length || bLength !== bLines.length;
+	const isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];
+	const diffs = [];
+	let aIndex = 0;
+	let bIndex = 0;
+	const foundSubsequence = (nCommon, aCommon, bCommon) => {
+		for (; aIndex !== aCommon; aIndex += 1) diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
+		for (; bIndex !== bCommon; bIndex += 1) diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
+		for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) diffs.push(new Diff(DIFF_EQUAL, bLines[bIndex]));
+	};
+	diffSequences(aLength, bLength, isCommon, foundSubsequence);
+	// After the last common subsequence, push remaining change items.
+	for (; aIndex !== aLength; aIndex += 1) diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
+	for (; bIndex !== bLength; bIndex += 1) diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
+	return [diffs, truncated];
+}
+
+// get the type of a value with handling the edge cases like `typeof []`
+// and `typeof null`
+function getType(value) {
+	if (value === void 0) return "undefined";
+	else if (value === null) return "null";
+	else if (Array.isArray(value)) return "array";
+	else if (typeof value === "boolean") return "boolean";
+	else if (typeof value === "function") return "function";
+	else if (typeof value === "number") return "number";
+	else if (typeof value === "string") return "string";
+	else if (typeof value === "bigint") return "bigint";
+	else if (typeof value === "object") {
+		if (value != null) {
+			if (value.constructor === RegExp) return "regexp";
+			else if (value.constructor === Map) return "map";
+			else if (value.constructor === Set) return "set";
+			else if (value.constructor === Date) return "date";
+		}
+		return "object";
+	} else if (typeof value === "symbol") return "symbol";
+	throw new Error(`value of unknown type: ${value}`);
+}
+
+// platforms compatible
+function getNewLineSymbol(string) {
+	return string.includes("\r\n") ? "\r\n" : "\n";
+}
+function diffStrings(a, b, options) {
+	const truncate = options?.truncateThreshold ?? false;
+	const truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);
+	let aLength = a.length;
+	let bLength = b.length;
+	if (truncate) {
+		const aMultipleLines = a.includes("\n");
+		const bMultipleLines = b.includes("\n");
+		const aNewLineSymbol = getNewLineSymbol(a);
+		const bNewLineSymbol = getNewLineSymbol(b);
+		// multiple-lines string expects a newline to be appended at the end
+		const _a = aMultipleLines ? `${a.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}\n` : a;
+		const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}\n` : b;
+		aLength = _a.length;
+		bLength = _b.length;
+	}
+	const truncated = aLength !== a.length || bLength !== b.length;
+	const isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];
+	let aIndex = 0;
+	let bIndex = 0;
+	const diffs = [];
+	const foundSubsequence = (nCommon, aCommon, bCommon) => {
+		if (aIndex !== aCommon) diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex, aCommon)));
+		if (bIndex !== bCommon) diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
+		aIndex = aCommon + nCommon;
+		bIndex = bCommon + nCommon;
+		diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
+	};
+	diffSequences(aLength, bLength, isCommon, foundSubsequence);
+	// After the last common subsequence, push remaining change items.
+	if (aIndex !== aLength) diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
+	if (bIndex !== bLength) diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
+	return [diffs, truncated];
+}
+
+// Given change op and array of diffs, return concatenated string:
+// * include common strings
+// * include change strings which have argument op with changeColor
+// * exclude change strings which have opposite op
+function concatenateRelevantDiffs(op, diffs, changeColor) {
+	return diffs.reduce((reduced, diff) => reduced + (diff[0] === DIFF_EQUAL ? diff[1] : diff[0] === op && diff[1].length !== 0 ? changeColor(diff[1]) : ""), "");
+}
+// Encapsulate change lines until either a common newline or the end.
+class ChangeBuffer {
+	op;
+	line;
+	lines;
+	changeColor;
+	constructor(op, changeColor) {
+		this.op = op;
+		this.line = [];
+		this.lines = [];
+		this.changeColor = changeColor;
+	}
+	pushSubstring(substring) {
+		this.pushDiff(new Diff(this.op, substring));
+	}
+	pushLine() {
+		// Assume call only if line has at least one diff,
+		// therefore an empty line must have a diff which has an empty string.
+		// If line has multiple diffs, then assume it has a common diff,
+		// therefore change diffs have change color;
+		// otherwise then it has line color only.
+		this.lines.push(this.line.length !== 1 ? new Diff(this.op, concatenateRelevantDiffs(this.op, this.line, this.changeColor)) : this.line[0][0] === this.op ? this.line[0] : new Diff(this.op, this.line[0][1]));
+		this.line.length = 0;
+	}
+	isLineEmpty() {
+		return this.line.length === 0;
+	}
+	// Minor input to buffer.
+	pushDiff(diff) {
+		this.line.push(diff);
+	}
+	// Main input to buffer.
+	align(diff) {
+		const string = diff[1];
+		if (string.includes("\n")) {
+			const substrings = string.split("\n");
+			const iLast = substrings.length - 1;
+			substrings.forEach((substring, i) => {
+				if (i < iLast) {
+					// The first substring completes the current change line.
+					// A middle substring is a change line.
+					this.pushSubstring(substring);
+					this.pushLine();
+				} else if (substring.length !== 0)
+ // The last substring starts a change line, if it is not empty.
+				// Important: This non-empty condition also automatically omits
+				// the newline appended to the end of expected and received strings.
+				this.pushSubstring(substring);
+			});
+		} else
+ // Append non-multiline string to current change line.
+		this.pushDiff(diff);
+	}
+	// Output from buffer.
+	moveLinesTo(lines) {
+		if (!this.isLineEmpty()) this.pushLine();
+		lines.push(...this.lines);
+		this.lines.length = 0;
+	}
+}
+// Encapsulate common and change lines.
+class CommonBuffer {
+	deleteBuffer;
+	insertBuffer;
+	lines;
+	constructor(deleteBuffer, insertBuffer) {
+		this.deleteBuffer = deleteBuffer;
+		this.insertBuffer = insertBuffer;
+		this.lines = [];
+	}
+	pushDiffCommonLine(diff) {
+		this.lines.push(diff);
+	}
+	pushDiffChangeLines(diff) {
+		const isDiffEmpty = diff[1].length === 0;
+		// An empty diff string is redundant, unless a change line is empty.
+		if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) this.deleteBuffer.pushDiff(diff);
+		if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) this.insertBuffer.pushDiff(diff);
+	}
+	flushChangeLines() {
+		this.deleteBuffer.moveLinesTo(this.lines);
+		this.insertBuffer.moveLinesTo(this.lines);
+	}
+	// Input to buffer.
+	align(diff) {
+		const op = diff[0];
+		const string = diff[1];
+		if (string.includes("\n")) {
+			const substrings = string.split("\n");
+			const iLast = substrings.length - 1;
+			substrings.forEach((substring, i) => {
+				if (i === 0) {
+					const subdiff = new Diff(op, substring);
+					if (this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty()) {
+						// If both current change lines are empty,
+						// then the first substring is a common line.
+						this.flushChangeLines();
+						this.pushDiffCommonLine(subdiff);
+					} else {
+						// If either current change line is non-empty,
+						// then the first substring completes the change lines.
+						this.pushDiffChangeLines(subdiff);
+						this.flushChangeLines();
+					}
+				} else if (i < iLast)
+ // A middle substring is a common line.
+				this.pushDiffCommonLine(new Diff(op, substring));
+				else if (substring.length !== 0)
+ // The last substring starts a change line, if it is not empty.
+				// Important: This non-empty condition also automatically omits
+				// the newline appended to the end of expected and received strings.
+				this.pushDiffChangeLines(new Diff(op, substring));
+			});
+		} else
+ // Append non-multiline string to current change lines.
+		// Important: It cannot be at the end following empty change lines,
+		// because newline appended to the end of expected and received strings.
+		this.pushDiffChangeLines(diff);
+	}
+	// Output from buffer.
+	getLines() {
+		this.flushChangeLines();
+		return this.lines;
+	}
+}
+// Given diffs from expected and received strings,
+// return new array of diffs split or joined into lines.
+//
+// To correctly align a change line at the end, the algorithm:
+// * assumes that a newline was appended to the strings
+// * omits the last newline from the output array
+//
+// Assume the function is not called:
+// * if either expected or received is empty string
+// * if neither expected nor received is multiline string
+function getAlignedDiffs(diffs, changeColor) {
+	const deleteBuffer = new ChangeBuffer(DIFF_DELETE, changeColor);
+	const insertBuffer = new ChangeBuffer(DIFF_INSERT, changeColor);
+	const commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);
+	diffs.forEach((diff) => {
+		switch (diff[0]) {
+			case DIFF_DELETE:
+				deleteBuffer.align(diff);
+				break;
+			case DIFF_INSERT:
+				insertBuffer.align(diff);
+				break;
+			default: commonBuffer.align(diff);
+		}
+	});
+	return commonBuffer.getLines();
+}
+
+function hasCommonDiff(diffs, isMultiline) {
+	if (isMultiline) {
+		// Important: Ignore common newline that was appended to multiline strings!
+		const iLast = diffs.length - 1;
+		return diffs.some((diff, i) => diff[0] === DIFF_EQUAL && (i !== iLast || diff[1] !== "\n"));
+	}
+	return diffs.some((diff) => diff[0] === DIFF_EQUAL);
+}
+// Compare two strings character-by-character.
+// Format as comparison lines in which changed substrings have inverse colors.
+function diffStringsUnified(a, b, options) {
+	if (a !== b && a.length !== 0 && b.length !== 0) {
+		const isMultiline = a.includes("\n") || b.includes("\n");
+		// getAlignedDiffs assumes that a newline was appended to the strings.
+		const [diffs, truncated] = diffStringsRaw(isMultiline ? `${a}\n` : a, isMultiline ? `${b}\n` : b, true, options);
+		if (hasCommonDiff(diffs, isMultiline)) {
+			const optionsNormalized = normalizeDiffOptions(options);
+			return printDiffLines(getAlignedDiffs(diffs, optionsNormalized.changeColor), truncated, optionsNormalized);
+		}
+	}
+	// Fall back to line-by-line diff.
+	return diffLinesUnified(a.split("\n"), b.split("\n"), options);
+}
+// Compare two strings character-by-character.
+// Optionally clean up small common substrings, also known as chaff.
+function diffStringsRaw(a, b, cleanup, options) {
+	const [diffs, truncated] = diffStrings(a, b, options);
+	diff_cleanupSemantic(diffs);
+	return [diffs, truncated];
+}
+
+function getCommonMessage(message, options) {
+	const { commonColor } = normalizeDiffOptions(options);
+	return commonColor(message);
+}
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher,
+	plugins.Error
+];
+const FORMAT_OPTIONS = {
+	maxDepth: 20,
+	plugins: PLUGINS
+};
+const FALLBACK_FORMAT_OPTIONS = {
+	callToJSON: false,
+	maxDepth: 8,
+	plugins: PLUGINS
+};
+const DEFAULT_MEMORIZE = (_, v) => v;
+// Generate a string that will highlight the difference between two values
+// with green and red. (similar to how github does code diffing)
+/**
+* @param a Expected value
+* @param b Received value
+* @param options Diff options
+* @returns {string | null} a string diff
+*/
+function diff(a, b, options, memorize = DEFAULT_MEMORIZE) {
+	if (Object.is(a, b)) return "";
+	const aType = getType(a);
+	let expectedType = aType;
+	let omitDifference = false;
+	if (aType === "object" && typeof a.asymmetricMatch === "function") {
+		if (a.$$typeof !== Symbol.for("jest.asymmetricMatcher"))
+ // Do not know expected type of user-defined asymmetric matcher.
+		return;
+		if (typeof a.getExpectedType !== "function")
+ // For example, expect.anything() matches either null or undefined
+		return;
+		expectedType = a.getExpectedType();
+		// Primitive types boolean and number omit difference below.
+		// For example, omit difference for expect.stringMatching(regexp)
+		omitDifference = expectedType === "string";
+	}
+	if (expectedType !== getType(b)) {
+		const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
+		const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
+		let aDisplay = format(a, formatOptions);
+		let bDisplay = format(b, formatOptions);
+		// even if prettyFormat prints successfully big objects,
+		// large string can choke later on (concatenation? RPC?),
+		// so truncate it to a reasonable length here.
+		// (For example, playwright's ElementHandle can become about 200_000_000 length string)
+		const MAX_LENGTH = 1e5;
+		function truncate(s) {
+			return s.length <= MAX_LENGTH ? s : `${s.slice(0, MAX_LENGTH)}...`;
+		}
+		aDisplay = memorize("expected", truncate(aDisplay));
+		bDisplay = memorize("actual", truncate(bDisplay));
+		return `${`${aColor(`${aIndicator} ${aAnnotation}:`)}\n${aDisplay}`}\n\n${`${bColor(`${bIndicator} ${bAnnotation}:`)}\n${bDisplay}`}`;
+	}
+	if (omitDifference) return;
+	switch (aType) {
+		case "string": return diffLinesUnified(a.split("\n"), b.split("\n"), options);
+		case "boolean":
+		case "number": return comparePrimitive(a, b, options, memorize);
+		case "map": return compareObjects(sortMap(a), sortMap(b), options, memorize);
+		case "set": return compareObjects(sortSet(a), sortSet(b), options, memorize);
+		default: return compareObjects(a, b, options, memorize);
+	}
+}
+function createMemorize(memory) {
+	return (pointer, stringifiedValue) => {
+		memory[pointer] = stringifiedValue;
+		return stringifiedValue;
+	};
+}
+function comparePrimitive(a, b, options, memorize = DEFAULT_MEMORIZE) {
+	const aFormat = memorize("expected", format(a, FORMAT_OPTIONS));
+	const bFormat = memorize("actual", format(b, FORMAT_OPTIONS));
+	return aFormat === bFormat ? "" : diffLinesUnified(aFormat.split("\n"), bFormat.split("\n"), options);
+}
+function sortMap(map) {
+	return new Map(Array.from(map.entries()).sort());
+}
+function sortSet(set) {
+	return new Set(Array.from(set.values()).sort());
+}
+function compareObjects(a, b, options, memorize = DEFAULT_MEMORIZE) {
+	let difference;
+	let hasThrown = false;
+	try {
+		difference = getObjectsDifference(a, b, getFormatOptions(FORMAT_OPTIONS, options), options, memorize);
+	} catch {
+		hasThrown = true;
+	}
+	const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
+	// If the comparison yields no results, compare again but this time
+	// without calling `toJSON`. It's also possible that toJSON might throw.
+	if (difference === void 0 || difference === noDiffMessage) {
+		difference = getObjectsDifference(a, b, getFormatOptions(FALLBACK_FORMAT_OPTIONS, options), options, memorize);
+		if (difference !== noDiffMessage && !hasThrown) difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}\n\n${difference}`;
+	}
+	return difference;
+}
+function getDefaultFormatOptions(options) {
+	return getFormatOptions(FORMAT_OPTIONS, options);
+}
+function getFormatOptions(formatOptions, options) {
+	const { compareKeys, printBasicPrototype, maxDepth } = normalizeDiffOptions(options);
+	return {
+		...formatOptions,
+		compareKeys,
+		printBasicPrototype,
+		maxDepth: maxDepth ?? formatOptions.maxDepth
+	};
+}
+function getObjectsDifference(a, b, formatOptions, options, memorize = DEFAULT_MEMORIZE) {
+	const formatOptionsZeroIndent = {
+		...formatOptions,
+		indent: 0
+	};
+	const aCompare = format(a, formatOptionsZeroIndent);
+	const bCompare = format(b, formatOptionsZeroIndent);
+	if (aCompare === bCompare) return getCommonMessage(NO_DIFF_MESSAGE, options);
+	else {
+		const aDisplay = memorize("expected", format(a, formatOptions));
+		const bDisplay = memorize("actual", format(b, formatOptions));
+		return diffLinesUnified2(aDisplay.split("\n"), bDisplay.split("\n"), aCompare.split("\n"), bCompare.split("\n"), options);
+	}
+}
+const MAX_DIFF_STRING_LENGTH = 2e4;
+function isAsymmetricMatcher(data) {
+	return getType$1(data) === "Object" && typeof data.asymmetricMatch === "function";
+}
+function isReplaceable(obj1, obj2) {
+	const obj1Type = getType$1(obj1);
+	return obj1Type === getType$1(obj2) && (obj1Type === "Object" || obj1Type === "Array");
+}
+function printDiffOrStringify(received, expected, options, memory) {
+	const { aAnnotation, bAnnotation } = normalizeDiffOptions(options);
+	if (typeof expected === "string" && typeof received === "string" && expected.length > 0 && received.length > 0 && expected.length <= MAX_DIFF_STRING_LENGTH && received.length <= MAX_DIFF_STRING_LENGTH && expected !== received) {
+		if (expected.includes("\n") || received.includes("\n")) return diffStringsUnified(expected, received, options);
+		const [diffs] = diffStringsRaw(expected, received);
+		const hasCommonDiff = diffs.some((diff) => diff[0] === DIFF_EQUAL);
+		const printLabel = getLabelPrinter(aAnnotation, bAnnotation);
+		return `${printLabel(aAnnotation) + printExpected(getCommonAndChangedSubstrings(diffs, DIFF_DELETE, hasCommonDiff))}\n${printLabel(bAnnotation) + printReceived(getCommonAndChangedSubstrings(diffs, DIFF_INSERT, hasCommonDiff))}`;
+	}
+	// if (isLineDiffable(expected, received)) {
+	const clonedExpected = deepClone(expected, { forceWritable: true });
+	const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(deepClone(received, { forceWritable: true }), clonedExpected);
+	return diff(replacedExpected, replacedActual, options, memory ? createMemorize(memory) : DEFAULT_MEMORIZE);
+	// }
+	// const printLabel = getLabelPrinter(aAnnotation, bAnnotation)
+	// const expectedLine = printLabel(aAnnotation) + printExpected(expected)
+	// const receivedLine
+	//   = printLabel(bAnnotation)
+	//   + (stringify(expected) === stringify(received)
+	//     ? 'serializes to the same string'
+	//     : printReceived(received))
+	// return `${expectedLine}\n${receivedLine}`
+}
+function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
+	// handle asymmetric Error.cause diff
+	if (actual instanceof Error && expected instanceof Error && typeof actual.cause !== "undefined" && typeof expected.cause === "undefined") {
+		delete actual.cause;
+		return {
+			replacedActual: actual,
+			replacedExpected: expected
+		};
+	}
+	if (!isReplaceable(actual, expected)) return {
+		replacedActual: actual,
+		replacedExpected: expected
+	};
+	if (actualReplaced.has(actual) || expectedReplaced.has(expected)) return {
+		replacedActual: actual,
+		replacedExpected: expected
+	};
+	actualReplaced.add(actual);
+	expectedReplaced.add(expected);
+	getOwnProperties(expected).forEach((key) => {
+		const expectedValue = expected[key];
+		const actualValue = actual[key];
+		if (isAsymmetricMatcher(expectedValue)) {
+			if (expectedValue.asymmetricMatch(actualValue))
+ // When matcher matches, replace expected with actual value
+			// so they appear the same in the diff
+			expected[key] = actualValue;
+			else if ("sample" in expectedValue && expectedValue.sample !== void 0 && isReplaceable(actualValue, expectedValue.sample)) {
+				// For container matchers (ArrayContaining, ObjectContaining), unwrap and recursively process
+				// Matcher doesn't match: unwrap but keep structure to show mismatch
+				const replaced = replaceAsymmetricMatcher(actualValue, expectedValue.sample, actualReplaced, expectedReplaced);
+				actual[key] = replaced.replacedActual;
+				expected[key] = replaced.replacedExpected;
+			}
+		} else if (isAsymmetricMatcher(actualValue)) {
+			if (actualValue.asymmetricMatch(expectedValue)) actual[key] = expectedValue;
+			else if ("sample" in actualValue && actualValue.sample !== void 0 && isReplaceable(actualValue.sample, expectedValue)) {
+				const replaced = replaceAsymmetricMatcher(actualValue.sample, expectedValue, actualReplaced, expectedReplaced);
+				actual[key] = replaced.replacedActual;
+				expected[key] = replaced.replacedExpected;
+			}
+		} else if (isReplaceable(actualValue, expectedValue)) {
+			const replaced = replaceAsymmetricMatcher(actualValue, expectedValue, actualReplaced, expectedReplaced);
+			actual[key] = replaced.replacedActual;
+			expected[key] = replaced.replacedExpected;
+		}
+	});
+	return {
+		replacedActual: actual,
+		replacedExpected: expected
+	};
+}
+function getLabelPrinter(...strings) {
+	const maxLength = strings.reduce((max, string) => string.length > max ? string.length : max, 0);
+	return (string) => `${string}: ${" ".repeat(maxLength - string.length)}`;
+}
+const SPACE_SYMBOL = "·";
+function replaceTrailingSpaces(text) {
+	return text.replace(/\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));
+}
+function printReceived(object) {
+	return y.red(replaceTrailingSpaces(stringify(object)));
+}
+function printExpected(value) {
+	return y.green(replaceTrailingSpaces(stringify(value)));
+}
+function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff) {
+	return diffs.reduce((reduced, diff) => reduced + (diff[0] === DIFF_EQUAL ? diff[1] : diff[0] === op ? hasCommonDiff ? y.inverse(diff[1]) : diff[1] : ""), "");
+}
+
+function processError(_err, diffOptions, seen = /* @__PURE__ */ new WeakSet()) {
+	if (!_err || typeof _err !== "object") return { message: String(_err) };
+	const err = _err;
+	if (err.showDiff || err.showDiff === void 0 && err.expected !== void 0 && err.actual !== void 0) {
+		const options = {
+			...diffOptions,
+			...err.diffOptions
+		};
+		err.diff = printDiffOrStringify(err.actual, err.expected, options, err);
+		err.expected = prettifyValue(err.expected, options);
+		err.actual = prettifyValue(err.actual, options);
+	}
+	// some Error implementations may not allow rewriting cause
+	// in most cases, the assignment will lead to "err.cause = err.cause"
+	try {
+		if (!seen.has(err) && typeof err.cause === "object") {
+			seen.add(err);
+			err.cause = processError(err.cause, diffOptions, seen);
+		}
+	} catch {}
+	try {
+		return serializeValue(err);
+	} catch (e) {
+		return serializeValue(/* @__PURE__ */ new Error(`Failed to fully serialize error: ${e?.message}\nInner error message: ${err?.message}`));
+	}
+}
+function prettifyValue(value, options) {
+	if (typeof value !== "string") return format(value, getDefaultFormatOptions(options));
+	return value;
+}
 
 let _test;
 function setCurrentTest(test) {
@@ -1680,7 +2977,7 @@ function formatTitle(template, items, idx) {
 	const inspectOptions = { truncate: runner.config.taskTitleValueFormatTruncate };
 	const isObjectItem = isObject(items[0]);
 	function formatAttribute(s) {
-		return s.replace(/\$([$\w.]+)/g, (_, key) => {
+		return s.replace(/\$([$\p{ID_Continue}.]+)/gu, (_, key) => {
 			const isArrayKey = /^\d+$/.test(key);
 			if (!isObjectItem && !isArrayKey) return `$${key}`;
 			const arrayElement = isArrayKey ? objectAttr(items, key) : void 0;
@@ -1697,7 +2994,7 @@ function formatTitle(template, items, idx) {
 		formatRegExp,
 		// format "%"
 		(match) => {
-			if (i < count) output += format([match[0], items[i++]], inspectOptions);
+			if (i < count) output += format$1([match[0], items[i++]], inspectOptions);
 			else output += match[0];
 		},
 		// format "$"
@@ -2767,4 +4064,4 @@ function manageArtifactAttachment(attachment) {
 	if (attachment.body != null) attachment.bodyEncoding ??= "base64";
 }
 
-export { TestSyntaxError as T, getCurrentSuite as a, createChainable as b, createTaskCollector as c, getHooks as d, getFn as e, afterAll as f, getCurrentTest as g, afterEach as h, aroundAll as i, aroundEach as j, beforeAll as k, beforeEach as l, matchesTags as m, describe as n, it as o, publicCollect as p, onTestFailed as q, onTestFinished as r, startTests as s, recordArtifact as t, suite as u, test as v, validateTags as w, limitConcurrency as x, createTagsFilter as y };
+export { limitConcurrency as A, shuffle as B, createTagsFilter as C, TestSyntaxError as T, processError as a, printDiffOrStringify as b, createTaskCollector as c, diff as d, getCurrentSuite as e, createChainable as f, getCurrentTest as g, getHooks as h, getFn as i, afterAll as j, afterEach as k, aroundAll as l, matchesTags as m, aroundEach as n, beforeAll as o, publicCollect as p, beforeEach as q, describe as r, startTests as s, it as t, onTestFailed as u, onTestFinished as v, recordArtifact as w, suite as x, test as y, validateTags as z };