@cartanova/qgrid-cli 2.4.8 → 2.4.9

package/bundle/dist/node_modules/.pnpm/@vitest_utils@4.1.10/node_modules/@vitest/utils/dist/diff.js

@@ -0,0 +1,1317 @@
+import y from "../../../../../tinyrainbow@3.1.0/node_modules/tinyrainbow/dist/index.js";
+import { format, plugins } from "../../../../../@vitest_pretty-format@4.1.10/node_modules/@vitest/pretty-format/dist/index.js";
+import { stringify } from "./display.js";
+import "./constants.js";
+import { deepClone, getOwnProperties, getType as getType$1 } from "./helpers.js";
+/**
+* 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
+*/
+var Diff = class {
+	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) {
+	if (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) return 0;
+	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) {
+	if (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) return 0;
+	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) {
+	const text1_length = text1.length;
+	const text2_length = text2.length;
+	if (text1_length === 0 || text2_length === 0) return 0;
+	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);
+	if (text1 === text2) return text_length;
+	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;
+	let pointer = 0;
+	let length_insertions1 = 0;
+	let length_deletions1 = 0;
+	let length_insertions2 = 0;
+	let length_deletions2 = 0;
+	while (pointer < diffs.length) {
+		if (diffs[pointer][0] === 0) {
+			equalities[equalitiesLength++] = pointer;
+			length_insertions1 = length_insertions2;
+			length_deletions1 = length_deletions2;
+			length_insertions2 = 0;
+			length_deletions2 = 0;
+			lastEquality = diffs[pointer][1];
+		} else {
+			if (diffs[pointer][0] === 1) length_insertions2 += diffs[pointer][1].length;
+			else length_deletions2 += diffs[pointer][1].length;
+			if (lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2)) {
+				diffs.splice(equalities[equalitiesLength - 1], 0, new Diff(-1, lastEquality));
+				diffs[equalities[equalitiesLength - 1] + 1][0] = 1;
+				equalitiesLength--;
+				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++;
+	}
+	if (changes) diff_cleanupMerge(diffs);
+	diff_cleanupSemanticLossless(diffs);
+	pointer = 1;
+	while (pointer < diffs.length) {
+		if (diffs[pointer - 1][0] === -1 && diffs[pointer][0] === 1) {
+			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) {
+					diffs.splice(pointer, 0, new Diff(0, 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) {
+				diffs.splice(pointer, 0, new Diff(0, deletion.substring(0, overlap_length2)));
+				diffs[pointer - 1][0] = 1;
+				diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
+				diffs[pointer + 1][0] = -1;
+				diffs[pointer + 1][1] = deletion.substring(overlap_length2);
+				pointer++;
+			}
+			pointer++;
+		}
+		pointer++;
+	}
+}
+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;
+	while (pointer < diffs.length - 1) {
+		if (diffs[pointer - 1][0] === 0 && diffs[pointer + 1][0] === 0) {
+			let equality1 = diffs[pointer - 1][1];
+			let edit = diffs[pointer][1];
+			let equality2 = diffs[pointer + 1][1];
+			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;
+			}
+			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);
+				if (score >= bestScore) {
+					bestScore = score;
+					bestEquality1 = equality1;
+					bestEdit = edit;
+					bestEquality2 = equality2;
+				}
+			}
+			if (diffs[pointer - 1][1] !== bestEquality1) {
+				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) {
+	diffs.push(new Diff(0, ""));
+	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 1:
+			count_insert++;
+			text_insert += diffs[pointer][1];
+			pointer++;
+			break;
+		case -1:
+			count_delete++;
+			text_delete += diffs[pointer][1];
+			pointer++;
+			break;
+		case 0:
+			if (count_delete + count_insert > 1) {
+				if (count_delete !== 0 && count_insert !== 0) {
+					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] === 0) diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
+						else {
+							diffs.splice(0, 0, new Diff(0, text_insert.substring(0, commonlength)));
+							pointer++;
+						}
+						text_insert = text_insert.substring(commonlength);
+						text_delete = text_delete.substring(commonlength);
+					}
+					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);
+					}
+				}
+				pointer -= count_delete + count_insert;
+				diffs.splice(pointer, count_delete + count_insert);
+				if (text_delete.length) {
+					diffs.splice(pointer, 0, new Diff(-1, text_delete));
+					pointer++;
+				}
+				if (text_insert.length) {
+					diffs.splice(pointer, 0, new Diff(1, text_insert));
+					pointer++;
+				}
+				pointer++;
+			} else if (pointer !== 0 && diffs[pointer - 1][0] === 0) {
+				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();
+	let changes = false;
+	pointer = 1;
+	while (pointer < diffs.length - 1) {
+		if (diffs[pointer - 1][0] === 0 && diffs[pointer + 1][0] === 0) {
+			if (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {
+				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]) {
+				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 (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) return 6;
+	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) return 5;
+	else if (lineBreak1 || lineBreak2) return 4;
+	else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) return 3;
+	else if (whitespace1 || whitespace2) return 2;
+	else if (nonAlphaNumeric1 || nonAlphaNumeric2) 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 getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var build = {};
+var hasRequiredBuild;
+function requireBuild() {
+	if (hasRequiredBuild) return build;
+	hasRequiredBuild = 1;
+	Object.defineProperty(build, "__esModule", { value: true });
+	build.default = diffSequence;
+	/**
+	* 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 pkg = "diff-sequences";
+	const NOT_YET_SET = 0;
+	const countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {
+		let nCommon = 0;
+		while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {
+			aIndex += 1;
+			bIndex += 1;
+			nCommon += 1;
+		}
+		return nCommon;
+	};
+	const countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {
+		let nCommon = 0;
+		while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {
+			aIndex -= 1;
+			bIndex -= 1;
+			nCommon += 1;
+		}
+		return nCommon;
+	};
+	const extendPathsF = (d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF) => {
+		let iF = 0;
+		let kF = -d;
+		let aFirst = aIndexesF[iF];
+		let aIndexPrev1 = aFirst;
+		aIndexesF[iF] += countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
+		const nF = d < iMaxF ? d : iMaxF;
+		for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
+			if (iF !== d && aIndexPrev1 < aIndexesF[iF]) aFirst = aIndexesF[iF];
+			else {
+				aFirst = aIndexPrev1 + 1;
+				if (aEnd <= aFirst) return iF - 1;
+			}
+			aIndexPrev1 = aIndexesF[iF];
+			aIndexesF[iF] = aFirst + countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
+		}
+		return iMaxF;
+	};
+	const extendPathsR = (d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR) => {
+		let iR = 0;
+		let kR = d;
+		let aFirst = aIndexesR[iR];
+		let aIndexPrev1 = aFirst;
+		aIndexesR[iR] -= countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
+		const nR = d < iMaxR ? d : iMaxR;
+		for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
+			if (iR !== d && aIndexesR[iR] < aIndexPrev1) aFirst = aIndexesR[iR];
+			else {
+				aFirst = aIndexPrev1 - 1;
+				if (aFirst < aStart) return iR - 1;
+			}
+			aIndexPrev1 = aIndexesR[iR];
+			aIndexesR[iR] = aFirst - countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
+		}
+		return iMaxR;
+	};
+	const extendOverlappablePathsF = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+		const bF = bStart - aStart;
+		const aLength = aEnd - aStart;
+		const baDeltaLength = bEnd - bStart - aLength;
+		const kMinOverlapF = -baDeltaLength - (d - 1);
+		const kMaxOverlapF = -baDeltaLength + (d - 1);
+		let aIndexPrev1 = NOT_YET_SET;
+		const nF = d < iMaxF ? d : iMaxF;
+		for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
+			const insert = iF === 0 || iF !== d && aIndexPrev1 < aIndexesF[iF];
+			const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;
+			const aFirst = insert ? aLastPrev : aLastPrev + 1;
+			const bFirst = bF + aFirst - kF;
+			const nCommonF = countCommonItemsF(aFirst + 1, aEnd, bFirst + 1, bEnd, isCommon);
+			const aLast = aFirst + nCommonF;
+			aIndexPrev1 = aIndexesF[iF];
+			aIndexesF[iF] = aLast;
+			if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {
+				const iR = (d - 1 - (kF + baDeltaLength)) / 2;
+				if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
+					const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);
+					const nCommonR = countCommonItemsR(aStart, aLastPrev, bStart, bLastPrev, isCommon);
+					const aIndexPrevFirst = aLastPrev - nCommonR;
+					const bIndexPrevFirst = bLastPrev - nCommonR;
+					const aEndPreceding = aIndexPrevFirst + 1;
+					const bEndPreceding = bIndexPrevFirst + 1;
+					division.nChangePreceding = d - 1;
+					if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {
+						division.aEndPreceding = aStart;
+						division.bEndPreceding = bStart;
+					} else {
+						division.aEndPreceding = aEndPreceding;
+						division.bEndPreceding = bEndPreceding;
+					}
+					division.nCommonPreceding = nCommonR;
+					if (nCommonR !== 0) {
+						division.aCommonPreceding = aEndPreceding;
+						division.bCommonPreceding = bEndPreceding;
+					}
+					division.nCommonFollowing = nCommonF;
+					if (nCommonF !== 0) {
+						division.aCommonFollowing = aFirst + 1;
+						division.bCommonFollowing = bFirst + 1;
+					}
+					const aStartFollowing = aLast + 1;
+					const bStartFollowing = bFirst + nCommonF + 1;
+					division.nChangeFollowing = d - 1;
+					if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+						division.aStartFollowing = aEnd;
+						division.bStartFollowing = bEnd;
+					} else {
+						division.aStartFollowing = aStartFollowing;
+						division.bStartFollowing = bStartFollowing;
+					}
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+	const extendOverlappablePathsR = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division) => {
+		const bR = bEnd - aEnd;
+		const aLength = aEnd - aStart;
+		const baDeltaLength = bEnd - bStart - aLength;
+		const kMinOverlapR = baDeltaLength - d;
+		const kMaxOverlapR = baDeltaLength + d;
+		let aIndexPrev1 = NOT_YET_SET;
+		const nR = d < iMaxR ? d : iMaxR;
+		for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
+			const insert = iR === 0 || iR !== d && aIndexesR[iR] < aIndexPrev1;
+			const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;
+			const aFirst = insert ? aLastPrev : aLastPrev - 1;
+			const bFirst = bR + aFirst - kR;
+			const nCommonR = countCommonItemsR(aStart, aFirst - 1, bStart, bFirst - 1, isCommon);
+			const aLast = aFirst - nCommonR;
+			aIndexPrev1 = aIndexesR[iR];
+			aIndexesR[iR] = aLast;
+			if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {
+				const iF = (d + (kR - baDeltaLength)) / 2;
+				if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
+					const bLast = bFirst - nCommonR;
+					division.nChangePreceding = d;
+					if (d === aLast + bLast - aStart - bStart) {
+						division.aEndPreceding = aStart;
+						division.bEndPreceding = bStart;
+					} else {
+						division.aEndPreceding = aLast;
+						division.bEndPreceding = bLast;
+					}
+					division.nCommonPreceding = nCommonR;
+					if (nCommonR !== 0) {
+						division.aCommonPreceding = aLast;
+						division.bCommonPreceding = bLast;
+					}
+					division.nChangeFollowing = d - 1;
+					if (d === 1) {
+						division.nCommonFollowing = 0;
+						division.aStartFollowing = aEnd;
+						division.bStartFollowing = bEnd;
+					} else {
+						const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);
+						const nCommonF = countCommonItemsF(aLastPrev, aEnd, bLastPrev, bEnd, isCommon);
+						division.nCommonFollowing = nCommonF;
+						if (nCommonF !== 0) {
+							division.aCommonFollowing = aLastPrev;
+							division.bCommonFollowing = bLastPrev;
+						}
+						const aStartFollowing = aLastPrev + nCommonF;
+						const bStartFollowing = bLastPrev + nCommonF;
+						if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {
+							division.aStartFollowing = aEnd;
+							division.bStartFollowing = bEnd;
+						} else {
+							division.aStartFollowing = aStartFollowing;
+							division.bStartFollowing = bStartFollowing;
+						}
+					}
+					return true;
+				}
+			}
+		}
+		return false;
+	};
+	const divide = (nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, aIndexesR, division) => {
+		const bF = bStart - aStart;
+		const bR = bEnd - aEnd;
+		const aLength = aEnd - aStart;
+		const bLength = bEnd - bStart;
+		const baDeltaLength = bLength - aLength;
+		let iMaxF = aLength;
+		let iMaxR = aLength;
+		aIndexesF[0] = aStart - 1;
+		aIndexesR[0] = aEnd;
+		if (baDeltaLength % 2 === 0) {
+			const dMin = (nChange || baDeltaLength) / 2;
+			const dMax = (aLength + bLength) / 2;
+			for (let d = 1; d <= dMax; d += 1) {
+				iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+				if (d < dMin) iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
+				else if (extendOverlappablePathsR(d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division)) return;
+			}
+		} else {
+			const dMin = ((nChange || baDeltaLength) + 1) / 2;
+			const dMax = (aLength + bLength + 1) / 2;
+			let d = 1;
+			iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+			for (d += 1; d <= dMax; d += 1) {
+				iMaxR = extendPathsR(d - 1, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);
+				if (d < dMin) iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);
+				else if (extendOverlappablePathsF(d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, iMaxR, division)) return;
+			}
+		}
+		/* istanbul ignore next */
+		throw new Error(`${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`);
+	};
+	const findSubsequences = (nChange, aStart, aEnd, bStart, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division) => {
+		if (bEnd - bStart < aEnd - aStart) {
+			transposed = !transposed;
+			if (transposed && callbacks.length === 1) {
+				const { foundSubsequence, isCommon } = callbacks[0];
+				callbacks[1] = {
+					foundSubsequence: (nCommon, bCommon, aCommon) => {
+						foundSubsequence(nCommon, aCommon, bCommon);
+					},
+					isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)
+				};
+			}
+			const tStart = aStart;
+			const tEnd = aEnd;
+			aStart = bStart;
+			aEnd = bEnd;
+			bStart = tStart;
+			bEnd = tEnd;
+		}
+		const { foundSubsequence, isCommon } = callbacks[transposed ? 1 : 0];
+		divide(nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, aIndexesR, division);
+		const { nChangePreceding, aEndPreceding, bEndPreceding, nCommonPreceding, aCommonPreceding, bCommonPreceding, nCommonFollowing, aCommonFollowing, bCommonFollowing, nChangeFollowing, aStartFollowing, bStartFollowing } = division;
+		if (aStart < aEndPreceding && bStart < bEndPreceding) findSubsequences(nChangePreceding, aStart, aEndPreceding, bStart, bEndPreceding, transposed, callbacks, aIndexesF, aIndexesR, division);
+		if (nCommonPreceding !== 0) foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);
+		if (nCommonFollowing !== 0) foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);
+		if (aStartFollowing < aEnd && bStartFollowing < bEnd) findSubsequences(nChangeFollowing, aStartFollowing, aEnd, bStartFollowing, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division);
+	};
+	const validateLength = (name, arg) => {
+		if (typeof arg !== "number") throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);
+		if (!Number.isSafeInteger(arg)) throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);
+		if (arg < 0) throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);
+	};
+	const validateCallback = (name, arg) => {
+		const type = typeof arg;
+		if (type !== "function") throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);
+	};
+	function diffSequence(aLength, bLength, isCommon, foundSubsequence) {
+		validateLength("aLength", aLength);
+		validateLength("bLength", bLength);
+		validateCallback("isCommon", isCommon);
+		validateCallback("foundSubsequence", foundSubsequence);
+		const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);
+		if (nCommonF !== 0) foundSubsequence(nCommonF, 0, 0);
+		if (aLength !== nCommonF || bLength !== nCommonF) {
+			const aStart = nCommonF;
+			const bStart = nCommonF;
+			const nCommonR = countCommonItemsR(aStart, aLength - 1, bStart, bLength - 1, isCommon);
+			const aEnd = aLength - nCommonR;
+			const bEnd = bLength - nCommonR;
+			const nCommonFR = nCommonF + nCommonR;
+			if (aLength !== nCommonFR && bLength !== nCommonFR) findSubsequences(0, aStart, aEnd, bStart, bEnd, false, [{
+				foundSubsequence,
+				isCommon
+			}], [NOT_YET_SET], [NOT_YET_SET], {
+				aCommonFollowing: NOT_YET_SET,
+				aCommonPreceding: NOT_YET_SET,
+				aEndPreceding: NOT_YET_SET,
+				aStartFollowing: NOT_YET_SET,
+				bCommonFollowing: NOT_YET_SET,
+				bCommonPreceding: NOT_YET_SET,
+				bEndPreceding: NOT_YET_SET,
+				bStartFollowing: NOT_YET_SET,
+				nChangeFollowing: NOT_YET_SET,
+				nChangePreceding: NOT_YET_SET,
+				nCommonFollowing: NOT_YET_SET,
+				nCommonPreceding: NOT_YET_SET
+			});
+			if (nCommonR !== 0) foundSubsequence(nCommonR, aEnd, bEnd);
+		}
+	}
+	return build;
+}
+var diffSequences = /*@__PURE__*/ getDefaultExportFromCjs(/* @__PURE__ */ requireBuild());
+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);
+}
+function createPatchMark(aStart, aEnd, bStart, bEnd, { patchColor }) {
+	return patchColor(`@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`);
+}
+function joinAlignedDiffsNoExpand(diffs, options) {
+	const iLength = diffs.length;
+	const nContextLines = options.contextLines;
+	const nContextLines2 = nContextLines + nContextLines;
+	let jLength = iLength;
+	let hasExcessAtStartOrEnd = false;
+	let nExcessesBetweenChanges = 0;
+	let i = 0;
+	while (i !== iLength) {
+		const iStart = i;
+		while (i !== iLength && diffs[i][0] === 0) i += 1;
+		if (iStart !== i) if (iStart === 0) {
+			if (i > nContextLines) {
+				jLength -= i - nContextLines;
+				hasExcessAtStartOrEnd = true;
+			}
+		} else if (i === iLength) {
+			const n = i - iStart;
+			if (n > nContextLines) {
+				jLength -= n - nContextLines;
+				hasExcessAtStartOrEnd = true;
+			}
+		} else {
+			const n = i - iStart;
+			if (n > nContextLines2) {
+				jLength -= n - nContextLines2;
+				nExcessesBetweenChanges += 1;
+			}
+		}
+		while (i !== iLength && diffs[i][0] !== 0) 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("");
+	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;
+	};
+	i = 0;
+	while (i !== iLength) {
+		let iStart = i;
+		while (i !== iLength && diffs[i][0] === 0) i += 1;
+		if (iStart !== i) if (iStart === 0) {
+			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) {
+			const iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;
+			for (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) pushCommonLine(diffs[iCommon][1]);
+		} else {
+			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] === -1) {
+			pushDeleteLine(diffs[i][1]);
+			i += 1;
+		}
+		while (i !== iLength && diffs[i][0] === 1) {
+			pushInsertLine(diffs[i][1]);
+			i += 1;
+		}
+	}
+	if (hasPatch) lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
+	return lines.join("\n");
+}
+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 -1: return printDeleteLine(line, isFirstOrLast, options);
+			case 1: 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;
+}
+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 -1:
+				a += 1;
+				break;
+			case 1:
+				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);
+		const baAnnotationLengthDiff = bAnnotation.length - aAnnotation.length;
+		const aAnnotationPadding = " ".repeat(Math.max(0, baAnnotationLengthDiff));
+		const bAnnotationPadding = " ".repeat(Math.max(0, -baAnnotationLengthDiff));
+		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}`) : "");
+}
+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);
+}
+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) return diffLinesUnified(aLinesDisplay, bLinesDisplay, options);
+	const [diffs, truncated] = diffLinesRaw(aLinesCompare, bLinesCompare, options);
+	let aIndex = 0;
+	let bIndex = 0;
+	diffs.forEach((diff) => {
+		switch (diff[0]) {
+			case -1:
+				diff[1] = aLinesDisplay[aIndex];
+				aIndex += 1;
+				break;
+			case 1:
+				diff[1] = bLinesDisplay[bIndex];
+				bIndex += 1;
+				break;
+			default:
+				diff[1] = bLinesDisplay[bIndex];
+				aIndex += 1;
+				bIndex += 1;
+		}
+	});
+	return printDiffLines(diffs, truncated, normalizeDiffOptions(options));
+}
+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(-1, aLines[aIndex]));
+		for (; bIndex !== bCommon; bIndex += 1) diffs.push(new Diff(1, bLines[bIndex]));
+		for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) diffs.push(new Diff(0, bLines[bIndex]));
+	};
+	diffSequences(aLength, bLength, isCommon, foundSubsequence);
+	for (; aIndex !== aLength; aIndex += 1) diffs.push(new Diff(-1, aLines[aIndex]));
+	for (; bIndex !== bLength; bIndex += 1) diffs.push(new Diff(1, bLines[bIndex]));
+	return [diffs, truncated];
+}
+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}`);
+}
+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);
+		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(-1, a.slice(aIndex, aCommon)));
+		if (bIndex !== bCommon) diffs.push(new Diff(1, b.slice(bIndex, bCommon)));
+		aIndex = aCommon + nCommon;
+		bIndex = bCommon + nCommon;
+		diffs.push(new Diff(0, b.slice(bCommon, bIndex)));
+	};
+	diffSequences(aLength, bLength, isCommon, foundSubsequence);
+	if (aIndex !== aLength) diffs.push(new Diff(-1, a.slice(aIndex)));
+	if (bIndex !== bLength) diffs.push(new Diff(1, b.slice(bIndex)));
+	return [diffs, truncated];
+}
+function concatenateRelevantDiffs(op, diffs, changeColor) {
+	return diffs.reduce((reduced, diff) => reduced + (diff[0] === 0 ? diff[1] : diff[0] === op && diff[1].length !== 0 ? changeColor(diff[1]) : ""), "");
+}
+var ChangeBuffer = class {
+	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() {
+		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;
+	}
+	pushDiff(diff) {
+		this.line.push(diff);
+	}
+	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) {
+					this.pushSubstring(substring);
+					this.pushLine();
+				} else if (substring.length !== 0) this.pushSubstring(substring);
+			});
+		} else this.pushDiff(diff);
+	}
+	moveLinesTo(lines) {
+		if (!this.isLineEmpty()) this.pushLine();
+		lines.push(...this.lines);
+		this.lines.length = 0;
+	}
+};
+var CommonBuffer = class {
+	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;
+		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);
+	}
+	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()) {
+						this.flushChangeLines();
+						this.pushDiffCommonLine(subdiff);
+					} else {
+						this.pushDiffChangeLines(subdiff);
+						this.flushChangeLines();
+					}
+				} else if (i < iLast) this.pushDiffCommonLine(new Diff(op, substring));
+				else if (substring.length !== 0) this.pushDiffChangeLines(new Diff(op, substring));
+			});
+		} else this.pushDiffChangeLines(diff);
+	}
+	getLines() {
+		this.flushChangeLines();
+		return this.lines;
+	}
+};
+function getAlignedDiffs(diffs, changeColor) {
+	const deleteBuffer = new ChangeBuffer(-1, changeColor);
+	const insertBuffer = new ChangeBuffer(1, changeColor);
+	const commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);
+	diffs.forEach((diff) => {
+		switch (diff[0]) {
+			case -1:
+				deleteBuffer.align(diff);
+				break;
+			case 1:
+				insertBuffer.align(diff);
+				break;
+			default: commonBuffer.align(diff);
+		}
+	});
+	return commonBuffer.getLines();
+}
+function hasCommonDiff(diffs, isMultiline) {
+	if (isMultiline) {
+		const iLast = diffs.length - 1;
+		return diffs.some((diff, i) => diff[0] === 0 && (i !== iLast || diff[1] !== "\n"));
+	}
+	return diffs.some((diff) => diff[0] === 0);
+}
+function diffStringsUnified(a, b, options) {
+	if (a !== b && a.length !== 0 && b.length !== 0) {
+		const isMultiline = a.includes("\n") || b.includes("\n");
+		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);
+		}
+	}
+	return diffLinesUnified(a.split("\n"), b.split("\n"), options);
+}
+function diffStringsRaw(a, b, cleanup, options) {
+	const [diffs, truncated] = diffStrings(a, b, options);
+	if (cleanup) 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;
+/**
+* @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")) return;
+		if (typeof a.getExpectedType !== "function") return;
+		expectedType = a.getExpectedType();
+		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);
+		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 (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, true);
+		const hasCommonDiff = diffs.some((diff) => diff[0] === 0);
+		const printLabel = getLabelPrinter(aAnnotation, bAnnotation);
+		return `${printLabel(aAnnotation) + printExpected(getCommonAndChangedSubstrings(diffs, -1, hasCommonDiff))}\n${printLabel(bAnnotation) + printReceived(getCommonAndChangedSubstrings(diffs, 1, hasCommonDiff))}`;
+	}
+	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);
+}
+function replaceAsymmetricMatcher(actual, expected, actualReplaced = /* @__PURE__ */ new WeakSet(), expectedReplaced = /* @__PURE__ */ new WeakSet()) {
+	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)) expected[key] = actualValue;
+			else if ("sample" in expectedValue && expectedValue.sample !== void 0 && isReplaceable(actualValue, expectedValue.sample)) {
+				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] === 0 ? diff[1] : diff[0] === op ? hasCommonDiff ? y.inverse(diff[1]) : diff[1] : ""), "");
+}
+//#endregion
+export { Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getDefaultFormatOptions, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };
+
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"diff.js","names":["c"],"sources":["../../../../../../../../../../node_modules/.pnpm/@vitest+utils@4.1.10/node_modules/@vitest/utils/dist/diff.js"],"sourcesContent":["import { plugins, format } from '@vitest/pretty-format';\nimport c from 'tinyrainbow';\nimport { stringify } from './display.js';\nimport { deepClone, getOwnProperties, getType as getType$1 } from './helpers.js';\nimport './constants.js';\n\n/**\n* Diff Match and Patch\n* Copyright 2018 The diff-match-patch Authors.\n* https://github.com/google/diff-match-patch\n*\n* Licensed under the Apache License, Version 2.0 (the \"License\");\n* you may not use this file except in compliance with the License.\n* You may obtain a copy of the License at\n*\n*   http://www.apache.org/licenses/LICENSE-2.0\n*\n* Unless required by applicable law or agreed to in writing, software\n* distributed under the License is distributed on an \"AS IS\" BASIS,\n* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n* See the License for the specific language governing permissions and\n* limitations under the License.\n*/\n/**\n* @fileoverview Computes the difference between two texts to create a patch.\n* Applies the patch onto another text, allowing for errors.\n* @author fraser@google.com (Neil Fraser)\n*/\n/**\n* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:\n*\n* 1. Delete anything not needed to use diff_cleanupSemantic method\n* 2. Convert from prototype properties to var declarations\n* 3. Convert Diff to class from constructor and prototype\n* 4. Add type annotations for arguments and return values\n* 5. Add exports\n*/\n/**\n* The data structure representing a diff is an array of tuples:\n* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]\n* which means: delete 'Hello', add 'Goodbye' and keep ' world.'\n*/\nconst DIFF_DELETE = -1;\nconst DIFF_INSERT = 1;\nconst DIFF_EQUAL = 0;\n/**\n* Class representing one diff tuple.\n* Attempts to look like a two-element array (which is what this used to be).\n* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.\n* @param {string} text Text to be deleted, inserted, or retained.\n* @constructor\n*/\nclass Diff {\n\t0;\n\t1;\n\tconstructor(op, text) {\n\t\tthis[0] = op;\n\t\tthis[1] = text;\n\t}\n}\n/**\n* Determine the common prefix of two strings.\n* @param {string} text1 First string.\n* @param {string} text2 Second string.\n* @return {number} The number of characters common to the start of each\n*     string.\n*/\nfunction diff_commonPrefix(text1, text2) {\n\t// Quick check for common null cases.\n\tif (!text1 || !text2 || text1.charAt(0) !== text2.charAt(0)) {\n\t\treturn 0;\n\t}\n\t// Binary search.\n\t// Performance analysis: https://neil.fraser.name/news/2007/10/09/\n\tlet pointermin = 0;\n\tlet pointermax = Math.min(text1.length, text2.length);\n\tlet pointermid = pointermax;\n\tlet pointerstart = 0;\n\twhile (pointermin < pointermid) {\n\t\tif (text1.substring(pointerstart, pointermid) === text2.substring(pointerstart, pointermid)) {\n\t\t\tpointermin = pointermid;\n\t\t\tpointerstart = pointermin;\n\t\t} else {\n\t\t\tpointermax = pointermid;\n\t\t}\n\t\tpointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n\t}\n\treturn pointermid;\n}\n/**\n* Determine the common suffix of two strings.\n* @param {string} text1 First string.\n* @param {string} text2 Second string.\n* @return {number} The number of characters common to the end of each string.\n*/\nfunction diff_commonSuffix(text1, text2) {\n\t// Quick check for common null cases.\n\tif (!text1 || !text2 || text1.charAt(text1.length - 1) !== text2.charAt(text2.length - 1)) {\n\t\treturn 0;\n\t}\n\t// Binary search.\n\t// Performance analysis: https://neil.fraser.name/news/2007/10/09/\n\tlet pointermin = 0;\n\tlet pointermax = Math.min(text1.length, text2.length);\n\tlet pointermid = pointermax;\n\tlet pointerend = 0;\n\twhile (pointermin < pointermid) {\n\t\tif (text1.substring(text1.length - pointermid, text1.length - pointerend) === text2.substring(text2.length - pointermid, text2.length - pointerend)) {\n\t\t\tpointermin = pointermid;\n\t\t\tpointerend = pointermin;\n\t\t} else {\n\t\t\tpointermax = pointermid;\n\t\t}\n\t\tpointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);\n\t}\n\treturn pointermid;\n}\n/**\n* Determine if the suffix of one string is the prefix of another.\n* @param {string} text1 First string.\n* @param {string} text2 Second string.\n* @return {number} The number of characters common to the end of the first\n*     string and the start of the second string.\n* @private\n*/\nfunction diff_commonOverlap_(text1, text2) {\n\t// Cache the text lengths to prevent multiple calls.\n\tconst text1_length = text1.length;\n\tconst text2_length = text2.length;\n\t// Eliminate the null case.\n\tif (text1_length === 0 || text2_length === 0) {\n\t\treturn 0;\n\t}\n\t// Truncate the longer string.\n\tif (text1_length > text2_length) {\n\t\ttext1 = text1.substring(text1_length - text2_length);\n\t} else if (text1_length < text2_length) {\n\t\ttext2 = text2.substring(0, text1_length);\n\t}\n\tconst text_length = Math.min(text1_length, text2_length);\n\t// Quick check for the worst case.\n\tif (text1 === text2) {\n\t\treturn text_length;\n\t}\n\t// Start by looking for a single character match\n\t// and increase length until no match is found.\n\t// Performance analysis: https://neil.fraser.name/news/2010/11/04/\n\tlet best = 0;\n\tlet length = 1;\n\twhile (true) {\n\t\tconst pattern = text1.substring(text_length - length);\n\t\tconst found = text2.indexOf(pattern);\n\t\tif (found === -1) {\n\t\t\treturn best;\n\t\t}\n\t\tlength += found;\n\t\tif (found === 0 || text1.substring(text_length - length) === text2.substring(0, length)) {\n\t\t\tbest = length;\n\t\t\tlength++;\n\t\t}\n\t}\n}\n/**\n* Reduce the number of edits by eliminating semantically trivial equalities.\n* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n*/\nfunction diff_cleanupSemantic(diffs) {\n\tlet changes = false;\n\tconst equalities = [];\n\tlet equalitiesLength = 0;\n\t/** @type {?string} */\n\tlet lastEquality = null;\n\t// Always equal to diffs[equalities[equalitiesLength - 1]][1]\n\tlet pointer = 0;\n\t// Number of characters that changed prior to the equality.\n\tlet length_insertions1 = 0;\n\tlet length_deletions1 = 0;\n\t// Number of characters that changed after the equality.\n\tlet length_insertions2 = 0;\n\tlet length_deletions2 = 0;\n\twhile (pointer < diffs.length) {\n\t\tif (diffs[pointer][0] === DIFF_EQUAL) {\n\t\t\t// Equality found.\n\t\t\tequalities[equalitiesLength++] = pointer;\n\t\t\tlength_insertions1 = length_insertions2;\n\t\t\tlength_deletions1 = length_deletions2;\n\t\t\tlength_insertions2 = 0;\n\t\t\tlength_deletions2 = 0;\n\t\t\tlastEquality = diffs[pointer][1];\n\t\t} else {\n\t\t\t// An insertion or deletion.\n\t\t\tif (diffs[pointer][0] === DIFF_INSERT) {\n\t\t\t\tlength_insertions2 += diffs[pointer][1].length;\n\t\t\t} else {\n\t\t\t\tlength_deletions2 += diffs[pointer][1].length;\n\t\t\t}\n\t\t\t// Eliminate an equality that is smaller or equal to the edits on both\n\t\t\t// sides of it.\n\t\t\tif (lastEquality && lastEquality.length <= Math.max(length_insertions1, length_deletions1) && lastEquality.length <= Math.max(length_insertions2, length_deletions2)) {\n\t\t\t\t// Duplicate record.\n\t\t\t\tdiffs.splice(equalities[equalitiesLength - 1], 0, new Diff(DIFF_DELETE, lastEquality));\n\t\t\t\t// Change second copy to insert.\n\t\t\t\tdiffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;\n\t\t\t\t// Throw away the equality we just deleted.\n\t\t\t\tequalitiesLength--;\n\t\t\t\t// Throw away the previous equality (it needs to be reevaluated).\n\t\t\t\tequalitiesLength--;\n\t\t\t\tpointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;\n\t\t\t\tlength_insertions1 = 0;\n\t\t\t\tlength_deletions1 = 0;\n\t\t\t\tlength_insertions2 = 0;\n\t\t\t\tlength_deletions2 = 0;\n\t\t\t\tlastEquality = null;\n\t\t\t\tchanges = true;\n\t\t\t}\n\t\t}\n\t\tpointer++;\n\t}\n\t// Normalize the diff.\n\tif (changes) {\n\t\tdiff_cleanupMerge(diffs);\n\t}\n\tdiff_cleanupSemanticLossless(diffs);\n\t// Find any overlaps between deletions and insertions.\n\t// e.g: <del>abcxxx</del><ins>xxxdef</ins>\n\t//   -> <del>abc</del>xxx<ins>def</ins>\n\t// e.g: <del>xxxabc</del><ins>defxxx</ins>\n\t//   -> <ins>def</ins>xxx<del>abc</del>\n\t// Only extract an overlap if it is as big as the edit ahead or behind it.\n\tpointer = 1;\n\twhile (pointer < diffs.length) {\n\t\tif (diffs[pointer - 1][0] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {\n\t\t\tconst deletion = diffs[pointer - 1][1];\n\t\t\tconst insertion = diffs[pointer][1];\n\t\t\tconst overlap_length1 = diff_commonOverlap_(deletion, insertion);\n\t\t\tconst overlap_length2 = diff_commonOverlap_(insertion, deletion);\n\t\t\tif (overlap_length1 >= overlap_length2) {\n\t\t\t\tif (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {\n\t\t\t\t\t// Overlap found.  Insert an equality and trim the surrounding edits.\n\t\t\t\t\tdiffs.splice(pointer, 0, new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1)));\n\t\t\t\t\tdiffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);\n\t\t\t\t\tdiffs[pointer + 1][1] = insertion.substring(overlap_length1);\n\t\t\t\t\tpointer++;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tif (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {\n\t\t\t\t\t// Reverse overlap found.\n\t\t\t\t\t// Insert an equality and swap and trim the surrounding edits.\n\t\t\t\t\tdiffs.splice(pointer, 0, new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2)));\n\t\t\t\t\tdiffs[pointer - 1][0] = DIFF_INSERT;\n\t\t\t\t\tdiffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);\n\t\t\t\t\tdiffs[pointer + 1][0] = DIFF_DELETE;\n\t\t\t\t\tdiffs[pointer + 1][1] = deletion.substring(overlap_length2);\n\t\t\t\t\tpointer++;\n\t\t\t\t}\n\t\t\t}\n\t\t\tpointer++;\n\t\t}\n\t\tpointer++;\n\t}\n}\n// Define some regex patterns for matching boundaries.\nconst nonAlphaNumericRegex_ = /[^a-z0-9]/i;\nconst whitespaceRegex_ = /\\s/;\nconst linebreakRegex_ = /[\\r\\n]/;\nconst blanklineEndRegex_ = /\\n\\r?\\n$/;\nconst blanklineStartRegex_ = /^\\r?\\n\\r?\\n/;\n/**\n* Look for single edits surrounded on both sides by equalities\n* which can be shifted sideways to align the edit to a word boundary.\n* e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.\n* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n*/\nfunction diff_cleanupSemanticLossless(diffs) {\n\tlet pointer = 1;\n\t// Intentionally ignore the first and last element (don't need checking).\n\twhile (pointer < diffs.length - 1) {\n\t\tif (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {\n\t\t\t// This is a single edit surrounded by equalities.\n\t\t\tlet equality1 = diffs[pointer - 1][1];\n\t\t\tlet edit = diffs[pointer][1];\n\t\t\tlet equality2 = diffs[pointer + 1][1];\n\t\t\t// First, shift the edit as far left as possible.\n\t\t\tconst commonOffset = diff_commonSuffix(equality1, edit);\n\t\t\tif (commonOffset) {\n\t\t\t\tconst commonString = edit.substring(edit.length - commonOffset);\n\t\t\t\tequality1 = equality1.substring(0, equality1.length - commonOffset);\n\t\t\t\tedit = commonString + edit.substring(0, edit.length - commonOffset);\n\t\t\t\tequality2 = commonString + equality2;\n\t\t\t}\n\t\t\t// Second, step character by character right, looking for the best fit.\n\t\t\tlet bestEquality1 = equality1;\n\t\t\tlet bestEdit = edit;\n\t\t\tlet bestEquality2 = equality2;\n\t\t\tlet bestScore = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);\n\t\t\twhile (edit.charAt(0) === equality2.charAt(0)) {\n\t\t\t\tequality1 += edit.charAt(0);\n\t\t\t\tedit = edit.substring(1) + equality2.charAt(0);\n\t\t\t\tequality2 = equality2.substring(1);\n\t\t\t\tconst score = diff_cleanupSemanticScore_(equality1, edit) + diff_cleanupSemanticScore_(edit, equality2);\n\t\t\t\t// The >= encourages trailing rather than leading whitespace on edits.\n\t\t\t\tif (score >= bestScore) {\n\t\t\t\t\tbestScore = score;\n\t\t\t\t\tbestEquality1 = equality1;\n\t\t\t\t\tbestEdit = edit;\n\t\t\t\t\tbestEquality2 = equality2;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (diffs[pointer - 1][1] !== bestEquality1) {\n\t\t\t\t// We have an improvement, save it back to the diff.\n\t\t\t\tif (bestEquality1) {\n\t\t\t\t\tdiffs[pointer - 1][1] = bestEquality1;\n\t\t\t\t} else {\n\t\t\t\t\tdiffs.splice(pointer - 1, 1);\n\t\t\t\t\tpointer--;\n\t\t\t\t}\n\t\t\t\tdiffs[pointer][1] = bestEdit;\n\t\t\t\tif (bestEquality2) {\n\t\t\t\t\tdiffs[pointer + 1][1] = bestEquality2;\n\t\t\t\t} else {\n\t\t\t\t\tdiffs.splice(pointer + 1, 1);\n\t\t\t\t\tpointer--;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tpointer++;\n\t}\n}\n/**\n* Reorder and merge like edit sections.  Merge equalities.\n* Any edit section can move as long as it doesn't cross an equality.\n* @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.\n*/\nfunction diff_cleanupMerge(diffs) {\n\t// Add a dummy entry at the end.\n\tdiffs.push(new Diff(DIFF_EQUAL, \"\"));\n\tlet pointer = 0;\n\tlet count_delete = 0;\n\tlet count_insert = 0;\n\tlet text_delete = \"\";\n\tlet text_insert = \"\";\n\tlet commonlength;\n\twhile (pointer < diffs.length) {\n\t\tswitch (diffs[pointer][0]) {\n\t\t\tcase DIFF_INSERT:\n\t\t\t\tcount_insert++;\n\t\t\t\ttext_insert += diffs[pointer][1];\n\t\t\t\tpointer++;\n\t\t\t\tbreak;\n\t\t\tcase DIFF_DELETE:\n\t\t\t\tcount_delete++;\n\t\t\t\ttext_delete += diffs[pointer][1];\n\t\t\t\tpointer++;\n\t\t\t\tbreak;\n\t\t\tcase DIFF_EQUAL:\n\t\t\t\t// Upon reaching an equality, check for prior redundancies.\n\t\t\t\tif (count_delete + count_insert > 1) {\n\t\t\t\t\tif (count_delete !== 0 && count_insert !== 0) {\n\t\t\t\t\t\t// Factor out any common prefixes.\n\t\t\t\t\t\tcommonlength = diff_commonPrefix(text_insert, text_delete);\n\t\t\t\t\t\tif (commonlength !== 0) {\n\t\t\t\t\t\t\tif (pointer - count_delete - count_insert > 0 && diffs[pointer - count_delete - count_insert - 1][0] === DIFF_EQUAL) {\n\t\t\t\t\t\t\t\tdiffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tdiffs.splice(0, 0, new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength)));\n\t\t\t\t\t\t\t\tpointer++;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\ttext_insert = text_insert.substring(commonlength);\n\t\t\t\t\t\t\ttext_delete = text_delete.substring(commonlength);\n\t\t\t\t\t\t}\n\t\t\t\t\t\t// Factor out any common suffixes.\n\t\t\t\t\t\tcommonlength = diff_commonSuffix(text_insert, text_delete);\n\t\t\t\t\t\tif (commonlength !== 0) {\n\t\t\t\t\t\t\tdiffs[pointer][1] = text_insert.substring(text_insert.length - commonlength) + diffs[pointer][1];\n\t\t\t\t\t\t\ttext_insert = text_insert.substring(0, text_insert.length - commonlength);\n\t\t\t\t\t\t\ttext_delete = text_delete.substring(0, text_delete.length - commonlength);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\t// Delete the offending records and add the merged ones.\n\t\t\t\t\tpointer -= count_delete + count_insert;\n\t\t\t\t\tdiffs.splice(pointer, count_delete + count_insert);\n\t\t\t\t\tif (text_delete.length) {\n\t\t\t\t\t\tdiffs.splice(pointer, 0, new Diff(DIFF_DELETE, text_delete));\n\t\t\t\t\t\tpointer++;\n\t\t\t\t\t}\n\t\t\t\t\tif (text_insert.length) {\n\t\t\t\t\t\tdiffs.splice(pointer, 0, new Diff(DIFF_INSERT, text_insert));\n\t\t\t\t\t\tpointer++;\n\t\t\t\t\t}\n\t\t\t\t\tpointer++;\n\t\t\t\t} else if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {\n\t\t\t\t\t// Merge this equality with the previous one.\n\t\t\t\t\tdiffs[pointer - 1][1] += diffs[pointer][1];\n\t\t\t\t\tdiffs.splice(pointer, 1);\n\t\t\t\t} else {\n\t\t\t\t\tpointer++;\n\t\t\t\t}\n\t\t\t\tcount_insert = 0;\n\t\t\t\tcount_delete = 0;\n\t\t\t\ttext_delete = \"\";\n\t\t\t\ttext_insert = \"\";\n\t\t\t\tbreak;\n\t\t}\n\t}\n\tif (diffs.at(-1)?.[1] === \"\") {\n\t\tdiffs.pop();\n\t}\n\t// Second pass: look for single edits surrounded on both sides by equalities\n\t// which can be shifted sideways to eliminate an equality.\n\t// e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC\n\tlet changes = false;\n\tpointer = 1;\n\t// Intentionally ignore the first and last element (don't need checking).\n\twhile (pointer < diffs.length - 1) {\n\t\tif (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {\n\t\t\t// This is a single edit surrounded by equalities.\n\t\t\tif (diffs[pointer][1].substring(diffs[pointer][1].length - diffs[pointer - 1][1].length) === diffs[pointer - 1][1]) {\n\t\t\t\t// Shift the edit over the previous equality.\n\t\t\t\tdiffs[pointer][1] = diffs[pointer - 1][1] + diffs[pointer][1].substring(0, diffs[pointer][1].length - diffs[pointer - 1][1].length);\n\t\t\t\tdiffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];\n\t\t\t\tdiffs.splice(pointer - 1, 1);\n\t\t\t\tchanges = true;\n\t\t\t} else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) === diffs[pointer + 1][1]) {\n\t\t\t\t// Shift the edit over the next equality.\n\t\t\t\tdiffs[pointer - 1][1] += diffs[pointer + 1][1];\n\t\t\t\tdiffs[pointer][1] = diffs[pointer][1].substring(diffs[pointer + 1][1].length) + diffs[pointer + 1][1];\n\t\t\t\tdiffs.splice(pointer + 1, 1);\n\t\t\t\tchanges = true;\n\t\t\t}\n\t\t}\n\t\tpointer++;\n\t}\n\t// If shifts were made, the diff needs reordering and another shift sweep.\n\tif (changes) {\n\t\tdiff_cleanupMerge(diffs);\n\t}\n}\n/**\n* Given two strings, compute a score representing whether the internal\n* boundary falls on logical boundaries.\n* Scores range from 6 (best) to 0 (worst).\n* Closure, but does not reference any external variables.\n* @param {string} one First string.\n* @param {string} two Second string.\n* @return {number} The score.\n* @private\n*/\nfunction diff_cleanupSemanticScore_(one, two) {\n\tif (!one || !two) {\n\t\t// Edges are the best.\n\t\treturn 6;\n\t}\n\t// Each port of this function behaves slightly differently due to\n\t// subtle differences in each language's definition of things like\n\t// 'whitespace'.  Since this function's purpose is largely cosmetic,\n\t// the choice has been made to use each language's native features\n\t// rather than force total conformity.\n\tconst char1 = one.charAt(one.length - 1);\n\tconst char2 = two.charAt(0);\n\tconst nonAlphaNumeric1 = char1.match(nonAlphaNumericRegex_);\n\tconst nonAlphaNumeric2 = char2.match(nonAlphaNumericRegex_);\n\tconst whitespace1 = nonAlphaNumeric1 && char1.match(whitespaceRegex_);\n\tconst whitespace2 = nonAlphaNumeric2 && char2.match(whitespaceRegex_);\n\tconst lineBreak1 = whitespace1 && char1.match(linebreakRegex_);\n\tconst lineBreak2 = whitespace2 && char2.match(linebreakRegex_);\n\tconst blankLine1 = lineBreak1 && one.match(blanklineEndRegex_);\n\tconst blankLine2 = lineBreak2 && two.match(blanklineStartRegex_);\n\tif (blankLine1 || blankLine2) {\n\t\t// Five points for blank lines.\n\t\treturn 5;\n\t} else if (lineBreak1 || lineBreak2) {\n\t\t// Four points for line breaks.\n\t\treturn 4;\n\t} else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {\n\t\t// Three points for end of sentences.\n\t\treturn 3;\n\t} else if (whitespace1 || whitespace2) {\n\t\t// Two points for whitespace.\n\t\treturn 2;\n\t} else if (nonAlphaNumeric1 || nonAlphaNumeric2) {\n\t\t// One point for non-alphanumeric.\n\t\treturn 1;\n\t}\n\treturn 0;\n}\n\n/**\n* Copyright (c) Meta Platforms, Inc. and affiliates.\n*\n* This source code is licensed under the MIT license found in the\n* LICENSE file in the root directory of this source tree.\n*/\nconst NO_DIFF_MESSAGE = \"Compared values have no visual difference.\";\nconst SIMILAR_MESSAGE = \"Compared values serialize to the same structure.\\n\" + \"Printing internal object structure without calling `toJSON` instead.\";\n\nfunction getDefaultExportFromCjs(x) {\n\treturn x && x.__esModule && Object.prototype.hasOwnProperty.call(x, \"default\") ? x[\"default\"] : x;\n}\n\nvar build = {};\n\nvar hasRequiredBuild;\n\nfunction requireBuild () {\n\tif (hasRequiredBuild) return build;\n\thasRequiredBuild = 1;\n\n\tObject.defineProperty(build, '__esModule', {\n\t  value: true\n\t});\n\tbuild.default = diffSequence;\n\t/**\n\t * Copyright (c) Meta Platforms, Inc. and affiliates.\n\t *\n\t * This source code is licensed under the MIT license found in the\n\t * LICENSE file in the root directory of this source tree.\n\t *\n\t */\n\n\t// This diff-sequences package implements the linear space variation in\n\t// An O(ND) Difference Algorithm and Its Variations by Eugene W. Myers\n\n\t// Relationship in notation between Myers paper and this package:\n\t// A is a\n\t// N is aLength, aEnd - aStart, and so on\n\t// x is aIndex, aFirst, aLast, and so on\n\t// B is b\n\t// M is bLength, bEnd - bStart, and so on\n\t// y is bIndex, bFirst, bLast, and so on\n\t// Δ = N - M is negative of baDeltaLength = bLength - aLength\n\t// D is d\n\t// k is kF\n\t// k + Δ is kF = kR - baDeltaLength\n\t// V is aIndexesF or aIndexesR (see comment below about Indexes type)\n\t// index intervals [1, N] and [1, M] are [0, aLength) and [0, bLength)\n\t// starting point in forward direction (0, 0) is (-1, -1)\n\t// starting point in reverse direction (N + 1, M + 1) is (aLength, bLength)\n\n\t// The “edit graph” for sequences a and b corresponds to items:\n\t// in a on the horizontal axis\n\t// in b on the vertical axis\n\t//\n\t// Given a-coordinate of a point in a diagonal, you can compute b-coordinate.\n\t//\n\t// Forward diagonals kF:\n\t// zero diagonal intersects top left corner\n\t// positive diagonals intersect top edge\n\t// negative diagonals insersect left edge\n\t//\n\t// Reverse diagonals kR:\n\t// zero diagonal intersects bottom right corner\n\t// positive diagonals intersect right edge\n\t// negative diagonals intersect bottom edge\n\n\t// The graph contains a directed acyclic graph of edges:\n\t// horizontal: delete an item from a\n\t// vertical: insert an item from b\n\t// diagonal: common item in a and b\n\t//\n\t// The algorithm solves dual problems in the graph analogy:\n\t// Find longest common subsequence: path with maximum number of diagonal edges\n\t// Find shortest edit script: path with minimum number of non-diagonal edges\n\n\t// Input callback function compares items at indexes in the sequences.\n\n\t// Output callback function receives the number of adjacent items\n\t// and starting indexes of each common subsequence.\n\t// Either original functions or wrapped to swap indexes if graph is transposed.\n\t// Indexes in sequence a of last point of forward or reverse paths in graph.\n\t// Myers algorithm indexes by diagonal k which for negative is bad deopt in V8.\n\t// This package indexes by iF and iR which are greater than or equal to zero.\n\t// and also updates the index arrays in place to cut memory in half.\n\t// kF = 2 * iF - d\n\t// kR = d - 2 * iR\n\t// Division of index intervals in sequences a and b at the middle change.\n\t// Invariant: intervals do not have common items at the start or end.\n\tconst pkg = 'diff-sequences'; // for error messages\n\tconst NOT_YET_SET = 0; // small int instead of undefined to avoid deopt in V8\n\n\t// Return the number of common items that follow in forward direction.\n\t// The length of what Myers paper calls a “snake” in a forward path.\n\tconst countCommonItemsF = (aIndex, aEnd, bIndex, bEnd, isCommon) => {\n\t  let nCommon = 0;\n\t  while (aIndex < aEnd && bIndex < bEnd && isCommon(aIndex, bIndex)) {\n\t    aIndex += 1;\n\t    bIndex += 1;\n\t    nCommon += 1;\n\t  }\n\t  return nCommon;\n\t};\n\n\t// Return the number of common items that precede in reverse direction.\n\t// The length of what Myers paper calls a “snake” in a reverse path.\n\tconst countCommonItemsR = (aStart, aIndex, bStart, bIndex, isCommon) => {\n\t  let nCommon = 0;\n\t  while (aStart <= aIndex && bStart <= bIndex && isCommon(aIndex, bIndex)) {\n\t    aIndex -= 1;\n\t    bIndex -= 1;\n\t    nCommon += 1;\n\t  }\n\t  return nCommon;\n\t};\n\n\t// A simple function to extend forward paths from (d - 1) to d changes\n\t// when forward and reverse paths cannot yet overlap.\n\tconst extendPathsF = (\n\t  d,\n\t  aEnd,\n\t  bEnd,\n\t  bF,\n\t  isCommon,\n\t  aIndexesF,\n\t  iMaxF // return the value because optimization might decrease it\n\t) => {\n\t  // Unroll the first iteration.\n\t  let iF = 0;\n\t  let kF = -d; // kF = 2 * iF - d\n\t  let aFirst = aIndexesF[iF]; // in first iteration always insert\n\t  let aIndexPrev1 = aFirst; // prev value of [iF - 1] in next iteration\n\t  aIndexesF[iF] += countCommonItemsF(\n\t    aFirst + 1,\n\t    aEnd,\n\t    bF + aFirst - kF + 1,\n\t    bEnd,\n\t    isCommon\n\t  );\n\n\t  // Optimization: skip diagonals in which paths cannot ever overlap.\n\t  const nF = d < iMaxF ? d : iMaxF;\n\n\t  // The diagonals kF are odd when d is odd and even when d is even.\n\t  for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {\n\t    // To get first point of path segment, move one change in forward direction\n\t    // from last point of previous path segment in an adjacent diagonal.\n\t    // In last possible iteration when iF === d and kF === d always delete.\n\t    if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {\n\t      aFirst = aIndexesF[iF]; // vertical to insert from b\n\t    } else {\n\t      aFirst = aIndexPrev1 + 1; // horizontal to delete from a\n\n\t      if (aEnd <= aFirst) {\n\t        // Optimization: delete moved past right of graph.\n\t        return iF - 1;\n\t      }\n\t    }\n\n\t    // To get last point of path segment, move along diagonal of common items.\n\t    aIndexPrev1 = aIndexesF[iF];\n\t    aIndexesF[iF] =\n\t      aFirst +\n\t      countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);\n\t  }\n\t  return iMaxF;\n\t};\n\n\t// A simple function to extend reverse paths from (d - 1) to d changes\n\t// when reverse and forward paths cannot yet overlap.\n\tconst extendPathsR = (\n\t  d,\n\t  aStart,\n\t  bStart,\n\t  bR,\n\t  isCommon,\n\t  aIndexesR,\n\t  iMaxR // return the value because optimization might decrease it\n\t) => {\n\t  // Unroll the first iteration.\n\t  let iR = 0;\n\t  let kR = d; // kR = d - 2 * iR\n\t  let aFirst = aIndexesR[iR]; // in first iteration always insert\n\t  let aIndexPrev1 = aFirst; // prev value of [iR - 1] in next iteration\n\t  aIndexesR[iR] -= countCommonItemsR(\n\t    aStart,\n\t    aFirst - 1,\n\t    bStart,\n\t    bR + aFirst - kR - 1,\n\t    isCommon\n\t  );\n\n\t  // Optimization: skip diagonals in which paths cannot ever overlap.\n\t  const nR = d < iMaxR ? d : iMaxR;\n\n\t  // The diagonals kR are odd when d is odd and even when d is even.\n\t  for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {\n\t    // To get first point of path segment, move one change in reverse direction\n\t    // from last point of previous path segment in an adjacent diagonal.\n\t    // In last possible iteration when iR === d and kR === -d always delete.\n\t    if (iR !== d && aIndexesR[iR] < aIndexPrev1) {\n\t      aFirst = aIndexesR[iR]; // vertical to insert from b\n\t    } else {\n\t      aFirst = aIndexPrev1 - 1; // horizontal to delete from a\n\n\t      if (aFirst < aStart) {\n\t        // Optimization: delete moved past left of graph.\n\t        return iR - 1;\n\t      }\n\t    }\n\n\t    // To get last point of path segment, move along diagonal of common items.\n\t    aIndexPrev1 = aIndexesR[iR];\n\t    aIndexesR[iR] =\n\t      aFirst -\n\t      countCommonItemsR(\n\t        aStart,\n\t        aFirst - 1,\n\t        bStart,\n\t        bR + aFirst - kR - 1,\n\t        isCommon\n\t      );\n\t  }\n\t  return iMaxR;\n\t};\n\n\t// A complete function to extend forward paths from (d - 1) to d changes.\n\t// Return true if a path overlaps reverse path of (d - 1) changes in its diagonal.\n\tconst extendOverlappablePathsF = (\n\t  d,\n\t  aStart,\n\t  aEnd,\n\t  bStart,\n\t  bEnd,\n\t  isCommon,\n\t  aIndexesF,\n\t  iMaxF,\n\t  aIndexesR,\n\t  iMaxR,\n\t  division // update prop values if return true\n\t) => {\n\t  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n\t  const aLength = aEnd - aStart;\n\t  const bLength = bEnd - bStart;\n\t  const baDeltaLength = bLength - aLength; // kF = kR - baDeltaLength\n\n\t  // Range of diagonals in which forward and reverse paths might overlap.\n\t  const kMinOverlapF = -baDeltaLength - (d - 1); // -(d - 1) <= kR\n\t  const kMaxOverlapF = -baDeltaLength + (d - 1); // kR <= (d - 1)\n\n\t  let aIndexPrev1 = NOT_YET_SET; // prev value of [iF - 1] in next iteration\n\n\t  // Optimization: skip diagonals in which paths cannot ever overlap.\n\t  const nF = d < iMaxF ? d : iMaxF;\n\n\t  // The diagonals kF = 2 * iF - d are odd when d is odd and even when d is even.\n\t  for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {\n\t    // To get first point of path segment, move one change in forward direction\n\t    // from last point of previous path segment in an adjacent diagonal.\n\t    // In first iteration when iF === 0 and kF === -d always insert.\n\t    // In last possible iteration when iF === d and kF === d always delete.\n\t    const insert = iF === 0 || (iF !== d && aIndexPrev1 < aIndexesF[iF]);\n\t    const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;\n\t    const aFirst = insert\n\t      ? aLastPrev // vertical to insert from b\n\t      : aLastPrev + 1; // horizontal to delete from a\n\n\t    // To get last point of path segment, move along diagonal of common items.\n\t    const bFirst = bF + aFirst - kF;\n\t    const nCommonF = countCommonItemsF(\n\t      aFirst + 1,\n\t      aEnd,\n\t      bFirst + 1,\n\t      bEnd,\n\t      isCommon\n\t    );\n\t    const aLast = aFirst + nCommonF;\n\t    aIndexPrev1 = aIndexesF[iF];\n\t    aIndexesF[iF] = aLast;\n\t    if (kMinOverlapF <= kF && kF <= kMaxOverlapF) {\n\t      // Solve for iR of reverse path with (d - 1) changes in diagonal kF:\n\t      // kR = kF + baDeltaLength\n\t      // kR = (d - 1) - 2 * iR\n\t      const iR = (d - 1 - (kF + baDeltaLength)) / 2;\n\n\t      // If this forward path overlaps the reverse path in this diagonal,\n\t      // then this is the middle change of the index intervals.\n\t      if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {\n\t        // Unlike the Myers algorithm which finds only the middle “snake”\n\t        // this package can find two common subsequences per division.\n\t        // Last point of previous path segment is on an adjacent diagonal.\n\t        const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);\n\n\t        // Because of invariant that intervals preceding the middle change\n\t        // cannot have common items at the end,\n\t        // move in reverse direction along a diagonal of common items.\n\t        const nCommonR = countCommonItemsR(\n\t          aStart,\n\t          aLastPrev,\n\t          bStart,\n\t          bLastPrev,\n\t          isCommon\n\t        );\n\t        const aIndexPrevFirst = aLastPrev - nCommonR;\n\t        const bIndexPrevFirst = bLastPrev - nCommonR;\n\t        const aEndPreceding = aIndexPrevFirst + 1;\n\t        const bEndPreceding = bIndexPrevFirst + 1;\n\t        division.nChangePreceding = d - 1;\n\t        if (d - 1 === aEndPreceding + bEndPreceding - aStart - bStart) {\n\t          // Optimization: number of preceding changes in forward direction\n\t          // is equal to number of items in preceding interval,\n\t          // therefore it cannot contain any common items.\n\t          division.aEndPreceding = aStart;\n\t          division.bEndPreceding = bStart;\n\t        } else {\n\t          division.aEndPreceding = aEndPreceding;\n\t          division.bEndPreceding = bEndPreceding;\n\t        }\n\t        division.nCommonPreceding = nCommonR;\n\t        if (nCommonR !== 0) {\n\t          division.aCommonPreceding = aEndPreceding;\n\t          division.bCommonPreceding = bEndPreceding;\n\t        }\n\t        division.nCommonFollowing = nCommonF;\n\t        if (nCommonF !== 0) {\n\t          division.aCommonFollowing = aFirst + 1;\n\t          division.bCommonFollowing = bFirst + 1;\n\t        }\n\t        const aStartFollowing = aLast + 1;\n\t        const bStartFollowing = bFirst + nCommonF + 1;\n\t        division.nChangeFollowing = d - 1;\n\t        if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n\t          // Optimization: number of changes in reverse direction\n\t          // is equal to number of items in following interval,\n\t          // therefore it cannot contain any common items.\n\t          division.aStartFollowing = aEnd;\n\t          division.bStartFollowing = bEnd;\n\t        } else {\n\t          division.aStartFollowing = aStartFollowing;\n\t          division.bStartFollowing = bStartFollowing;\n\t        }\n\t        return true;\n\t      }\n\t    }\n\t  }\n\t  return false;\n\t};\n\n\t// A complete function to extend reverse paths from (d - 1) to d changes.\n\t// Return true if a path overlaps forward path of d changes in its diagonal.\n\tconst extendOverlappablePathsR = (\n\t  d,\n\t  aStart,\n\t  aEnd,\n\t  bStart,\n\t  bEnd,\n\t  isCommon,\n\t  aIndexesF,\n\t  iMaxF,\n\t  aIndexesR,\n\t  iMaxR,\n\t  division // update prop values if return true\n\t) => {\n\t  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n\t  const aLength = aEnd - aStart;\n\t  const bLength = bEnd - bStart;\n\t  const baDeltaLength = bLength - aLength; // kR = kF + baDeltaLength\n\n\t  // Range of diagonals in which forward and reverse paths might overlap.\n\t  const kMinOverlapR = baDeltaLength - d; // -d <= kF\n\t  const kMaxOverlapR = baDeltaLength + d; // kF <= d\n\n\t  let aIndexPrev1 = NOT_YET_SET; // prev value of [iR - 1] in next iteration\n\n\t  // Optimization: skip diagonals in which paths cannot ever overlap.\n\t  const nR = d < iMaxR ? d : iMaxR;\n\n\t  // The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.\n\t  for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {\n\t    // To get first point of path segment, move one change in reverse direction\n\t    // from last point of previous path segment in an adjacent diagonal.\n\t    // In first iteration when iR === 0 and kR === d always insert.\n\t    // In last possible iteration when iR === d and kR === -d always delete.\n\t    const insert = iR === 0 || (iR !== d && aIndexesR[iR] < aIndexPrev1);\n\t    const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;\n\t    const aFirst = insert\n\t      ? aLastPrev // vertical to insert from b\n\t      : aLastPrev - 1; // horizontal to delete from a\n\n\t    // To get last point of path segment, move along diagonal of common items.\n\t    const bFirst = bR + aFirst - kR;\n\t    const nCommonR = countCommonItemsR(\n\t      aStart,\n\t      aFirst - 1,\n\t      bStart,\n\t      bFirst - 1,\n\t      isCommon\n\t    );\n\t    const aLast = aFirst - nCommonR;\n\t    aIndexPrev1 = aIndexesR[iR];\n\t    aIndexesR[iR] = aLast;\n\t    if (kMinOverlapR <= kR && kR <= kMaxOverlapR) {\n\t      // Solve for iF of forward path with d changes in diagonal kR:\n\t      // kF = kR - baDeltaLength\n\t      // kF = 2 * iF - d\n\t      const iF = (d + (kR - baDeltaLength)) / 2;\n\n\t      // If this reverse path overlaps the forward path in this diagonal,\n\t      // then this is a middle change of the index intervals.\n\t      if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {\n\t        const bLast = bFirst - nCommonR;\n\t        division.nChangePreceding = d;\n\t        if (d === aLast + bLast - aStart - bStart) {\n\t          // Optimization: number of changes in reverse direction\n\t          // is equal to number of items in preceding interval,\n\t          // therefore it cannot contain any common items.\n\t          division.aEndPreceding = aStart;\n\t          division.bEndPreceding = bStart;\n\t        } else {\n\t          division.aEndPreceding = aLast;\n\t          division.bEndPreceding = bLast;\n\t        }\n\t        division.nCommonPreceding = nCommonR;\n\t        if (nCommonR !== 0) {\n\t          // The last point of reverse path segment is start of common subsequence.\n\t          division.aCommonPreceding = aLast;\n\t          division.bCommonPreceding = bLast;\n\t        }\n\t        division.nChangeFollowing = d - 1;\n\t        if (d === 1) {\n\t          // There is no previous path segment.\n\t          division.nCommonFollowing = 0;\n\t          division.aStartFollowing = aEnd;\n\t          division.bStartFollowing = bEnd;\n\t        } else {\n\t          // Unlike the Myers algorithm which finds only the middle “snake”\n\t          // this package can find two common subsequences per division.\n\t          // Last point of previous path segment is on an adjacent diagonal.\n\t          const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);\n\n\t          // Because of invariant that intervals following the middle change\n\t          // cannot have common items at the start,\n\t          // move in forward direction along a diagonal of common items.\n\t          const nCommonF = countCommonItemsF(\n\t            aLastPrev,\n\t            aEnd,\n\t            bLastPrev,\n\t            bEnd,\n\t            isCommon\n\t          );\n\t          division.nCommonFollowing = nCommonF;\n\t          if (nCommonF !== 0) {\n\t            // The last point of reverse path segment is start of common subsequence.\n\t            division.aCommonFollowing = aLastPrev;\n\t            division.bCommonFollowing = bLastPrev;\n\t          }\n\t          const aStartFollowing = aLastPrev + nCommonF; // aFirstPrev\n\t          const bStartFollowing = bLastPrev + nCommonF; // bFirstPrev\n\n\t          if (d - 1 === aEnd + bEnd - aStartFollowing - bStartFollowing) {\n\t            // Optimization: number of changes in forward direction\n\t            // is equal to number of items in following interval,\n\t            // therefore it cannot contain any common items.\n\t            division.aStartFollowing = aEnd;\n\t            division.bStartFollowing = bEnd;\n\t          } else {\n\t            division.aStartFollowing = aStartFollowing;\n\t            division.bStartFollowing = bStartFollowing;\n\t          }\n\t        }\n\t        return true;\n\t      }\n\t    }\n\t  }\n\t  return false;\n\t};\n\n\t// Given index intervals and input function to compare items at indexes,\n\t// divide at the middle change.\n\t//\n\t// DO NOT CALL if start === end, because interval cannot contain common items\n\t// and because this function will throw the “no overlap” error.\n\tconst divide = (\n\t  nChange,\n\t  aStart,\n\t  aEnd,\n\t  bStart,\n\t  bEnd,\n\t  isCommon,\n\t  aIndexesF,\n\t  aIndexesR,\n\t  division // output\n\t) => {\n\t  const bF = bStart - aStart; // bIndex = bF + aIndex - kF\n\t  const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR\n\t  const aLength = aEnd - aStart;\n\t  const bLength = bEnd - bStart;\n\n\t  // Because graph has square or portrait orientation,\n\t  // length difference is minimum number of items to insert from b.\n\t  // Corresponding forward and reverse diagonals in graph\n\t  // depend on length difference of the sequences:\n\t  // kF = kR - baDeltaLength\n\t  // kR = kF + baDeltaLength\n\t  const baDeltaLength = bLength - aLength;\n\n\t  // Optimization: max diagonal in graph intersects corner of shorter side.\n\t  let iMaxF = aLength;\n\t  let iMaxR = aLength;\n\n\t  // Initialize no changes yet in forward or reverse direction:\n\t  aIndexesF[0] = aStart - 1; // at open start of interval, outside closed start\n\t  aIndexesR[0] = aEnd; // at open end of interval\n\n\t  if (baDeltaLength % 2 === 0) {\n\t    // The number of changes in paths is 2 * d if length difference is even.\n\t    const dMin = (nChange || baDeltaLength) / 2;\n\t    const dMax = (aLength + bLength) / 2;\n\t    for (let d = 1; d <= dMax; d += 1) {\n\t      iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n\t      if (d < dMin) {\n\t        iMaxR = extendPathsR(d, aStart, bStart, bR, isCommon, aIndexesR, iMaxR);\n\t      } else if (\n\t        // If a reverse path overlaps a forward path in the same diagonal,\n\t        // return a division of the index intervals at the middle change.\n\t        extendOverlappablePathsR(\n\t          d,\n\t          aStart,\n\t          aEnd,\n\t          bStart,\n\t          bEnd,\n\t          isCommon,\n\t          aIndexesF,\n\t          iMaxF,\n\t          aIndexesR,\n\t          iMaxR,\n\t          division\n\t        )\n\t      ) {\n\t        return;\n\t      }\n\t    }\n\t  } else {\n\t    // The number of changes in paths is 2 * d - 1 if length difference is odd.\n\t    const dMin = ((nChange || baDeltaLength) + 1) / 2;\n\t    const dMax = (aLength + bLength + 1) / 2;\n\n\t    // Unroll first half iteration so loop extends the relevant pairs of paths.\n\t    // Because of invariant that intervals have no common items at start or end,\n\t    // and limitation not to call divide with empty intervals,\n\t    // therefore it cannot be called if a forward path with one change\n\t    // would overlap a reverse path with no changes, even if dMin === 1.\n\t    let d = 1;\n\t    iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n\t    for (d += 1; d <= dMax; d += 1) {\n\t      iMaxR = extendPathsR(\n\t        d - 1,\n\t        aStart,\n\t        bStart,\n\t        bR,\n\t        isCommon,\n\t        aIndexesR,\n\t        iMaxR\n\t      );\n\t      if (d < dMin) {\n\t        iMaxF = extendPathsF(d, aEnd, bEnd, bF, isCommon, aIndexesF, iMaxF);\n\t      } else if (\n\t        // If a forward path overlaps a reverse path in the same diagonal,\n\t        // return a division of the index intervals at the middle change.\n\t        extendOverlappablePathsF(\n\t          d,\n\t          aStart,\n\t          aEnd,\n\t          bStart,\n\t          bEnd,\n\t          isCommon,\n\t          aIndexesF,\n\t          iMaxF,\n\t          aIndexesR,\n\t          iMaxR,\n\t          division\n\t        )\n\t      ) {\n\t        return;\n\t      }\n\t    }\n\t  }\n\n\t  /* istanbul ignore next */\n\t  throw new Error(\n\t    `${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`\n\t  );\n\t};\n\n\t// Given index intervals and input function to compare items at indexes,\n\t// return by output function the number of adjacent items and starting indexes\n\t// of each common subsequence. Divide and conquer with only linear space.\n\t//\n\t// The index intervals are half open [start, end) like array slice method.\n\t// DO NOT CALL if start === end, because interval cannot contain common items\n\t// and because divide function will throw the “no overlap” error.\n\tconst findSubsequences = (\n\t  nChange,\n\t  aStart,\n\t  aEnd,\n\t  bStart,\n\t  bEnd,\n\t  transposed,\n\t  callbacks,\n\t  aIndexesF,\n\t  aIndexesR,\n\t  division // temporary memory, not input nor output\n\t) => {\n\t  if (bEnd - bStart < aEnd - aStart) {\n\t    // Transpose graph so it has portrait instead of landscape orientation.\n\t    // Always compare shorter to longer sequence for consistency and optimization.\n\t    transposed = !transposed;\n\t    if (transposed && callbacks.length === 1) {\n\t      // Lazily wrap callback functions to swap args if graph is transposed.\n\t      const {foundSubsequence, isCommon} = callbacks[0];\n\t      callbacks[1] = {\n\t        foundSubsequence: (nCommon, bCommon, aCommon) => {\n\t          foundSubsequence(nCommon, aCommon, bCommon);\n\t        },\n\t        isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex)\n\t      };\n\t    }\n\t    const tStart = aStart;\n\t    const tEnd = aEnd;\n\t    aStart = bStart;\n\t    aEnd = bEnd;\n\t    bStart = tStart;\n\t    bEnd = tEnd;\n\t  }\n\t  const {foundSubsequence, isCommon} = callbacks[transposed ? 1 : 0];\n\n\t  // Divide the index intervals at the middle change.\n\t  divide(\n\t    nChange,\n\t    aStart,\n\t    aEnd,\n\t    bStart,\n\t    bEnd,\n\t    isCommon,\n\t    aIndexesF,\n\t    aIndexesR,\n\t    division\n\t  );\n\t  const {\n\t    nChangePreceding,\n\t    aEndPreceding,\n\t    bEndPreceding,\n\t    nCommonPreceding,\n\t    aCommonPreceding,\n\t    bCommonPreceding,\n\t    nCommonFollowing,\n\t    aCommonFollowing,\n\t    bCommonFollowing,\n\t    nChangeFollowing,\n\t    aStartFollowing,\n\t    bStartFollowing\n\t  } = division;\n\n\t  // Unless either index interval is empty, they might contain common items.\n\t  if (aStart < aEndPreceding && bStart < bEndPreceding) {\n\t    // Recursely find and return common subsequences preceding the division.\n\t    findSubsequences(\n\t      nChangePreceding,\n\t      aStart,\n\t      aEndPreceding,\n\t      bStart,\n\t      bEndPreceding,\n\t      transposed,\n\t      callbacks,\n\t      aIndexesF,\n\t      aIndexesR,\n\t      division\n\t    );\n\t  }\n\n\t  // Return common subsequences that are adjacent to the middle change.\n\t  if (nCommonPreceding !== 0) {\n\t    foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);\n\t  }\n\t  if (nCommonFollowing !== 0) {\n\t    foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);\n\t  }\n\n\t  // Unless either index interval is empty, they might contain common items.\n\t  if (aStartFollowing < aEnd && bStartFollowing < bEnd) {\n\t    // Recursely find and return common subsequences following the division.\n\t    findSubsequences(\n\t      nChangeFollowing,\n\t      aStartFollowing,\n\t      aEnd,\n\t      bStartFollowing,\n\t      bEnd,\n\t      transposed,\n\t      callbacks,\n\t      aIndexesF,\n\t      aIndexesR,\n\t      division\n\t    );\n\t  }\n\t};\n\tconst validateLength = (name, arg) => {\n\t  if (typeof arg !== 'number') {\n\t    throw new TypeError(`${pkg}: ${name} typeof ${typeof arg} is not a number`);\n\t  }\n\t  if (!Number.isSafeInteger(arg)) {\n\t    throw new RangeError(`${pkg}: ${name} value ${arg} is not a safe integer`);\n\t  }\n\t  if (arg < 0) {\n\t    throw new RangeError(`${pkg}: ${name} value ${arg} is a negative integer`);\n\t  }\n\t};\n\tconst validateCallback = (name, arg) => {\n\t  const type = typeof arg;\n\t  if (type !== 'function') {\n\t    throw new TypeError(`${pkg}: ${name} typeof ${type} is not a function`);\n\t  }\n\t};\n\n\t// Compare items in two sequences to find a longest common subsequence.\n\t// Given lengths of sequences and input function to compare items at indexes,\n\t// return by output function the number of adjacent items and starting indexes\n\t// of each common subsequence.\n\tfunction diffSequence(aLength, bLength, isCommon, foundSubsequence) {\n\t  validateLength('aLength', aLength);\n\t  validateLength('bLength', bLength);\n\t  validateCallback('isCommon', isCommon);\n\t  validateCallback('foundSubsequence', foundSubsequence);\n\n\t  // Count common items from the start in the forward direction.\n\t  const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);\n\t  if (nCommonF !== 0) {\n\t    foundSubsequence(nCommonF, 0, 0);\n\t  }\n\n\t  // Unless both sequences consist of common items only,\n\t  // find common items in the half-trimmed index intervals.\n\t  if (aLength !== nCommonF || bLength !== nCommonF) {\n\t    // Invariant: intervals do not have common items at the start.\n\t    // The start of an index interval is closed like array slice method.\n\t    const aStart = nCommonF;\n\t    const bStart = nCommonF;\n\n\t    // Count common items from the end in the reverse direction.\n\t    const nCommonR = countCommonItemsR(\n\t      aStart,\n\t      aLength - 1,\n\t      bStart,\n\t      bLength - 1,\n\t      isCommon\n\t    );\n\n\t    // Invariant: intervals do not have common items at the end.\n\t    // The end of an index interval is open like array slice method.\n\t    const aEnd = aLength - nCommonR;\n\t    const bEnd = bLength - nCommonR;\n\n\t    // Unless one sequence consists of common items only,\n\t    // therefore the other trimmed index interval consists of changes only,\n\t    // find common items in the trimmed index intervals.\n\t    const nCommonFR = nCommonF + nCommonR;\n\t    if (aLength !== nCommonFR && bLength !== nCommonFR) {\n\t      const nChange = 0; // number of change items is not yet known\n\t      const transposed = false; // call the original unwrapped functions\n\t      const callbacks = [\n\t        {\n\t          foundSubsequence,\n\t          isCommon\n\t        }\n\t      ];\n\n\t      // Indexes in sequence a of last points in furthest reaching paths\n\t      // from outside the start at top left in the forward direction:\n\t      const aIndexesF = [NOT_YET_SET];\n\t      // from the end at bottom right in the reverse direction:\n\t      const aIndexesR = [NOT_YET_SET];\n\n\t      // Initialize one object as output of all calls to divide function.\n\t      const division = {\n\t        aCommonFollowing: NOT_YET_SET,\n\t        aCommonPreceding: NOT_YET_SET,\n\t        aEndPreceding: NOT_YET_SET,\n\t        aStartFollowing: NOT_YET_SET,\n\t        bCommonFollowing: NOT_YET_SET,\n\t        bCommonPreceding: NOT_YET_SET,\n\t        bEndPreceding: NOT_YET_SET,\n\t        bStartFollowing: NOT_YET_SET,\n\t        nChangeFollowing: NOT_YET_SET,\n\t        nChangePreceding: NOT_YET_SET,\n\t        nCommonFollowing: NOT_YET_SET,\n\t        nCommonPreceding: NOT_YET_SET\n\t      };\n\n\t      // Find and return common subsequences in the trimmed index intervals.\n\t      findSubsequences(\n\t        nChange,\n\t        aStart,\n\t        aEnd,\n\t        bStart,\n\t        bEnd,\n\t        transposed,\n\t        callbacks,\n\t        aIndexesF,\n\t        aIndexesR,\n\t        division\n\t      );\n\t    }\n\t    if (nCommonR !== 0) {\n\t      foundSubsequence(nCommonR, aEnd, bEnd);\n\t    }\n\t  }\n\t}\n\treturn build;\n}\n\nvar buildExports = /*@__PURE__*/ requireBuild();\nvar diffSequences = /*@__PURE__*/getDefaultExportFromCjs(buildExports);\n\nfunction formatTrailingSpaces(line, trailingSpaceFormatter) {\n\treturn line.replace(/\\s+$/, (match) => trailingSpaceFormatter(match));\n}\nfunction printDiffLine(line, isFirstOrLast, color, indicator, trailingSpaceFormatter, emptyFirstOrLastLinePlaceholder) {\n\treturn line.length !== 0 ? color(`${indicator} ${formatTrailingSpaces(line, trailingSpaceFormatter)}`) : indicator !== \" \" ? color(indicator) : isFirstOrLast && emptyFirstOrLastLinePlaceholder.length !== 0 ? color(`${indicator} ${emptyFirstOrLastLinePlaceholder}`) : \"\";\n}\nfunction printDeleteLine(line, isFirstOrLast, { aColor, aIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {\n\treturn printDiffLine(line, isFirstOrLast, aColor, aIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);\n}\nfunction printInsertLine(line, isFirstOrLast, { bColor, bIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {\n\treturn printDiffLine(line, isFirstOrLast, bColor, bIndicator, changeLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);\n}\nfunction printCommonLine(line, isFirstOrLast, { commonColor, commonIndicator, commonLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder }) {\n\treturn printDiffLine(line, isFirstOrLast, commonColor, commonIndicator, commonLineTrailingSpaceColor, emptyFirstOrLastLinePlaceholder);\n}\n// In GNU diff format, indexes are one-based instead of zero-based.\nfunction createPatchMark(aStart, aEnd, bStart, bEnd, { patchColor }) {\n\treturn patchColor(`@@ -${aStart + 1},${aEnd - aStart} +${bStart + 1},${bEnd - bStart} @@`);\n}\n// jest --no-expand\n//\n// Given array of aligned strings with inverse highlight formatting,\n// return joined lines with diff formatting (and patch marks, if needed).\nfunction joinAlignedDiffsNoExpand(diffs, options) {\n\tconst iLength = diffs.length;\n\tconst nContextLines = options.contextLines;\n\tconst nContextLines2 = nContextLines + nContextLines;\n\t// First pass: count output lines and see if it has patches.\n\tlet jLength = iLength;\n\tlet hasExcessAtStartOrEnd = false;\n\tlet nExcessesBetweenChanges = 0;\n\tlet i = 0;\n\twhile (i !== iLength) {\n\t\tconst iStart = i;\n\t\twhile (i !== iLength && diffs[i][0] === DIFF_EQUAL) {\n\t\t\ti += 1;\n\t\t}\n\t\tif (iStart !== i) {\n\t\t\tif (iStart === 0) {\n\t\t\t\t// at start\n\t\t\t\tif (i > nContextLines) {\n\t\t\t\t\tjLength -= i - nContextLines;\n\t\t\t\t\thasExcessAtStartOrEnd = true;\n\t\t\t\t}\n\t\t\t} else if (i === iLength) {\n\t\t\t\t// at end\n\t\t\t\tconst n = i - iStart;\n\t\t\t\tif (n > nContextLines) {\n\t\t\t\t\tjLength -= n - nContextLines;\n\t\t\t\t\thasExcessAtStartOrEnd = true;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// between changes\n\t\t\t\tconst n = i - iStart;\n\t\t\t\tif (n > nContextLines2) {\n\t\t\t\t\tjLength -= n - nContextLines2;\n\t\t\t\t\tnExcessesBetweenChanges += 1;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\twhile (i !== iLength && diffs[i][0] !== DIFF_EQUAL) {\n\t\t\ti += 1;\n\t\t}\n\t}\n\tconst hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;\n\tif (nExcessesBetweenChanges !== 0) {\n\t\tjLength += nExcessesBetweenChanges + 1;\n\t} else if (hasExcessAtStartOrEnd) {\n\t\tjLength += 1;\n\t}\n\tconst jLast = jLength - 1;\n\tconst lines = [];\n\tlet jPatchMark = 0;\n\tif (hasPatch) {\n\t\tlines.push(\"\");\n\t}\n\t// Indexes of expected or received lines in current patch:\n\tlet aStart = 0;\n\tlet bStart = 0;\n\tlet aEnd = 0;\n\tlet bEnd = 0;\n\tconst pushCommonLine = (line) => {\n\t\tconst j = lines.length;\n\t\tlines.push(printCommonLine(line, j === 0 || j === jLast, options));\n\t\taEnd += 1;\n\t\tbEnd += 1;\n\t};\n\tconst pushDeleteLine = (line) => {\n\t\tconst j = lines.length;\n\t\tlines.push(printDeleteLine(line, j === 0 || j === jLast, options));\n\t\taEnd += 1;\n\t};\n\tconst pushInsertLine = (line) => {\n\t\tconst j = lines.length;\n\t\tlines.push(printInsertLine(line, j === 0 || j === jLast, options));\n\t\tbEnd += 1;\n\t};\n\t// Second pass: push lines with diff formatting (and patch marks, if needed).\n\ti = 0;\n\twhile (i !== iLength) {\n\t\tlet iStart = i;\n\t\twhile (i !== iLength && diffs[i][0] === DIFF_EQUAL) {\n\t\t\ti += 1;\n\t\t}\n\t\tif (iStart !== i) {\n\t\t\tif (iStart === 0) {\n\t\t\t\t// at beginning\n\t\t\t\tif (i > nContextLines) {\n\t\t\t\t\tiStart = i - nContextLines;\n\t\t\t\t\taStart = iStart;\n\t\t\t\t\tbStart = iStart;\n\t\t\t\t\taEnd = aStart;\n\t\t\t\t\tbEnd = bStart;\n\t\t\t\t}\n\t\t\t\tfor (let iCommon = iStart; iCommon !== i; iCommon += 1) {\n\t\t\t\t\tpushCommonLine(diffs[iCommon][1]);\n\t\t\t\t}\n\t\t\t} else if (i === iLength) {\n\t\t\t\t// at end\n\t\t\t\tconst iEnd = i - iStart > nContextLines ? iStart + nContextLines : i;\n\t\t\t\tfor (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {\n\t\t\t\t\tpushCommonLine(diffs[iCommon][1]);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// between changes\n\t\t\t\tconst nCommon = i - iStart;\n\t\t\t\tif (nCommon > nContextLines2) {\n\t\t\t\t\tconst iEnd = iStart + nContextLines;\n\t\t\t\t\tfor (let iCommon = iStart; iCommon !== iEnd; iCommon += 1) {\n\t\t\t\t\t\tpushCommonLine(diffs[iCommon][1]);\n\t\t\t\t\t}\n\t\t\t\t\tlines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);\n\t\t\t\t\tjPatchMark = lines.length;\n\t\t\t\t\tlines.push(\"\");\n\t\t\t\t\tconst nOmit = nCommon - nContextLines2;\n\t\t\t\t\taStart = aEnd + nOmit;\n\t\t\t\t\tbStart = bEnd + nOmit;\n\t\t\t\t\taEnd = aStart;\n\t\t\t\t\tbEnd = bStart;\n\t\t\t\t\tfor (let iCommon = i - nContextLines; iCommon !== i; iCommon += 1) {\n\t\t\t\t\t\tpushCommonLine(diffs[iCommon][1]);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\tfor (let iCommon = iStart; iCommon !== i; iCommon += 1) {\n\t\t\t\t\t\tpushCommonLine(diffs[iCommon][1]);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\twhile (i !== iLength && diffs[i][0] === DIFF_DELETE) {\n\t\t\tpushDeleteLine(diffs[i][1]);\n\t\t\ti += 1;\n\t\t}\n\t\twhile (i !== iLength && diffs[i][0] === DIFF_INSERT) {\n\t\t\tpushInsertLine(diffs[i][1]);\n\t\t\ti += 1;\n\t\t}\n\t}\n\tif (hasPatch) {\n\t\tlines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);\n\t}\n\treturn lines.join(\"\\n\");\n}\n// jest --expand\n//\n// Given array of aligned strings with inverse highlight formatting,\n// return joined lines with diff formatting.\nfunction joinAlignedDiffsExpand(diffs, options) {\n\treturn diffs.map((diff, i, diffs) => {\n\t\tconst line = diff[1];\n\t\tconst isFirstOrLast = i === 0 || i === diffs.length - 1;\n\t\tswitch (diff[0]) {\n\t\t\tcase DIFF_DELETE: return printDeleteLine(line, isFirstOrLast, options);\n\t\t\tcase DIFF_INSERT: return printInsertLine(line, isFirstOrLast, options);\n\t\t\tdefault: return printCommonLine(line, isFirstOrLast, options);\n\t\t}\n\t}).join(\"\\n\");\n}\n\nconst noColor = (string) => string;\nconst DIFF_CONTEXT_DEFAULT = 5;\nconst DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;\nfunction getDefaultOptions() {\n\treturn {\n\t\taAnnotation: \"Expected\",\n\t\taColor: c.green,\n\t\taIndicator: \"-\",\n\t\tbAnnotation: \"Received\",\n\t\tbColor: c.red,\n\t\tbIndicator: \"+\",\n\t\tchangeColor: c.inverse,\n\t\tchangeLineTrailingSpaceColor: noColor,\n\t\tcommonColor: c.dim,\n\t\tcommonIndicator: \" \",\n\t\tcommonLineTrailingSpaceColor: noColor,\n\t\tcompareKeys: undefined,\n\t\tcontextLines: DIFF_CONTEXT_DEFAULT,\n\t\temptyFirstOrLastLinePlaceholder: \"\",\n\t\texpand: false,\n\t\tincludeChangeCounts: false,\n\t\tomitAnnotationLines: false,\n\t\tpatchColor: c.yellow,\n\t\tprintBasicPrototype: false,\n\t\ttruncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,\n\t\ttruncateAnnotation: \"... Diff result is truncated\",\n\t\ttruncateAnnotationColor: noColor\n\t};\n}\nfunction getCompareKeys(compareKeys) {\n\treturn compareKeys && typeof compareKeys === \"function\" ? compareKeys : undefined;\n}\nfunction getContextLines(contextLines) {\n\treturn typeof contextLines === \"number\" && Number.isSafeInteger(contextLines) && contextLines >= 0 ? contextLines : DIFF_CONTEXT_DEFAULT;\n}\n// Pure function returns options with all properties.\nfunction normalizeDiffOptions(options = {}) {\n\treturn {\n\t\t...getDefaultOptions(),\n\t\t...options,\n\t\tcompareKeys: getCompareKeys(options.compareKeys),\n\t\tcontextLines: getContextLines(options.contextLines)\n\t};\n}\n\nfunction isEmptyString(lines) {\n\treturn lines.length === 1 && lines[0].length === 0;\n}\nfunction countChanges(diffs) {\n\tlet a = 0;\n\tlet b = 0;\n\tdiffs.forEach((diff) => {\n\t\tswitch (diff[0]) {\n\t\t\tcase DIFF_DELETE:\n\t\t\t\ta += 1;\n\t\t\t\tbreak;\n\t\t\tcase DIFF_INSERT:\n\t\t\t\tb += 1;\n\t\t\t\tbreak;\n\t\t}\n\t});\n\treturn {\n\t\ta,\n\t\tb\n\t};\n}\nfunction printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {\n\tif (omitAnnotationLines) {\n\t\treturn \"\";\n\t}\n\tlet aRest = \"\";\n\tlet bRest = \"\";\n\tif (includeChangeCounts) {\n\t\tconst aCount = String(changeCounts.a);\n\t\tconst bCount = String(changeCounts.b);\n\t\t// Padding right aligns the ends of the annotations.\n\t\tconst baAnnotationLengthDiff = bAnnotation.length - aAnnotation.length;\n\t\tconst aAnnotationPadding = \" \".repeat(Math.max(0, baAnnotationLengthDiff));\n\t\tconst bAnnotationPadding = \" \".repeat(Math.max(0, -baAnnotationLengthDiff));\n\t\t// Padding left aligns the ends of the counts.\n\t\tconst baCountLengthDiff = bCount.length - aCount.length;\n\t\tconst aCountPadding = \" \".repeat(Math.max(0, baCountLengthDiff));\n\t\tconst bCountPadding = \" \".repeat(Math.max(0, -baCountLengthDiff));\n\t\taRest = `${aAnnotationPadding}  ${aIndicator} ${aCountPadding}${aCount}`;\n\t\tbRest = `${bAnnotationPadding}  ${bIndicator} ${bCountPadding}${bCount}`;\n\t}\n\tconst a = `${aIndicator} ${aAnnotation}${aRest}`;\n\tconst b = `${bIndicator} ${bAnnotation}${bRest}`;\n\treturn `${aColor(a)}\\n${bColor(b)}\\n\\n`;\n}\nfunction printDiffLines(diffs, truncated, options) {\n\treturn printAnnotation(options, countChanges(diffs)) + (options.expand ? joinAlignedDiffsExpand(diffs, options) : joinAlignedDiffsNoExpand(diffs, options)) + (truncated ? options.truncateAnnotationColor(`\\n${options.truncateAnnotation}`) : \"\");\n}\n// Compare two arrays of strings line-by-line. Format as comparison lines.\nfunction diffLinesUnified(aLines, bLines, options) {\n\tconst normalizedOptions = normalizeDiffOptions(options);\n\tconst [diffs, truncated] = diffLinesRaw(isEmptyString(aLines) ? [] : aLines, isEmptyString(bLines) ? [] : bLines, normalizedOptions);\n\treturn printDiffLines(diffs, truncated, normalizedOptions);\n}\n// Given two pairs of arrays of strings:\n// Compare the pair of comparison arrays line-by-line.\n// Format the corresponding lines in the pair of displayable arrays.\nfunction diffLinesUnified2(aLinesDisplay, bLinesDisplay, aLinesCompare, bLinesCompare, options) {\n\tif (isEmptyString(aLinesDisplay) && isEmptyString(aLinesCompare)) {\n\t\taLinesDisplay = [];\n\t\taLinesCompare = [];\n\t}\n\tif (isEmptyString(bLinesDisplay) && isEmptyString(bLinesCompare)) {\n\t\tbLinesDisplay = [];\n\t\tbLinesCompare = [];\n\t}\n\tif (aLinesDisplay.length !== aLinesCompare.length || bLinesDisplay.length !== bLinesCompare.length) {\n\t\t// Fall back to diff of display lines.\n\t\treturn diffLinesUnified(aLinesDisplay, bLinesDisplay, options);\n\t}\n\tconst [diffs, truncated] = diffLinesRaw(aLinesCompare, bLinesCompare, options);\n\t// Replace comparison lines with displayable lines.\n\tlet aIndex = 0;\n\tlet bIndex = 0;\n\tdiffs.forEach((diff) => {\n\t\tswitch (diff[0]) {\n\t\t\tcase DIFF_DELETE:\n\t\t\t\tdiff[1] = aLinesDisplay[aIndex];\n\t\t\t\taIndex += 1;\n\t\t\t\tbreak;\n\t\t\tcase DIFF_INSERT:\n\t\t\t\tdiff[1] = bLinesDisplay[bIndex];\n\t\t\t\tbIndex += 1;\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tdiff[1] = bLinesDisplay[bIndex];\n\t\t\t\taIndex += 1;\n\t\t\t\tbIndex += 1;\n\t\t}\n\t});\n\treturn printDiffLines(diffs, truncated, normalizeDiffOptions(options));\n}\n// Compare two arrays of strings line-by-line.\nfunction diffLinesRaw(aLines, bLines, options) {\n\tconst truncate = options?.truncateThreshold ?? false;\n\tconst truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);\n\tconst aLength = truncate ? Math.min(aLines.length, truncateThreshold) : aLines.length;\n\tconst bLength = truncate ? Math.min(bLines.length, truncateThreshold) : bLines.length;\n\tconst truncated = aLength !== aLines.length || bLength !== bLines.length;\n\tconst isCommon = (aIndex, bIndex) => aLines[aIndex] === bLines[bIndex];\n\tconst diffs = [];\n\tlet aIndex = 0;\n\tlet bIndex = 0;\n\tconst foundSubsequence = (nCommon, aCommon, bCommon) => {\n\t\tfor (; aIndex !== aCommon; aIndex += 1) {\n\t\t\tdiffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));\n\t\t}\n\t\tfor (; bIndex !== bCommon; bIndex += 1) {\n\t\t\tdiffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));\n\t\t}\n\t\tfor (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {\n\t\t\tdiffs.push(new Diff(DIFF_EQUAL, bLines[bIndex]));\n\t\t}\n\t};\n\tdiffSequences(aLength, bLength, isCommon, foundSubsequence);\n\t// After the last common subsequence, push remaining change items.\n\tfor (; aIndex !== aLength; aIndex += 1) {\n\t\tdiffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));\n\t}\n\tfor (; bIndex !== bLength; bIndex += 1) {\n\t\tdiffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));\n\t}\n\treturn [diffs, truncated];\n}\n\n// get the type of a value with handling the edge cases like `typeof []`\n// and `typeof null`\nfunction getType(value) {\n\tif (value === undefined) {\n\t\treturn \"undefined\";\n\t} else if (value === null) {\n\t\treturn \"null\";\n\t} else if (Array.isArray(value)) {\n\t\treturn \"array\";\n\t} else if (typeof value === \"boolean\") {\n\t\treturn \"boolean\";\n\t} else if (typeof value === \"function\") {\n\t\treturn \"function\";\n\t} else if (typeof value === \"number\") {\n\t\treturn \"number\";\n\t} else if (typeof value === \"string\") {\n\t\treturn \"string\";\n\t} else if (typeof value === \"bigint\") {\n\t\treturn \"bigint\";\n\t} else if (typeof value === \"object\") {\n\t\tif (value != null) {\n\t\t\tif (value.constructor === RegExp) {\n\t\t\t\treturn \"regexp\";\n\t\t\t} else if (value.constructor === Map) {\n\t\t\t\treturn \"map\";\n\t\t\t} else if (value.constructor === Set) {\n\t\t\t\treturn \"set\";\n\t\t\t} else if (value.constructor === Date) {\n\t\t\t\treturn \"date\";\n\t\t\t}\n\t\t}\n\t\treturn \"object\";\n\t} else if (typeof value === \"symbol\") {\n\t\treturn \"symbol\";\n\t}\n\tthrow new Error(`value of unknown type: ${value}`);\n}\n\n// platforms compatible\nfunction getNewLineSymbol(string) {\n\treturn string.includes(\"\\r\\n\") ? \"\\r\\n\" : \"\\n\";\n}\nfunction diffStrings(a, b, options) {\n\tconst truncate = options?.truncateThreshold ?? false;\n\tconst truncateThreshold = Math.max(Math.floor(options?.truncateThreshold ?? 0), 0);\n\tlet aLength = a.length;\n\tlet bLength = b.length;\n\tif (truncate) {\n\t\tconst aMultipleLines = a.includes(\"\\n\");\n\t\tconst bMultipleLines = b.includes(\"\\n\");\n\t\tconst aNewLineSymbol = getNewLineSymbol(a);\n\t\tconst bNewLineSymbol = getNewLineSymbol(b);\n\t\t// multiple-lines string expects a newline to be appended at the end\n\t\tconst _a = aMultipleLines ? `${a.split(aNewLineSymbol, truncateThreshold).join(aNewLineSymbol)}\\n` : a;\n\t\tconst _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}\\n` : b;\n\t\taLength = _a.length;\n\t\tbLength = _b.length;\n\t}\n\tconst truncated = aLength !== a.length || bLength !== b.length;\n\tconst isCommon = (aIndex, bIndex) => a[aIndex] === b[bIndex];\n\tlet aIndex = 0;\n\tlet bIndex = 0;\n\tconst diffs = [];\n\tconst foundSubsequence = (nCommon, aCommon, bCommon) => {\n\t\tif (aIndex !== aCommon) {\n\t\t\tdiffs.push(new Diff(DIFF_DELETE, a.slice(aIndex, aCommon)));\n\t\t}\n\t\tif (bIndex !== bCommon) {\n\t\t\tdiffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));\n\t\t}\n\t\taIndex = aCommon + nCommon;\n\t\tbIndex = bCommon + nCommon;\n\t\tdiffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));\n\t};\n\tdiffSequences(aLength, bLength, isCommon, foundSubsequence);\n\t// After the last common subsequence, push remaining change items.\n\tif (aIndex !== aLength) {\n\t\tdiffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));\n\t}\n\tif (bIndex !== bLength) {\n\t\tdiffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));\n\t}\n\treturn [diffs, truncated];\n}\n\n// Given change op and array of diffs, return concatenated string:\n// * include common strings\n// * include change strings which have argument op with changeColor\n// * exclude change strings which have opposite op\nfunction concatenateRelevantDiffs(op, diffs, changeColor) {\n\treturn diffs.reduce((reduced, diff) => reduced + (diff[0] === DIFF_EQUAL ? diff[1] : diff[0] === op && diff[1].length !== 0 ? changeColor(diff[1]) : \"\"), \"\");\n}\n// Encapsulate change lines until either a common newline or the end.\nclass ChangeBuffer {\n\top;\n\tline;\n\tlines;\n\tchangeColor;\n\tconstructor(op, changeColor) {\n\t\tthis.op = op;\n\t\tthis.line = [];\n\t\tthis.lines = [];\n\t\tthis.changeColor = changeColor;\n\t}\n\tpushSubstring(substring) {\n\t\tthis.pushDiff(new Diff(this.op, substring));\n\t}\n\tpushLine() {\n\t\t// Assume call only if line has at least one diff,\n\t\t// therefore an empty line must have a diff which has an empty string.\n\t\t// If line has multiple diffs, then assume it has a common diff,\n\t\t// therefore change diffs have change color;\n\t\t// otherwise then it has line color only.\n\t\tthis.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]));\n\t\tthis.line.length = 0;\n\t}\n\tisLineEmpty() {\n\t\treturn this.line.length === 0;\n\t}\n\t// Minor input to buffer.\n\tpushDiff(diff) {\n\t\tthis.line.push(diff);\n\t}\n\t// Main input to buffer.\n\talign(diff) {\n\t\tconst string = diff[1];\n\t\tif (string.includes(\"\\n\")) {\n\t\t\tconst substrings = string.split(\"\\n\");\n\t\t\tconst iLast = substrings.length - 1;\n\t\t\tsubstrings.forEach((substring, i) => {\n\t\t\t\tif (i < iLast) {\n\t\t\t\t\t// The first substring completes the current change line.\n\t\t\t\t\t// A middle substring is a change line.\n\t\t\t\t\tthis.pushSubstring(substring);\n\t\t\t\t\tthis.pushLine();\n\t\t\t\t} else if (substring.length !== 0) {\n\t\t\t\t\t// The last substring starts a change line, if it is not empty.\n\t\t\t\t\t// Important: This non-empty condition also automatically omits\n\t\t\t\t\t// the newline appended to the end of expected and received strings.\n\t\t\t\t\tthis.pushSubstring(substring);\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\t// Append non-multiline string to current change line.\n\t\t\tthis.pushDiff(diff);\n\t\t}\n\t}\n\t// Output from buffer.\n\tmoveLinesTo(lines) {\n\t\tif (!this.isLineEmpty()) {\n\t\t\tthis.pushLine();\n\t\t}\n\t\tlines.push(...this.lines);\n\t\tthis.lines.length = 0;\n\t}\n}\n// Encapsulate common and change lines.\nclass CommonBuffer {\n\tdeleteBuffer;\n\tinsertBuffer;\n\tlines;\n\tconstructor(deleteBuffer, insertBuffer) {\n\t\tthis.deleteBuffer = deleteBuffer;\n\t\tthis.insertBuffer = insertBuffer;\n\t\tthis.lines = [];\n\t}\n\tpushDiffCommonLine(diff) {\n\t\tthis.lines.push(diff);\n\t}\n\tpushDiffChangeLines(diff) {\n\t\tconst isDiffEmpty = diff[1].length === 0;\n\t\t// An empty diff string is redundant, unless a change line is empty.\n\t\tif (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {\n\t\t\tthis.deleteBuffer.pushDiff(diff);\n\t\t}\n\t\tif (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {\n\t\t\tthis.insertBuffer.pushDiff(diff);\n\t\t}\n\t}\n\tflushChangeLines() {\n\t\tthis.deleteBuffer.moveLinesTo(this.lines);\n\t\tthis.insertBuffer.moveLinesTo(this.lines);\n\t}\n\t// Input to buffer.\n\talign(diff) {\n\t\tconst op = diff[0];\n\t\tconst string = diff[1];\n\t\tif (string.includes(\"\\n\")) {\n\t\t\tconst substrings = string.split(\"\\n\");\n\t\t\tconst iLast = substrings.length - 1;\n\t\t\tsubstrings.forEach((substring, i) => {\n\t\t\t\tif (i === 0) {\n\t\t\t\t\tconst subdiff = new Diff(op, substring);\n\t\t\t\t\tif (this.deleteBuffer.isLineEmpty() && this.insertBuffer.isLineEmpty()) {\n\t\t\t\t\t\t// If both current change lines are empty,\n\t\t\t\t\t\t// then the first substring is a common line.\n\t\t\t\t\t\tthis.flushChangeLines();\n\t\t\t\t\t\tthis.pushDiffCommonLine(subdiff);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// If either current change line is non-empty,\n\t\t\t\t\t\t// then the first substring completes the change lines.\n\t\t\t\t\t\tthis.pushDiffChangeLines(subdiff);\n\t\t\t\t\t\tthis.flushChangeLines();\n\t\t\t\t\t}\n\t\t\t\t} else if (i < iLast) {\n\t\t\t\t\t// A middle substring is a common line.\n\t\t\t\t\tthis.pushDiffCommonLine(new Diff(op, substring));\n\t\t\t\t} else if (substring.length !== 0) {\n\t\t\t\t\t// The last substring starts a change line, if it is not empty.\n\t\t\t\t\t// Important: This non-empty condition also automatically omits\n\t\t\t\t\t// the newline appended to the end of expected and received strings.\n\t\t\t\t\tthis.pushDiffChangeLines(new Diff(op, substring));\n\t\t\t\t}\n\t\t\t});\n\t\t} else {\n\t\t\t// Append non-multiline string to current change lines.\n\t\t\t// Important: It cannot be at the end following empty change lines,\n\t\t\t// because newline appended to the end of expected and received strings.\n\t\t\tthis.pushDiffChangeLines(diff);\n\t\t}\n\t}\n\t// Output from buffer.\n\tgetLines() {\n\t\tthis.flushChangeLines();\n\t\treturn this.lines;\n\t}\n}\n// Given diffs from expected and received strings,\n// return new array of diffs split or joined into lines.\n//\n// To correctly align a change line at the end, the algorithm:\n// * assumes that a newline was appended to the strings\n// * omits the last newline from the output array\n//\n// Assume the function is not called:\n// * if either expected or received is empty string\n// * if neither expected nor received is multiline string\nfunction getAlignedDiffs(diffs, changeColor) {\n\tconst deleteBuffer = new ChangeBuffer(DIFF_DELETE, changeColor);\n\tconst insertBuffer = new ChangeBuffer(DIFF_INSERT, changeColor);\n\tconst commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);\n\tdiffs.forEach((diff) => {\n\t\tswitch (diff[0]) {\n\t\t\tcase DIFF_DELETE:\n\t\t\t\tdeleteBuffer.align(diff);\n\t\t\t\tbreak;\n\t\t\tcase DIFF_INSERT:\n\t\t\t\tinsertBuffer.align(diff);\n\t\t\t\tbreak;\n\t\t\tdefault: commonBuffer.align(diff);\n\t\t}\n\t});\n\treturn commonBuffer.getLines();\n}\n\nfunction hasCommonDiff(diffs, isMultiline) {\n\tif (isMultiline) {\n\t\t// Important: Ignore common newline that was appended to multiline strings!\n\t\tconst iLast = diffs.length - 1;\n\t\treturn diffs.some((diff, i) => diff[0] === DIFF_EQUAL && (i !== iLast || diff[1] !== \"\\n\"));\n\t}\n\treturn diffs.some((diff) => diff[0] === DIFF_EQUAL);\n}\n// Compare two strings character-by-character.\n// Format as comparison lines in which changed substrings have inverse colors.\nfunction diffStringsUnified(a, b, options) {\n\tif (a !== b && a.length !== 0 && b.length !== 0) {\n\t\tconst isMultiline = a.includes(\"\\n\") || b.includes(\"\\n\");\n\t\t// getAlignedDiffs assumes that a newline was appended to the strings.\n\t\tconst [diffs, truncated] = diffStringsRaw(isMultiline ? `${a}\\n` : a, isMultiline ? `${b}\\n` : b, true, options);\n\t\tif (hasCommonDiff(diffs, isMultiline)) {\n\t\t\tconst optionsNormalized = normalizeDiffOptions(options);\n\t\t\tconst lines = getAlignedDiffs(diffs, optionsNormalized.changeColor);\n\t\t\treturn printDiffLines(lines, truncated, optionsNormalized);\n\t\t}\n\t}\n\t// Fall back to line-by-line diff.\n\treturn diffLinesUnified(a.split(\"\\n\"), b.split(\"\\n\"), options);\n}\n// Compare two strings character-by-character.\n// Optionally clean up small common substrings, also known as chaff.\nfunction diffStringsRaw(a, b, cleanup, options) {\n\tconst [diffs, truncated] = diffStrings(a, b, options);\n\tif (cleanup) {\n\t\tdiff_cleanupSemantic(diffs);\n\t}\n\treturn [diffs, truncated];\n}\n\nfunction getCommonMessage(message, options) {\n\tconst { commonColor } = normalizeDiffOptions(options);\n\treturn commonColor(message);\n}\nconst { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;\nconst PLUGINS = [\n\tReactTestComponent,\n\tReactElement,\n\tDOMElement,\n\tDOMCollection,\n\tImmutable,\n\tAsymmetricMatcher,\n\tplugins.Error\n];\nconst FORMAT_OPTIONS = {\n\tmaxDepth: 20,\n\tplugins: PLUGINS\n};\nconst FALLBACK_FORMAT_OPTIONS = {\n\tcallToJSON: false,\n\tmaxDepth: 8,\n\tplugins: PLUGINS\n};\nconst DEFAULT_MEMORIZE = (_, v) => v;\n// Generate a string that will highlight the difference between two values\n// with green and red. (similar to how github does code diffing)\n/**\n* @param a Expected value\n* @param b Received value\n* @param options Diff options\n* @returns {string | null} a string diff\n*/\nfunction diff(a, b, options, memorize = DEFAULT_MEMORIZE) {\n\tif (Object.is(a, b)) {\n\t\treturn \"\";\n\t}\n\tconst aType = getType(a);\n\tlet expectedType = aType;\n\tlet omitDifference = false;\n\tif (aType === \"object\" && typeof a.asymmetricMatch === \"function\") {\n\t\tif (a.$$typeof !== Symbol.for(\"jest.asymmetricMatcher\")) {\n\t\t\t// Do not know expected type of user-defined asymmetric matcher.\n\t\t\treturn undefined;\n\t\t}\n\t\tif (typeof a.getExpectedType !== \"function\") {\n\t\t\t// For example, expect.anything() matches either null or undefined\n\t\t\treturn undefined;\n\t\t}\n\t\texpectedType = a.getExpectedType();\n\t\t// Primitive types boolean and number omit difference below.\n\t\t// For example, omit difference for expect.stringMatching(regexp)\n\t\tomitDifference = expectedType === \"string\";\n\t}\n\tif (expectedType !== getType(b)) {\n\t\tconst { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);\n\t\tconst formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);\n\t\tlet aDisplay = format(a, formatOptions);\n\t\tlet bDisplay = format(b, formatOptions);\n\t\t// even if prettyFormat prints successfully big objects,\n\t\t// large string can choke later on (concatenation? RPC?),\n\t\t// so truncate it to a reasonable length here.\n\t\t// (For example, playwright's ElementHandle can become about 200_000_000 length string)\n\t\tconst MAX_LENGTH = 1e5;\n\t\tfunction truncate(s) {\n\t\t\treturn s.length <= MAX_LENGTH ? s : `${s.slice(0, MAX_LENGTH)}...`;\n\t\t}\n\t\taDisplay = memorize(\"expected\", truncate(aDisplay));\n\t\tbDisplay = memorize(\"actual\", truncate(bDisplay));\n\t\tconst aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)}\\n${aDisplay}`;\n\t\tconst bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)}\\n${bDisplay}`;\n\t\treturn `${aDiff}\\n\\n${bDiff}`;\n\t}\n\tif (omitDifference) {\n\t\treturn undefined;\n\t}\n\tswitch (aType) {\n\t\tcase \"string\": return diffLinesUnified(a.split(\"\\n\"), b.split(\"\\n\"), options);\n\t\tcase \"boolean\":\n\t\tcase \"number\": return comparePrimitive(a, b, options, memorize);\n\t\tcase \"map\": return compareObjects(sortMap(a), sortMap(b), options, memorize);\n\t\tcase \"set\": return compareObjects(sortSet(a), sortSet(b), options, memorize);\n\t\tdefault: return compareObjects(a, b, options, memorize);\n\t}\n}\nfunction createMemorize(memory) {\n\treturn (pointer, stringifiedValue) => {\n\t\tmemory[pointer] = stringifiedValue;\n\t\treturn stringifiedValue;\n\t};\n}\nfunction comparePrimitive(a, b, options, memorize = DEFAULT_MEMORIZE) {\n\tconst aFormat = memorize(\"expected\", format(a, FORMAT_OPTIONS));\n\tconst bFormat = memorize(\"actual\", format(b, FORMAT_OPTIONS));\n\treturn aFormat === bFormat ? \"\" : diffLinesUnified(aFormat.split(\"\\n\"), bFormat.split(\"\\n\"), options);\n}\nfunction sortMap(map) {\n\treturn new Map(Array.from(map.entries()).sort());\n}\nfunction sortSet(set) {\n\treturn new Set(Array.from(set.values()).sort());\n}\nfunction compareObjects(a, b, options, memorize = DEFAULT_MEMORIZE) {\n\tlet difference;\n\tlet hasThrown = false;\n\ttry {\n\t\tconst formatOptions = getFormatOptions(FORMAT_OPTIONS, options);\n\t\tdifference = getObjectsDifference(a, b, formatOptions, options, memorize);\n\t} catch {\n\t\thasThrown = true;\n\t}\n\tconst noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);\n\t// If the comparison yields no results, compare again but this time\n\t// without calling `toJSON`. It's also possible that toJSON might throw.\n\tif (difference === undefined || difference === noDiffMessage) {\n\t\tconst formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);\n\t\tdifference = getObjectsDifference(a, b, formatOptions, options, memorize);\n\t\tif (difference !== noDiffMessage && !hasThrown) {\n\t\t\tdifference = `${getCommonMessage(SIMILAR_MESSAGE, options)}\\n\\n${difference}`;\n\t\t}\n\t}\n\treturn difference;\n}\nfunction getDefaultFormatOptions(options) {\n\treturn getFormatOptions(FORMAT_OPTIONS, options);\n}\nfunction getFormatOptions(formatOptions, options) {\n\tconst { compareKeys, printBasicPrototype, maxDepth } = normalizeDiffOptions(options);\n\treturn {\n\t\t...formatOptions,\n\t\tcompareKeys,\n\t\tprintBasicPrototype,\n\t\tmaxDepth: maxDepth ?? formatOptions.maxDepth\n\t};\n}\nfunction getObjectsDifference(a, b, formatOptions, options, memorize = DEFAULT_MEMORIZE) {\n\tconst formatOptionsZeroIndent = {\n\t\t...formatOptions,\n\t\tindent: 0\n\t};\n\tconst aCompare = format(a, formatOptionsZeroIndent);\n\tconst bCompare = format(b, formatOptionsZeroIndent);\n\tif (aCompare === bCompare) {\n\t\treturn getCommonMessage(NO_DIFF_MESSAGE, options);\n\t} else {\n\t\tconst aDisplay = memorize(\"expected\", format(a, formatOptions));\n\t\tconst bDisplay = memorize(\"actual\", format(b, formatOptions));\n\t\treturn diffLinesUnified2(aDisplay.split(\"\\n\"), bDisplay.split(\"\\n\"), aCompare.split(\"\\n\"), bCompare.split(\"\\n\"), options);\n\t}\n}\nconst MAX_DIFF_STRING_LENGTH = 2e4;\nfunction isAsymmetricMatcher(data) {\n\tconst type = getType$1(data);\n\treturn type === \"Object\" && typeof data.asymmetricMatch === \"function\";\n}\nfunction isReplaceable(obj1, obj2) {\n\tconst obj1Type = getType$1(obj1);\n\tconst obj2Type = getType$1(obj2);\n\treturn obj1Type === obj2Type && (obj1Type === \"Object\" || obj1Type === \"Array\");\n}\nfunction printDiffOrStringify(received, expected, options, memory) {\n\tconst { aAnnotation, bAnnotation } = normalizeDiffOptions(options);\n\tif (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) {\n\t\tif (expected.includes(\"\\n\") || received.includes(\"\\n\")) {\n\t\t\treturn diffStringsUnified(expected, received, options);\n\t\t}\n\t\tconst [diffs] = diffStringsRaw(expected, received, true);\n\t\tconst hasCommonDiff = diffs.some((diff) => diff[0] === DIFF_EQUAL);\n\t\tconst printLabel = getLabelPrinter(aAnnotation, bAnnotation);\n\t\tconst expectedLine = printLabel(aAnnotation) + printExpected(getCommonAndChangedSubstrings(diffs, DIFF_DELETE, hasCommonDiff));\n\t\tconst receivedLine = printLabel(bAnnotation) + printReceived(getCommonAndChangedSubstrings(diffs, DIFF_INSERT, hasCommonDiff));\n\t\treturn `${expectedLine}\\n${receivedLine}`;\n\t}\n\t// if (isLineDiffable(expected, received)) {\n\tconst clonedExpected = deepClone(expected, { forceWritable: true });\n\tconst clonedReceived = deepClone(received, { forceWritable: true });\n\tconst { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedReceived, clonedExpected);\n\tconst memorize = memory ? createMemorize(memory) : DEFAULT_MEMORIZE;\n\tconst difference = diff(replacedExpected, replacedActual, options, memorize);\n\treturn difference;\n\t// }\n\t// const printLabel = getLabelPrinter(aAnnotation, bAnnotation)\n\t// const expectedLine = printLabel(aAnnotation) + printExpected(expected)\n\t// const receivedLine\n\t//   = printLabel(bAnnotation)\n\t//   + (stringify(expected) === stringify(received)\n\t//     ? 'serializes to the same string'\n\t//     : printReceived(received))\n\t// return `${expectedLine}\\n${receivedLine}`\n}\nfunction replaceAsymmetricMatcher(actual, expected, actualReplaced = new WeakSet(), expectedReplaced = new WeakSet()) {\n\t// handle asymmetric Error.cause diff\n\tif (actual instanceof Error && expected instanceof Error && typeof actual.cause !== \"undefined\" && typeof expected.cause === \"undefined\") {\n\t\tdelete actual.cause;\n\t\treturn {\n\t\t\treplacedActual: actual,\n\t\t\treplacedExpected: expected\n\t\t};\n\t}\n\tif (!isReplaceable(actual, expected)) {\n\t\treturn {\n\t\t\treplacedActual: actual,\n\t\t\treplacedExpected: expected\n\t\t};\n\t}\n\tif (actualReplaced.has(actual) || expectedReplaced.has(expected)) {\n\t\treturn {\n\t\t\treplacedActual: actual,\n\t\t\treplacedExpected: expected\n\t\t};\n\t}\n\tactualReplaced.add(actual);\n\texpectedReplaced.add(expected);\n\tgetOwnProperties(expected).forEach((key) => {\n\t\tconst expectedValue = expected[key];\n\t\tconst actualValue = actual[key];\n\t\tif (isAsymmetricMatcher(expectedValue)) {\n\t\t\tif (expectedValue.asymmetricMatch(actualValue)) {\n\t\t\t\t// When matcher matches, replace expected with actual value\n\t\t\t\t// so they appear the same in the diff\n\t\t\t\texpected[key] = actualValue;\n\t\t\t} else if (\"sample\" in expectedValue && expectedValue.sample !== undefined && isReplaceable(actualValue, expectedValue.sample)) {\n\t\t\t\t// For container matchers (ArrayContaining, ObjectContaining), unwrap and recursively process\n\t\t\t\t// Matcher doesn't match: unwrap but keep structure to show mismatch\n\t\t\t\tconst replaced = replaceAsymmetricMatcher(actualValue, expectedValue.sample, actualReplaced, expectedReplaced);\n\t\t\t\tactual[key] = replaced.replacedActual;\n\t\t\t\texpected[key] = replaced.replacedExpected;\n\t\t\t}\n\t\t} else if (isAsymmetricMatcher(actualValue)) {\n\t\t\tif (actualValue.asymmetricMatch(expectedValue)) {\n\t\t\t\tactual[key] = expectedValue;\n\t\t\t} else if (\"sample\" in actualValue && actualValue.sample !== undefined && isReplaceable(actualValue.sample, expectedValue)) {\n\t\t\t\tconst replaced = replaceAsymmetricMatcher(actualValue.sample, expectedValue, actualReplaced, expectedReplaced);\n\t\t\t\tactual[key] = replaced.replacedActual;\n\t\t\t\texpected[key] = replaced.replacedExpected;\n\t\t\t}\n\t\t} else if (isReplaceable(actualValue, expectedValue)) {\n\t\t\tconst replaced = replaceAsymmetricMatcher(actualValue, expectedValue, actualReplaced, expectedReplaced);\n\t\t\tactual[key] = replaced.replacedActual;\n\t\t\texpected[key] = replaced.replacedExpected;\n\t\t}\n\t});\n\treturn {\n\t\treplacedActual: actual,\n\t\treplacedExpected: expected\n\t};\n}\nfunction getLabelPrinter(...strings) {\n\tconst maxLength = strings.reduce((max, string) => string.length > max ? string.length : max, 0);\n\treturn (string) => `${string}: ${\" \".repeat(maxLength - string.length)}`;\n}\nconst SPACE_SYMBOL = \"·\";\nfunction replaceTrailingSpaces(text) {\n\treturn text.replace(/\\s+$/gm, (spaces) => SPACE_SYMBOL.repeat(spaces.length));\n}\nfunction printReceived(object) {\n\treturn c.red(replaceTrailingSpaces(stringify(object)));\n}\nfunction printExpected(value) {\n\treturn c.green(replaceTrailingSpaces(stringify(value)));\n}\nfunction getCommonAndChangedSubstrings(diffs, op, hasCommonDiff) {\n\treturn diffs.reduce((reduced, diff) => reduced + (diff[0] === DIFF_EQUAL ? diff[1] : diff[0] === op ? hasCommonDiff ? c.inverse(diff[1]) : diff[1] : \"\"), \"\");\n}\n\nexport { DIFF_DELETE, DIFF_EQUAL, DIFF_INSERT, Diff, diff, diffLinesRaw, diffLinesUnified, diffLinesUnified2, diffStringsRaw, diffStringsUnified, getDefaultFormatOptions, getLabelPrinter, printDiffOrStringify, replaceAsymmetricMatcher };\n"],"x_google_ignoreList":[0],"mappings":"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"}