@noma.to/qwik-mock 1.1.0 → 1.1.2

package/lib/node_modules/.pnpm/@vitest_utils@4.0.18/node_modules/@vitest/utils/dist/diff.cjs

@@ -1,1626 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const index = require("../../../../../@vitest_pretty-format@4.0.18/node_modules/@vitest/pretty-format/dist/index.cjs");
-const index$1 = require("../../../../../tinyrainbow@3.0.3/node_modules/tinyrainbow/dist/index.cjs");
-const display = require("./display.cjs");
-const helpers = require("./helpers.cjs");
-const chunk_commonjsHelpers = require("./chunk-_commonjsHelpers.cjs");
-const DIFF_DELETE = -1;
-const DIFF_INSERT = 1;
-const DIFF_EQUAL = 0;
-class Diff {
-  constructor(op, text) {
-    __publicField(this, 0);
-    __publicField(this, 1);
-    this[0] = op;
-    this[1] = text;
-  }
-}
-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;
-}
-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;
-}
-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++;
-    }
-  }
-}
-function diff_cleanupSemantic(diffs) {
-  let changes = false;
-  const equalities = [];
-  let equalitiesLength = 0;
-  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/;
-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++;
-  }
-}
-function diff_cleanupMerge(diffs) {
-  var _diffs$at;
-  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$at = diffs.at(-1)) === null || _diffs$at === void 0 ? void 0 : _diffs$at[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);
-  }
-}
-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;
-}
-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.";
-var build = {};
-var hasRequiredBuild;
-function requireBuild() {
-  if (hasRequiredBuild) return build;
-  hasRequiredBuild = 1;
-  Object.defineProperty(build, "__esModule", {
-    value: true
-  });
-  build.default = diffSequence;
-  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 (
-          // If a reverse path overlaps a forward path in the same diagonal,
-          // return a division of the index intervals at the middle change.
-          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 (
-          // If a forward path overlaps a reverse path in the same diagonal,
-          // return a division of the index intervals at the middle change.
-          extendOverlappablePathsF(
-            d,
-            aStart,
-            aEnd,
-            bStart,
-            bEnd,
-            isCommon,
-            aIndexesF,
-            iMaxF,
-            aIndexesR,
-            iMaxR,
-            division
-          )
-        ) {
-          return;
-        }
-      }
-    }
-    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: foundSubsequence2, isCommon: isCommon2 } = callbacks[0];
-        callbacks[1] = {
-          foundSubsequence: (nCommon, bCommon, aCommon) => {
-            foundSubsequence2(nCommon, aCommon, bCommon);
-          },
-          isCommon: (bIndex, aIndex) => isCommon2(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 = /* @__PURE__ */ requireBuild();
-var diffSequences = /* @__PURE__ */ chunk_commonjsHelpers.g(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((diff2, i, diffs2) => {
-    const line = diff2[1];
-    const isFirstOrLast = i === 0 || i === diffs2.length - 1;
-    switch (diff2[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: index$1.default.green,
-    aIndicator: "-",
-    bAnnotation: "Received",
-    bColor: index$1.default.red,
-    bIndicator: "+",
-    changeColor: index$1.default.inverse,
-    changeLineTrailingSpaceColor: noColor,
-    commonColor: index$1.default.dim,
-    commonIndicator: " ",
-    commonLineTrailingSpaceColor: noColor,
-    compareKeys: void 0,
-    contextLines: DIFF_CONTEXT_DEFAULT,
-    emptyFirstOrLastLinePlaceholder: "",
-    expand: false,
-    includeChangeCounts: false,
-    omitAnnotationLines: false,
-    patchColor: index$1.default.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((diff2) => {
-    switch (diff2[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)}
-${bColor(b)}
-
-`;
-}
-function printDiffLines(diffs, truncated, options) {
-  return printAnnotation(options, countChanges(diffs)) + (options.expand ? joinAlignedDiffsExpand(diffs, options) : joinAlignedDiffsNoExpand(diffs, options)) + (truncated ? options.truncateAnnotationColor(`
-${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((diff2) => {
-    switch (diff2[0]) {
-      case DIFF_DELETE:
-        diff2[1] = aLinesDisplay[aIndex];
-        aIndex += 1;
-        break;
-      case DIFF_INSERT:
-        diff2[1] = bLinesDisplay[bIndex];
-        bIndex += 1;
-        break;
-      default:
-        diff2[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 = (aIndex2, bIndex2) => aLines[aIndex2] === bLines[bIndex2];
-  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(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 === 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)}
-` : a;
-    const _b = bMultipleLines ? `${b.split(bNewLineSymbol, truncateThreshold).join(bNewLineSymbol)}
-` : b;
-    aLength = _a.length;
-    bLength = _b.length;
-  }
-  const truncated = aLength !== a.length || bLength !== b.length;
-  const isCommon = (aIndex2, bIndex2) => a[aIndex2] === b[bIndex2];
-  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, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op && diff2[1].length !== 0 ? changeColor(diff2[1]) : ""), "");
-}
-class ChangeBuffer {
-  constructor(op, changeColor) {
-    __publicField(this, "op");
-    __publicField(this, "line");
-    __publicField(this, "lines");
-    __publicField(this, "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;
-  }
-  // Minor input to buffer.
-  pushDiff(diff2) {
-    this.line.push(diff2);
-  }
-  // Main input to buffer.
-  align(diff2) {
-    const string = diff2[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(diff2);
-    }
-  }
-  // Output from buffer.
-  moveLinesTo(lines) {
-    if (!this.isLineEmpty()) {
-      this.pushLine();
-    }
-    lines.push(...this.lines);
-    this.lines.length = 0;
-  }
-}
-class CommonBuffer {
-  constructor(deleteBuffer, insertBuffer) {
-    __publicField(this, "deleteBuffer");
-    __publicField(this, "insertBuffer");
-    __publicField(this, "lines");
-    this.deleteBuffer = deleteBuffer;
-    this.insertBuffer = insertBuffer;
-    this.lines = [];
-  }
-  pushDiffCommonLine(diff2) {
-    this.lines.push(diff2);
-  }
-  pushDiffChangeLines(diff2) {
-    const isDiffEmpty = diff2[1].length === 0;
-    if (!isDiffEmpty || this.deleteBuffer.isLineEmpty()) {
-      this.deleteBuffer.pushDiff(diff2);
-    }
-    if (!isDiffEmpty || this.insertBuffer.isLineEmpty()) {
-      this.insertBuffer.pushDiff(diff2);
-    }
-  }
-  flushChangeLines() {
-    this.deleteBuffer.moveLinesTo(this.lines);
-    this.insertBuffer.moveLinesTo(this.lines);
-  }
-  // Input to buffer.
-  align(diff2) {
-    const op = diff2[0];
-    const string = diff2[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(diff2);
-    }
-  }
-  // Output from buffer.
-  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((diff2) => {
-    switch (diff2[0]) {
-      case DIFF_DELETE:
-        deleteBuffer.align(diff2);
-        break;
-      case DIFF_INSERT:
-        insertBuffer.align(diff2);
-        break;
-      default:
-        commonBuffer.align(diff2);
-    }
-  });
-  return commonBuffer.getLines();
-}
-function hasCommonDiff(diffs, isMultiline) {
-  if (isMultiline) {
-    const iLast = diffs.length - 1;
-    return diffs.some((diff2, i) => diff2[0] === DIFF_EQUAL && (i !== iLast || diff2[1] !== "\n"));
-  }
-  return diffs.some((diff2) => diff2[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}
-` : a, isMultiline ? `${b}
-` : 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);
-  {
-    diff_cleanupSemantic(diffs);
-  }
-  return [diffs, truncated];
-}
-function getCommonMessage(message, options) {
-  const { commonColor } = normalizeDiffOptions(options);
-  return commonColor(message);
-}
-const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = index.plugins;
-const PLUGINS = [
-  ReactTestComponent,
-  ReactElement,
-  DOMElement,
-  DOMCollection,
-  Immutable,
-  AsymmetricMatcher,
-  index.plugins.Error
-];
-const FORMAT_OPTIONS = {
-  maxDepth: 20,
-  plugins: PLUGINS
-};
-const FALLBACK_FORMAT_OPTIONS = {
-  callToJSON: false,
-  maxDepth: 8,
-  plugins: PLUGINS
-};
-function diff(a, b, options) {
-  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 !== /* @__PURE__ */ Symbol.for("jest.asymmetricMatcher")) {
-      return void 0;
-    }
-    if (typeof a.getExpectedType !== "function") {
-      return void 0;
-    }
-    expectedType = a.getExpectedType();
-    omitDifference = expectedType === "string";
-  }
-  if (expectedType !== getType(b)) {
-    let truncate = function(s) {
-      return s.length <= MAX_LENGTH ? s : `${s.slice(0, MAX_LENGTH)}...`;
-    };
-    const { aAnnotation, aColor, aIndicator, bAnnotation, bColor, bIndicator } = normalizeDiffOptions(options);
-    const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    let aDisplay = index.format(a, formatOptions);
-    let bDisplay = index.format(b, formatOptions);
-    const MAX_LENGTH = 1e5;
-    aDisplay = truncate(aDisplay);
-    bDisplay = truncate(bDisplay);
-    const aDiff = `${aColor(`${aIndicator} ${aAnnotation}:`)} 
-${aDisplay}`;
-    const bDiff = `${bColor(`${bIndicator} ${bAnnotation}:`)} 
-${bDisplay}`;
-    return `${aDiff}
-
-${bDiff}`;
-  }
-  if (omitDifference) {
-    return void 0;
-  }
-  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 = index.format(a, FORMAT_OPTIONS);
-  const bFormat = index.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 === void 0 || difference === noDiffMessage) {
-    const formatOptions = getFormatOptions(FALLBACK_FORMAT_OPTIONS, options);
-    difference = getObjectsDifference(a, b, formatOptions, options);
-    if (difference !== noDiffMessage && !hasThrown) {
-      difference = `${getCommonMessage(SIMILAR_MESSAGE, options)}
-
-${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 = index.format(a, formatOptionsZeroIndent);
-  const bCompare = index.format(b, formatOptionsZeroIndent);
-  if (aCompare === bCompare) {
-    return getCommonMessage(NO_DIFF_MESSAGE, options);
-  } else {
-    const aDisplay = index.format(a, formatOptions);
-    const bDisplay = index.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 = helpers.getType(data);
-  return type === "Object" && typeof data.asymmetricMatch === "function";
-}
-function isReplaceable(obj1, obj2) {
-  const obj1Type = helpers.getType(obj1);
-  const obj2Type = helpers.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);
-    const hasCommonDiff2 = diffs.some((diff2) => diff2[0] === DIFF_EQUAL);
-    const printLabel = getLabelPrinter(aAnnotation, bAnnotation);
-    const expectedLine = printLabel(aAnnotation) + printExpected(getCommonAndChangedSubstrings(diffs, DIFF_DELETE, hasCommonDiff2));
-    const receivedLine = printLabel(bAnnotation) + printReceived(getCommonAndChangedSubstrings(diffs, DIFF_INSERT, hasCommonDiff2));
-    return `${expectedLine}
-${receivedLine}`;
-  }
-  const clonedExpected = helpers.deepClone(expected, { forceWritable: true });
-  const clonedReceived = helpers.deepClone(received, { forceWritable: true });
-  const { replacedExpected, replacedActual } = replaceAsymmetricMatcher(clonedReceived, clonedExpected);
-  const difference = diff(replacedExpected, replacedActual, options);
-  return difference;
-}
-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);
-  helpers.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 index$1.default.red(replaceTrailingSpaces(display.stringify(object)));
-}
-function printExpected(value) {
-  return index$1.default.green(replaceTrailingSpaces(display.stringify(value)));
-}
-function getCommonAndChangedSubstrings(diffs, op, hasCommonDiff2) {
-  return diffs.reduce((reduced, diff2) => reduced + (diff2[0] === DIFF_EQUAL ? diff2[1] : diff2[0] === op ? hasCommonDiff2 ? index$1.default.inverse(diff2[1]) : diff2[1] : ""), "");
-}
-exports.DIFF_DELETE = DIFF_DELETE;
-exports.DIFF_EQUAL = DIFF_EQUAL;
-exports.DIFF_INSERT = DIFF_INSERT;
-exports.Diff = Diff;
-exports.diff = diff;
-exports.diffLinesRaw = diffLinesRaw;
-exports.diffLinesUnified = diffLinesUnified;
-exports.diffLinesUnified2 = diffLinesUnified2;
-exports.diffStringsRaw = diffStringsRaw;
-exports.diffStringsUnified = diffStringsUnified;
-exports.getLabelPrinter = getLabelPrinter;
-exports.printDiffOrStringify = printDiffOrStringify;
-exports.replaceAsymmetricMatcher = replaceAsymmetricMatcher;