@directus/api 35.0.2 → 35.1.0

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

@@ -1,1535 +0,0 @@
-import { u } from "../../../../../tinyrainbow@2.0.0/node_modules/tinyrainbow/dist/node.js";
-import { format, plugins } from "../../../../../@vitest_pretty-format@3.2.4/node_modules/@vitest/pretty-format/dist/index.js";
-import "../../../../../loupe@3.2.1/node_modules/loupe/lib/index.js";
-import { getDefaultExportFromCjs, stringify } from "./chunk-_commonjsHelpers.js";
-import { deepClone, getOwnProperties, getType } from "./helpers.js";
-
-//#region ../node_modules/.pnpm/@vitest+utils@3.2.4/node_modules/@vitest/utils/dist/diff.js
-/**
-* Diff Match and Patch
-* Copyright 2018 The diff-match-patch Authors.
-* https://github.com/google/diff-match-patch
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*   http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-/**
-* @fileoverview Computes the difference between two texts to create a patch.
-* Applies the patch onto another text, allowing for errors.
-* @author fraser@google.com (Neil Fraser)
-*/
-/**
-* CHANGES by pedrottimark to diff_match_patch_uncompressed.ts file:
-*
-* 1. Delete anything not needed to use diff_cleanupSemantic method
-* 2. Convert from prototype properties to var declarations
-* 3. Convert Diff to class from constructor and prototype
-* 4. Add type annotations for arguments and return values
-* 5. Add exports
-*/
-/**
-* The data structure representing a diff is an array of tuples:
-* [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
-* which means: delete 'Hello', add 'Goodbye' and keep ' world.'
-*/
-const DIFF_DELETE = -1;
-const DIFF_INSERT = 1;
-const DIFF_EQUAL = 0;
-/**
-* Class representing one diff tuple.
-* Attempts to look like a two-element array (which is what this used to be).
-* @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
-* @param {string} text Text to be deleted, inserted, or retained.
-* @constructor
-*/
-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] === DIFF_EQUAL) {
-			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] === DIFF_INSERT) {
-				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(DIFF_DELETE, lastEquality));
-				diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
-				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] === DIFF_DELETE && diffs[pointer][0] === DIFF_INSERT) {
-			const deletion = diffs[pointer - 1][1];
-			const insertion = diffs[pointer][1];
-			const overlap_length1 = diff_commonOverlap_(deletion, insertion);
-			const overlap_length2 = diff_commonOverlap_(insertion, deletion);
-			if (overlap_length1 >= overlap_length2) {
-				if (overlap_length1 >= deletion.length / 2 || overlap_length1 >= insertion.length / 2) {
-					diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, insertion.substring(0, overlap_length1)));
-					diffs[pointer - 1][1] = deletion.substring(0, deletion.length - overlap_length1);
-					diffs[pointer + 1][1] = insertion.substring(overlap_length1);
-					pointer++;
-				}
-			} else {
-				if (overlap_length2 >= deletion.length / 2 || overlap_length2 >= insertion.length / 2) {
-					diffs.splice(pointer, 0, new Diff(DIFF_EQUAL, deletion.substring(0, overlap_length2)));
-					diffs[pointer - 1][0] = DIFF_INSERT;
-					diffs[pointer - 1][1] = insertion.substring(0, insertion.length - overlap_length2);
-					diffs[pointer + 1][0] = DIFF_DELETE;
-					diffs[pointer + 1][1] = deletion.substring(overlap_length2);
-					pointer++;
-				}
-			}
-			pointer++;
-		}
-		pointer++;
-	}
-}
-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] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
-			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(DIFF_EQUAL, ""));
-	let pointer = 0;
-	let count_delete = 0;
-	let count_insert = 0;
-	let text_delete = "";
-	let text_insert = "";
-	let commonlength;
-	while (pointer < diffs.length) {
-		switch (diffs[pointer][0]) {
-			case DIFF_INSERT:
-				count_insert++;
-				text_insert += diffs[pointer][1];
-				pointer++;
-				break;
-			case DIFF_DELETE:
-				count_delete++;
-				text_delete += diffs[pointer][1];
-				pointer++;
-				break;
-			case DIFF_EQUAL:
-				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] === DIFF_EQUAL) {
-								diffs[pointer - count_delete - count_insert - 1][1] += text_insert.substring(0, commonlength);
-							} else {
-								diffs.splice(0, 0, new Diff(DIFF_EQUAL, text_insert.substring(0, commonlength)));
-								pointer++;
-							}
-							text_insert = text_insert.substring(commonlength);
-							text_delete = text_delete.substring(commonlength);
-						}
-						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(DIFF_DELETE, text_delete));
-						pointer++;
-					}
-					if (text_insert.length) {
-						diffs.splice(pointer, 0, new Diff(DIFF_INSERT, text_insert));
-						pointer++;
-					}
-					pointer++;
-				} else if (pointer !== 0 && diffs[pointer - 1][0] === DIFF_EQUAL) {
-					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[diffs.length - 1][1] === "") {
-		diffs.pop();
-	}
-	let changes = false;
-	pointer = 1;
-	while (pointer < diffs.length - 1) {
-		if (diffs[pointer - 1][0] === DIFF_EQUAL && diffs[pointer + 1][0] === DIFF_EQUAL) {
-			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.\n" + "Printing internal object structure without calling `toJSON` instead.";
-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 bLength = bEnd - bStart;
-		const baDeltaLength = bLength - 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 bLength = bEnd - bStart;
-		const baDeltaLength = bLength - 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: foundSubsequence$1, isCommon: isCommon$1 } = callbacks[0];
-				callbacks[1] = {
-					foundSubsequence: (nCommon, bCommon, aCommon) => {
-						foundSubsequence$1(nCommon, aCommon, bCommon);
-					},
-					isCommon: (bIndex, aIndex) => isCommon$1(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) {
-				const nChange = 0;
-				const transposed = false;
-				const callbacks = [{
-					foundSubsequence,
-					isCommon
-				}];
-				const aIndexesF = [NOT_YET_SET];
-				const aIndexesR = [NOT_YET_SET];
-				const division = {
-					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
-				};
-				findSubsequences(nChange, aStart, aEnd, bStart, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division);
-			}
-			if (nCommonR !== 0) {
-				foundSubsequence(nCommonR, aEnd, bEnd);
-			}
-		}
-	}
-	return build;
-}
-var buildExports = requireBuild();
-var diffSequences = /* @__PURE__ */ getDefaultExportFromCjs(buildExports);
-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] === DIFF_EQUAL) {
-			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] !== DIFF_EQUAL) {
-			i += 1;
-		}
-	}
-	const hasPatch = nExcessesBetweenChanges !== 0 || hasExcessAtStartOrEnd;
-	if (nExcessesBetweenChanges !== 0) {
-		jLength += nExcessesBetweenChanges + 1;
-	} else if (hasExcessAtStartOrEnd) {
-		jLength += 1;
-	}
-	const jLast = jLength - 1;
-	const lines = [];
-	let jPatchMark = 0;
-	if (hasPatch) {
-		lines.push("");
-	}
-	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] === DIFF_EQUAL) {
-			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] === DIFF_DELETE) {
-			pushDeleteLine(diffs[i][1]);
-			i += 1;
-		}
-		while (i !== iLength && diffs[i][0] === DIFF_INSERT) {
-			pushInsertLine(diffs[i][1]);
-			i += 1;
-		}
-	}
-	if (hasPatch) {
-		lines[jPatchMark] = createPatchMark(aStart, aEnd, bStart, bEnd, options);
-	}
-	return lines.join("\n");
-}
-function joinAlignedDiffsExpand(diffs, options) {
-	return diffs.map((diff$1, i, diffs$1) => {
-		const line = diff$1[1];
-		const isFirstOrLast = i === 0 || i === diffs$1.length - 1;
-		switch (diff$1[0]) {
-			case DIFF_DELETE: return printDeleteLine(line, isFirstOrLast, options);
-			case DIFF_INSERT: return printInsertLine(line, isFirstOrLast, options);
-			default: return printCommonLine(line, isFirstOrLast, options);
-		}
-	}).join("\n");
-}
-const noColor = (string) => string;
-const DIFF_CONTEXT_DEFAULT = 5;
-const DIFF_TRUNCATE_THRESHOLD_DEFAULT = 0;
-function getDefaultOptions() {
-	return {
-		aAnnotation: "Expected",
-		aColor: u.green,
-		aIndicator: "-",
-		bAnnotation: "Received",
-		bColor: u.red,
-		bIndicator: "+",
-		changeColor: u.inverse,
-		changeLineTrailingSpaceColor: noColor,
-		commonColor: u.dim,
-		commonIndicator: " ",
-		commonLineTrailingSpaceColor: noColor,
-		compareKeys: undefined,
-		contextLines: DIFF_CONTEXT_DEFAULT,
-		emptyFirstOrLastLinePlaceholder: "",
-		expand: false,
-		includeChangeCounts: false,
-		omitAnnotationLines: false,
-		patchColor: u.yellow,
-		printBasicPrototype: false,
-		truncateThreshold: DIFF_TRUNCATE_THRESHOLD_DEFAULT,
-		truncateAnnotation: "... Diff result is truncated",
-		truncateAnnotationColor: noColor
-	};
-}
-function getCompareKeys(compareKeys) {
-	return compareKeys && typeof compareKeys === "function" ? compareKeys : undefined;
-}
-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$1) => {
-		switch (diff$1[0]) {
-			case DIFF_DELETE:
-				a += 1;
-				break;
-			case DIFF_INSERT:
-				b += 1;
-				break;
-		}
-	});
-	return {
-		a,
-		b
-	};
-}
-function printAnnotation({ aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator, includeChangeCounts, omitAnnotationLines }, changeCounts) {
-	if (omitAnnotationLines) {
-		return "";
-	}
-	let aRest = "";
-	let bRest = "";
-	if (includeChangeCounts) {
-		const aCount = String(changeCounts.a);
-		const bCount = String(changeCounts.b);
-		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$1) => {
-		switch (diff$1[0]) {
-			case DIFF_DELETE:
-				diff$1[1] = aLinesDisplay[aIndex];
-				aIndex += 1;
-				break;
-			case DIFF_INSERT:
-				diff$1[1] = bLinesDisplay[bIndex];
-				bIndex += 1;
-				break;
-			default:
-				diff$1[1] = bLinesDisplay[bIndex];
-				aIndex += 1;
-				bIndex += 1;
-		}
-	});
-	return printDiffLines(diffs, truncated, normalizeDiffOptions(options));
-}
-function diffLinesRaw(aLines, bLines, options) {
-	const truncate = (options === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
-	const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : 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$1, bIndex$1) => aLines[aIndex$1] === bLines[bIndex$1];
-	const diffs = [];
-	let aIndex = 0;
-	let bIndex = 0;
-	const foundSubsequence = (nCommon, aCommon, bCommon) => {
-		for (; aIndex !== aCommon; aIndex += 1) {
-			diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
-		}
-		for (; bIndex !== bCommon; bIndex += 1) {
-			diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
-		}
-		for (; nCommon !== 0; nCommon -= 1, aIndex += 1, bIndex += 1) {
-			diffs.push(new Diff(DIFF_EQUAL, bLines[bIndex]));
-		}
-	};
-	diffSequences(aLength, bLength, isCommon, foundSubsequence);
-	for (; aIndex !== aLength; aIndex += 1) {
-		diffs.push(new Diff(DIFF_DELETE, aLines[aIndex]));
-	}
-	for (; bIndex !== bLength; bIndex += 1) {
-		diffs.push(new Diff(DIFF_INSERT, bLines[bIndex]));
-	}
-	return [diffs, truncated];
-}
-function getType$1(value) {
-	if (value === undefined) {
-		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 === null || options === void 0 ? void 0 : options.truncateThreshold) ?? false;
-	const truncateThreshold = Math.max(Math.floor((options === null || options === void 0 ? void 0 : 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$1, bIndex$1) => a[aIndex$1] === b[bIndex$1];
-	let aIndex = 0;
-	let bIndex = 0;
-	const diffs = [];
-	const foundSubsequence = (nCommon, aCommon, bCommon) => {
-		if (aIndex !== aCommon) {
-			diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex, aCommon)));
-		}
-		if (bIndex !== bCommon) {
-			diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex, bCommon)));
-		}
-		aIndex = aCommon + nCommon;
-		bIndex = bCommon + nCommon;
-		diffs.push(new Diff(DIFF_EQUAL, b.slice(bCommon, bIndex)));
-	};
-	diffSequences(aLength, bLength, isCommon, foundSubsequence);
-	if (aIndex !== aLength) {
-		diffs.push(new Diff(DIFF_DELETE, a.slice(aIndex)));
-	}
-	if (bIndex !== bLength) {
-		diffs.push(new Diff(DIFF_INSERT, b.slice(bIndex)));
-	}
-	return [diffs, truncated];
-}
-function concatenateRelevantDiffs(op, diffs, changeColor) {
-	return diffs.reduce((reduced, diff$1) => reduced + (diff$1[0] === DIFF_EQUAL ? diff$1[1] : diff$1[0] === op && diff$1[1].length !== 0 ? changeColor(diff$1[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$1) {
-		this.line.push(diff$1);
-	}
-	align(diff$1) {
-		const string = diff$1[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$1);
-		}
-	}
-	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$1) {
-		this.lines.push(diff$1);
-	}
-	pushDiffChangeLines(diff$1) {
-		const isDiffEmpty = diff$1[1].length === 0;
-		if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {
-			this.deleteBuffer.pushDiff(diff$1);
-		}
-		if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {
-			this.insertBuffer.pushDiff(diff$1);
-		}
-	}
-	flushChangeLines() {
-		this.deleteBuffer.moveLinesTo(this.lines);
-		this.insertBuffer.moveLinesTo(this.lines);
-	}
-	align(diff$1) {
-		const op = diff$1[0];
-		const string = diff$1[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$1);
-		}
-	}
-	getLines() {
-		this.flushChangeLines();
-		return this.lines;
-	}
-};
-function getAlignedDiffs(diffs, changeColor) {
-	const deleteBuffer = new ChangeBuffer(DIFF_DELETE, changeColor);
-	const insertBuffer = new ChangeBuffer(DIFF_INSERT, changeColor);
-	const commonBuffer = new CommonBuffer(deleteBuffer, insertBuffer);
-	diffs.forEach((diff$1) => {
-		switch (diff$1[0]) {
-			case DIFF_DELETE:
-				deleteBuffer.align(diff$1);
-				break;
-			case DIFF_INSERT:
-				insertBuffer.align(diff$1);
-				break;
-			default: commonBuffer.align(diff$1);
-		}
-	});
-	return commonBuffer.getLines();
-}
-function hasCommonDiff(diffs, isMultiline) {
-	if (isMultiline) {
-		const iLast = diffs.length - 1;
-		return diffs.some((diff$1, i) => diff$1[0] === DIFF_EQUAL && (i !== iLast || diff$1[1] !== "\n"));
-	}
-	return diffs.some((diff$1) => diff$1[0] === DIFF_EQUAL);
-}
-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);
-			const lines = getAlignedDiffs(diffs, optionsNormalized.changeColor);
-			return printDiffLines(lines, 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
-};
-/**
-* @param a Expected value
-* @param b Received value
-* @param options Diff options
-* @returns {string | null} a string diff
-*/
-function diff(a, b, options) {
-	if (Object.is(a, b)) {
-		return "";
-	}
-	const aType = getType$1(a);
-	let expectedType = aType;
-	let omitDifference = false;
-	if (aType === "object" && typeof a.asymmetricMatch === "function") {
-		if (a.$$typeof !== Symbol.for("jest.asymmetricMatcher")) {
-			return undefined;
-		}
-		if (typeof a.getExpectedType !== "function") {
-			return undefined;
-		}
-		expectedType = a.getExpectedType();
-		omitDifference = expectedType === "string";
-	}
-	if (expectedType !== getType$1(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 = truncate(aDisplay);
-		bDisplay = truncate(bDisplay);
-		const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)} \n${aDisplay}`;
-		const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)} \n${bDisplay}`;
-		return `${aDiff}\n\n${bDiff}`;
-	}
-	if (omitDifference) {
-		return undefined;
-	}
-	switch (aType) {
-		case "string": return diffLinesUnified(a.split("\n"), b.split("\n"), options);
-		case "boolean":
-		case "number": return comparePrimitive(a, b, options);
-		case "map": return compareObjects(sortMap(a), sortMap(b), options);
-		case "set": return compareObjects(sortSet(a), sortSet(b), options);
-		default: return compareObjects(a, b, options);
-	}
-}
-function comparePrimitive(a, b, options) {
-	const aFormat = format(a, FORMAT_OPTIONS);
-	const bFormat = 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) {
-	let difference;
-	let hasThrown = false;
-	try {
-		const formatOptions = getFormatOptions(FORMAT_OPTIONS, options);
-		difference = getObjectsDifference(a, b, formatOptions, options);
-	} catch {
-		hasThrown = true;
-	}
-	const noDiffMessage = getCommonMessage(NO_DIFF_MESSAGE, options);
-	if (difference === undefined || difference === noDiffMessage) {
-		const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-		difference = getObjectsDifference(a, b, formatOptions, options);
-		if (difference !== noDiffMessage && !hasThrown) {
-			difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}\n\n${difference}`;
-		}
-	}
-	return difference;
-}
-function getFormatOptions(formatOptions, options) {
-	const { compareKeys, printBasicPrototype, maxDepth } = normalizeDiffOptions(options);
-	return {
-		...formatOptions,
-		compareKeys,
-		printBasicPrototype,
-		maxDepth: maxDepth ?? formatOptions.maxDepth
-	};
-}
-function getObjectsDifference(a, b, formatOptions, options) {
-	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 = format(a, formatOptions);
-		const bDisplay = 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) {
-	const type = getType(data);
-	return type === "Object" && typeof data.asymmetricMatch === "function";
-}
-function isReplaceable(obj1, obj2) {
-	const obj1Type = getType(obj1);
-	const obj2Type = getType(obj2);
-	return obj1Type === obj2Type && (obj1Type === "Object" || obj1Type === "Array");
-}
-function printDiffOrStringify(received, expected, options) {
-	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$1 = diffs.some((diff$1) => diff$1[0] === DIFF_EQUAL);
-		const printLabel = getLabelPrinter(aAnnotation, bAnnotation);
-		const expectedLine = printLabel(aAnnotation) + printExpected(getCommonAndChangedSubstrings(diffs, DIFF_DELETE, hasCommonDiff$1));
-		const receivedLine = printLabel(bAnnotation) + printReceived(getCommonAndChangedSubstrings(diffs, DIFF_INSERT, hasCommonDiff$1));
-		return `${expectedLine}\n${receivedLine}`;
-	}
-	const clonedExpected = deepClone(expected, { forceWritable: true });
-	const clonedReceived = deepClone(received, { forceWritable: true });
-	const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedReceived, clonedExpected);
-	const difference = diff(replacedExpected, replacedActual, options);
-	return difference;
-}
-function replaceAsymmetricMatcher(actual, expected, actualReplaced = new WeakSet(), expectedReplaced = 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)) {
-				actual[key] = expectedValue;
-			}
-		} else if (isAsymmetricMatcher(actualValue)) {
-			if (actualValue.asymmetricMatch(expectedValue)) {
-				expected[key] = actualValue;
-			}
-		} 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 u.red(replaceTrailingSpaces(stringify(object)));
-}
-function printExpected(value) {
-	return u.green(replaceTrailingSpaces(stringify(value)));
-}
-function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff$1) {
-	return diffs.reduce((reduced, diff$1) => reduced + (diff$1[0] === DIFF_EQUAL ? diff$1[1] : diff$1[0] === op ? hasCommonDiff$1 ? u.inverse(diff$1[1]) : diff$1[1] : ""), "");
-}
-
-//#endregion
-export { diff, printDiffOrStringify };