@casual-simulation/expect 2.0.18

package/src/diff-sequences/index.js

@@ -0,0 +1,506 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const pkg = 'diff-sequences'; // for error messages
+const NOT_YET_SET = 0; // small int instead of undefined to avoid deopt in V8
+// Return the number of common items that follow in forward direction.
+// The length of what Myers paper calls a “snake” in a forward path.
+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;
+};
+// Return the number of common items that precede in reverse direction.
+// The length of what Myers paper calls a “snake” in a reverse path.
+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;
+};
+// A simple function to extend forward paths from (d - 1) to d changes
+// when forward and reverse paths cannot yet overlap.
+const extendPathsF = (d, aEnd, bEnd, bF, // bIndex = bF + aIndex - kF
+isCommon, aIndexesF, // update indexes in sequence a of paths in diagonals kF
+iMaxF // return the value because optimization might decrease it
+) => {
+    // Unroll the first iteration.
+    let iF = 0;
+    let kF = -d; // kF = 2 * iF - d
+    let aFirst = aIndexesF[iF]; // in first iteration always insert
+    let aIndexPrev1 = aFirst; // prev value of [iF - 1] in next iteration
+    aIndexesF[iF] += countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
+    // Optimization: skip diagonals in which paths cannot ever overlap.
+    const nF = d < iMaxF ? d : iMaxF;
+    // The diagonals kF are odd when d is odd and even when d is even.
+    for (iF += 1, kF += 2; iF <= nF; iF += 1, kF += 2) {
+        // To get first point of path segment, move one change in forward direction
+        // from last point of previous path segment in an adjacent diagonal.
+        // In last possible iteration when iF === d and kF === d always delete.
+        if (iF !== d && aIndexPrev1 < aIndexesF[iF]) {
+            aFirst = aIndexesF[iF]; // vertical to insert from b
+        }
+        else {
+            aFirst = aIndexPrev1 + 1; // horizontal to delete from a
+            if (aEnd <= aFirst) {
+                // Optimization: delete moved past right of graph.
+                return iF - 1;
+            }
+        }
+        // To get last point of path segment, move along diagonal of common items.
+        aIndexPrev1 = aIndexesF[iF];
+        aIndexesF[iF] =
+            aFirst +
+                countCommonItemsF(aFirst + 1, aEnd, bF + aFirst - kF + 1, bEnd, isCommon);
+    }
+    return iMaxF;
+};
+// A simple function to extend reverse paths from (d - 1) to d changes
+// when reverse and forward paths cannot yet overlap.
+const extendPathsR = (d, aStart, bStart, bR, // bIndex = bR + aIndex - kR
+isCommon, aIndexesR, // update indexes in sequence a of paths in diagonals kR
+iMaxR // return the value because optimization might decrease it
+) => {
+    // Unroll the first iteration.
+    let iR = 0;
+    let kR = d; // kR = d - 2 * iR
+    let aFirst = aIndexesR[iR]; // in first iteration always insert
+    let aIndexPrev1 = aFirst; // prev value of [iR - 1] in next iteration
+    aIndexesR[iR] -= countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
+    // Optimization: skip diagonals in which paths cannot ever overlap.
+    const nR = d < iMaxR ? d : iMaxR;
+    // The diagonals kR are odd when d is odd and even when d is even.
+    for (iR += 1, kR -= 2; iR <= nR; iR += 1, kR -= 2) {
+        // To get first point of path segment, move one change in reverse direction
+        // from last point of previous path segment in an adjacent diagonal.
+        // In last possible iteration when iR === d and kR === -d always delete.
+        if (iR !== d && aIndexesR[iR] < aIndexPrev1) {
+            aFirst = aIndexesR[iR]; // vertical to insert from b
+        }
+        else {
+            aFirst = aIndexPrev1 - 1; // horizontal to delete from a
+            if (aFirst < aStart) {
+                // Optimization: delete moved past left of graph.
+                return iR - 1;
+            }
+        }
+        // To get last point of path segment, move along diagonal of common items.
+        aIndexPrev1 = aIndexesR[iR];
+        aIndexesR[iR] =
+            aFirst -
+                countCommonItemsR(aStart, aFirst - 1, bStart, bR + aFirst - kR - 1, isCommon);
+    }
+    return iMaxR;
+};
+// A complete function to extend forward paths from (d - 1) to d changes.
+// Return true if a path overlaps reverse path of (d - 1) changes in its diagonal.
+const extendOverlappablePathsF = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, // update indexes in sequence a of paths in diagonals kF
+iMaxF, aIndexesR, iMaxR, division // update prop values if return true
+) => {
+    const bF = bStart - aStart; // bIndex = bF + aIndex - kF
+    const aLength = aEnd - aStart;
+    const bLength = bEnd - bStart;
+    const baDeltaLength = bLength - aLength; // kF = kR - baDeltaLength
+    // Range of diagonals in which forward and reverse paths might overlap.
+    const kMinOverlapF = -baDeltaLength - (d - 1); // -(d - 1) <= kR
+    const kMaxOverlapF = -baDeltaLength + (d - 1); // kR <= (d - 1)
+    let aIndexPrev1 = NOT_YET_SET; // prev value of [iF - 1] in next iteration
+    // Optimization: skip diagonals in which paths cannot ever overlap.
+    const nF = d < iMaxF ? d : iMaxF;
+    // The diagonals kF = 2 * iF - d are odd when d is odd and even when d is even.
+    for (let iF = 0, kF = -d; iF <= nF; iF += 1, kF += 2) {
+        // To get first point of path segment, move one change in forward direction
+        // from last point of previous path segment in an adjacent diagonal.
+        // In first iteration when iF === 0 and kF === -d always insert.
+        // In last possible iteration when iF === d and kF === d always delete.
+        const insert = iF === 0 || (iF !== d && aIndexPrev1 < aIndexesF[iF]);
+        const aLastPrev = insert ? aIndexesF[iF] : aIndexPrev1;
+        const aFirst = insert
+            ? aLastPrev // vertical to insert from b
+            : aLastPrev + 1; // horizontal to delete from a
+        // To get last point of path segment, move along diagonal of common items.
+        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) {
+            // Solve for iR of reverse path with (d - 1) changes in diagonal kF:
+            // kR = kF + baDeltaLength
+            // kR = (d - 1) - 2 * iR
+            const iR = (d - 1 - (kF + baDeltaLength)) / 2;
+            // If this forward path overlaps the reverse path in this diagonal,
+            // then this is the middle change of the index intervals.
+            if (iR <= iMaxR && aIndexesR[iR] - 1 <= aLast) {
+                // Unlike the Myers algorithm which finds only the middle “snake”
+                // this package can find two common subsequences per division.
+                // Last point of previous path segment is on an adjacent diagonal.
+                const bLastPrev = bF + aLastPrev - (insert ? kF + 1 : kF - 1);
+                // Because of invariant that intervals preceding the middle change
+                // cannot have common items at the end,
+                // move in reverse direction along a diagonal of common items.
+                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) {
+                    // Optimization: number of preceding changes in forward direction
+                    // is equal to number of items in preceding interval,
+                    // therefore it cannot contain any common items.
+                    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) {
+                    // Optimization: number of changes in reverse direction
+                    // is equal to number of items in following interval,
+                    // therefore it cannot contain any common items.
+                    division.aStartFollowing = aEnd;
+                    division.bStartFollowing = bEnd;
+                }
+                else {
+                    division.aStartFollowing = aStartFollowing;
+                    division.bStartFollowing = bStartFollowing;
+                }
+                return true;
+            }
+        }
+    }
+    return false;
+};
+// A complete function to extend reverse paths from (d - 1) to d changes.
+// Return true if a path overlaps forward path of d changes in its diagonal.
+const extendOverlappablePathsR = (d, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, iMaxF, aIndexesR, // update indexes in sequence a of paths in diagonals kR
+iMaxR, division // update prop values if return true
+) => {
+    const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR
+    const aLength = aEnd - aStart;
+    const bLength = bEnd - bStart;
+    const baDeltaLength = bLength - aLength; // kR = kF + baDeltaLength
+    // Range of diagonals in which forward and reverse paths might overlap.
+    const kMinOverlapR = baDeltaLength - d; // -d <= kF
+    const kMaxOverlapR = baDeltaLength + d; // kF <= d
+    let aIndexPrev1 = NOT_YET_SET; // prev value of [iR - 1] in next iteration
+    // Optimization: skip diagonals in which paths cannot ever overlap.
+    const nR = d < iMaxR ? d : iMaxR;
+    // The diagonals kR = d - 2 * iR are odd when d is odd and even when d is even.
+    for (let iR = 0, kR = d; iR <= nR; iR += 1, kR -= 2) {
+        // To get first point of path segment, move one change in reverse direction
+        // from last point of previous path segment in an adjacent diagonal.
+        // In first iteration when iR === 0 and kR === d always insert.
+        // In last possible iteration when iR === d and kR === -d always delete.
+        const insert = iR === 0 || (iR !== d && aIndexesR[iR] < aIndexPrev1);
+        const aLastPrev = insert ? aIndexesR[iR] : aIndexPrev1;
+        const aFirst = insert
+            ? aLastPrev // vertical to insert from b
+            : aLastPrev - 1; // horizontal to delete from a
+        // To get last point of path segment, move along diagonal of common items.
+        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) {
+            // Solve for iF of forward path with d changes in diagonal kR:
+            // kF = kR - baDeltaLength
+            // kF = 2 * iF - d
+            const iF = (d + (kR - baDeltaLength)) / 2;
+            // If this reverse path overlaps the forward path in this diagonal,
+            // then this is a middle change of the index intervals.
+            if (iF <= iMaxF && aLast - 1 <= aIndexesF[iF]) {
+                const bLast = bFirst - nCommonR;
+                division.nChangePreceding = d;
+                if (d === aLast + bLast - aStart - bStart) {
+                    // Optimization: number of changes in reverse direction
+                    // is equal to number of items in preceding interval,
+                    // therefore it cannot contain any common items.
+                    division.aEndPreceding = aStart;
+                    division.bEndPreceding = bStart;
+                }
+                else {
+                    division.aEndPreceding = aLast;
+                    division.bEndPreceding = bLast;
+                }
+                division.nCommonPreceding = nCommonR;
+                if (nCommonR !== 0) {
+                    // The last point of reverse path segment is start of common subsequence.
+                    division.aCommonPreceding = aLast;
+                    division.bCommonPreceding = bLast;
+                }
+                division.nChangeFollowing = d - 1;
+                if (d === 1) {
+                    // There is no previous path segment.
+                    division.nCommonFollowing = 0;
+                    division.aStartFollowing = aEnd;
+                    division.bStartFollowing = bEnd;
+                }
+                else {
+                    // Unlike the Myers algorithm which finds only the middle “snake”
+                    // this package can find two common subsequences per division.
+                    // Last point of previous path segment is on an adjacent diagonal.
+                    const bLastPrev = bR + aLastPrev - (insert ? kR - 1 : kR + 1);
+                    // Because of invariant that intervals following the middle change
+                    // cannot have common items at the start,
+                    // move in forward direction along a diagonal of common items.
+                    const nCommonF = countCommonItemsF(aLastPrev, aEnd, bLastPrev, bEnd, isCommon);
+                    division.nCommonFollowing = nCommonF;
+                    if (nCommonF !== 0) {
+                        // The last point of reverse path segment is start of common subsequence.
+                        division.aCommonFollowing = aLastPrev;
+                        division.bCommonFollowing = bLastPrev;
+                    }
+                    const aStartFollowing = aLastPrev + nCommonF; // aFirstPrev
+                    const bStartFollowing = bLastPrev + nCommonF; // bFirstPrev
+                    if (d - 1 ===
+                        aEnd + bEnd - aStartFollowing - bStartFollowing) {
+                        // Optimization: number of changes in forward direction
+                        // is equal to number of items in following interval,
+                        // therefore it cannot contain any common items.
+                        division.aStartFollowing = aEnd;
+                        division.bStartFollowing = bEnd;
+                    }
+                    else {
+                        division.aStartFollowing = aStartFollowing;
+                        division.bStartFollowing = bStartFollowing;
+                    }
+                }
+                return true;
+            }
+        }
+    }
+    return false;
+};
+// Given index intervals and input function to compare items at indexes,
+// divide at the middle change.
+//
+// DO NOT CALL if start === end, because interval cannot contain common items
+// and because this function will throw the “no overlap” error.
+const divide = (nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, // temporary memory, not input nor output
+aIndexesR, // temporary memory, not input nor output
+division // output
+) => {
+    const bF = bStart - aStart; // bIndex = bF + aIndex - kF
+    const bR = bEnd - aEnd; // bIndex = bR + aIndex - kR
+    const aLength = aEnd - aStart;
+    const bLength = bEnd - bStart;
+    // Because graph has square or portrait orientation,
+    // length difference is minimum number of items to insert from b.
+    // Corresponding forward and reverse diagonals in graph
+    // depend on length difference of the sequences:
+    // kF = kR - baDeltaLength
+    // kR = kF + baDeltaLength
+    const baDeltaLength = bLength - aLength;
+    // Optimization: max diagonal in graph intersects corner of shorter side.
+    let iMaxF = aLength;
+    let iMaxR = aLength;
+    // Initialize no changes yet in forward or reverse direction:
+    aIndexesF[0] = aStart - 1; // at open start of interval, outside closed start
+    aIndexesR[0] = aEnd; // at open end of interval
+    if (baDeltaLength % 2 === 0) {
+        // The number of changes in paths is 2 * d if length difference is even.
+        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 {
+        // The number of changes in paths is 2 * d - 1 if length difference is odd.
+        const dMin = ((nChange || baDeltaLength) + 1) / 2;
+        const dMax = (aLength + bLength + 1) / 2;
+        // Unroll first half iteration so loop extends the relevant pairs of paths.
+        // Because of invariant that intervals have no common items at start or end,
+        // and limitation not to call divide with empty intervals,
+        // therefore it cannot be called if a forward path with one change
+        // would overlap a reverse path with no changes, even if dMin === 1.
+        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;
+            }
+        }
+    }
+    /* istanbul ignore next */
+    throw new Error(`${pkg}: no overlap aStart=${aStart} aEnd=${aEnd} bStart=${bStart} bEnd=${bEnd}`);
+};
+// Given index intervals and input function to compare items at indexes,
+// return by output function the number of adjacent items and starting indexes
+// of each common subsequence. Divide and conquer with only linear space.
+//
+// The index intervals are half open [start, end) like array slice method.
+// DO NOT CALL if start === end, because interval cannot contain common items
+// and because divide function will throw the “no overlap” error.
+const findSubsequences = (nChange, aStart, aEnd, bStart, bEnd, transposed, callbacks, aIndexesF, // temporary memory, not input nor output
+aIndexesR, // temporary memory, not input nor output
+division // temporary memory, not input nor output
+) => {
+    if (bEnd - bStart < aEnd - aStart) {
+        // Transpose graph so it has portrait instead of landscape orientation.
+        // Always compare shorter to longer sequence for consistency and optimization.
+        transposed = !transposed;
+        if (transposed && callbacks.length === 1) {
+            // Lazily wrap callback functions to swap args if graph is transposed.
+            const { foundSubsequence, isCommon } = callbacks[0];
+            callbacks[1] = {
+                foundSubsequence: (nCommon, bCommon, aCommon) => {
+                    foundSubsequence(nCommon, aCommon, bCommon);
+                },
+                isCommon: (bIndex, aIndex) => isCommon(aIndex, bIndex),
+            };
+        }
+        const tStart = aStart;
+        const tEnd = aEnd;
+        aStart = bStart;
+        aEnd = bEnd;
+        bStart = tStart;
+        bEnd = tEnd;
+    }
+    const { foundSubsequence, isCommon } = callbacks[transposed ? 1 : 0];
+    // Divide the index intervals at the middle change.
+    divide(nChange, aStart, aEnd, bStart, bEnd, isCommon, aIndexesF, aIndexesR, division);
+    const { nChangePreceding, aEndPreceding, bEndPreceding, nCommonPreceding, aCommonPreceding, bCommonPreceding, nCommonFollowing, aCommonFollowing, bCommonFollowing, nChangeFollowing, aStartFollowing, bStartFollowing, } = division;
+    // Unless either index interval is empty, they might contain common items.
+    if (aStart < aEndPreceding && bStart < bEndPreceding) {
+        // Recursely find and return common subsequences preceding the division.
+        findSubsequences(nChangePreceding, aStart, aEndPreceding, bStart, bEndPreceding, transposed, callbacks, aIndexesF, aIndexesR, division);
+    }
+    // Return common subsequences that are adjacent to the middle change.
+    if (nCommonPreceding !== 0) {
+        foundSubsequence(nCommonPreceding, aCommonPreceding, bCommonPreceding);
+    }
+    if (nCommonFollowing !== 0) {
+        foundSubsequence(nCommonFollowing, aCommonFollowing, bCommonFollowing);
+    }
+    // Unless either index interval is empty, they might contain common items.
+    if (aStartFollowing < aEnd && bStartFollowing < bEnd) {
+        // Recursely find and return common subsequences following the division.
+        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`);
+    }
+};
+// Compare items in two sequences to find a longest common subsequence.
+// Given lengths of sequences and input function to compare items at indexes,
+// return by output function the number of adjacent items and starting indexes
+// of each common subsequence.
+export default (aLength, bLength, isCommon, foundSubsequence) => {
+    validateLength('aLength', aLength);
+    validateLength('bLength', bLength);
+    validateCallback('isCommon', isCommon);
+    validateCallback('foundSubsequence', foundSubsequence);
+    // Count common items from the start in the forward direction.
+    const nCommonF = countCommonItemsF(0, aLength, 0, bLength, isCommon);
+    if (nCommonF !== 0) {
+        foundSubsequence(nCommonF, 0, 0);
+    }
+    // Unless both sequences consist of common items only,
+    // find common items in the half-trimmed index intervals.
+    if (aLength !== nCommonF || bLength !== nCommonF) {
+        // Invariant: intervals do not have common items at the start.
+        // The start of an index interval is closed like array slice method.
+        const aStart = nCommonF;
+        const bStart = nCommonF;
+        // Count common items from the end in the reverse direction.
+        const nCommonR = countCommonItemsR(aStart, aLength - 1, bStart, bLength - 1, isCommon);
+        // Invariant: intervals do not have common items at the end.
+        // The end of an index interval is open like array slice method.
+        const aEnd = aLength - nCommonR;
+        const bEnd = bLength - nCommonR;
+        // Unless one sequence consists of common items only,
+        // therefore the other trimmed index interval consists of changes only,
+        // find common items in the trimmed index intervals.
+        const nCommonFR = nCommonF + nCommonR;
+        if (aLength !== nCommonFR && bLength !== nCommonFR) {
+            const nChange = 0; // number of change items is not yet known
+            const transposed = false; // call the original unwrapped functions
+            const callbacks = [{ foundSubsequence, isCommon }];
+            // Indexes in sequence a of last points in furthest reaching paths
+            // from outside the start at top left in the forward direction:
+            const aIndexesF = [NOT_YET_SET];
+            // from the end at bottom right in the reverse direction:
+            const aIndexesR = [NOT_YET_SET];
+            // Initialize one object as output of all calls to divide function.
+            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,
+            };
+            // Find and return common subsequences in the trimmed index intervals.
+            findSubsequences(nChange, aStart, aEnd, bStart, bEnd, transposed, callbacks, aIndexesF, aIndexesR, division);
+        }
+        if (nCommonR !== 0) {
+            foundSubsequence(nCommonR, aEnd, bEnd);
+        }
+    }
+};
+//# sourceMappingURL=index.js.map

package/src/diff-sequences/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}

package/src/extractExpectedAssertionsErrors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { Expect } from './types';
+declare const extractExpectedAssertionsErrors: Expect['extractExpectedAssertionsErrors'];
+export default extractExpectedAssertionsErrors;
+//# sourceMappingURL=extractExpectedAssertionsErrors.d.ts.map

package/src/extractExpectedAssertionsErrors.js

@@ -0,0 +1,58 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { EXPECTED_COLOR, RECEIVED_COLOR, matcherHint, pluralize, } from './matcher-utils';
+import { getState, setState } from './jestMatchersObject';
+const resetAssertionsLocalState = () => {
+    setState({
+        assertionCalls: 0,
+        expectedAssertionsNumber: null,
+        isExpectingAssertions: false,
+    });
+};
+// Create and format all errors related to the mismatched number of `expect`
+// calls and reset the matcher's state.
+const extractExpectedAssertionsErrors = () => {
+    const result = [];
+    const { assertionCalls, expectedAssertionsNumber, expectedAssertionsNumberError, isExpectingAssertions, isExpectingAssertionsError, } = getState();
+    resetAssertionsLocalState();
+    if (typeof expectedAssertionsNumber === 'number' &&
+        assertionCalls !== expectedAssertionsNumber) {
+        const numOfAssertionsExpected = EXPECTED_COLOR(pluralize('assertion', expectedAssertionsNumber));
+        expectedAssertionsNumberError.message =
+            matcherHint('.assertions', '', String(expectedAssertionsNumber), {
+                isDirectExpectCall: true,
+            }) +
+                '\n\n' +
+                `Expected ${numOfAssertionsExpected} to be called but received ` +
+                RECEIVED_COLOR(pluralize('assertion call', assertionCalls || 0)) +
+                '.';
+        result.push({
+            actual: assertionCalls.toString(),
+            error: expectedAssertionsNumberError,
+            expected: expectedAssertionsNumber.toString(),
+        });
+    }
+    if (isExpectingAssertions && assertionCalls === 0) {
+        const expected = EXPECTED_COLOR('at least one assertion');
+        const received = RECEIVED_COLOR('received none');
+        isExpectingAssertionsError.message =
+            matcherHint('.hasAssertions', '', '', {
+                isDirectExpectCall: true,
+            }) +
+                '\n\n' +
+                `Expected ${expected} to be called but ${received}.`;
+        result.push({
+            actual: 'none',
+            error: isExpectingAssertionsError,
+            expected: 'at least one',
+        });
+    }
+    return result;
+};
+export default extractExpectedAssertionsErrors;
+//# sourceMappingURL=extractExpectedAssertionsErrors.js.map

package/src/extractExpectedAssertionsErrors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extractExpectedAssertionsErrors.js","sourceRoot":"","sources":["extractExpectedAssertionsErrors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACH,cAAc,EACd,cAAc,EACd,WAAW,EACX,SAAS,GACZ,MAAM,iBAAiB,CAAC;AACzB,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAG1D,MAAM,yBAAyB,GAAG,GAAG,EAAE;IACnC,QAAQ,CAAC;QACL,cAAc,EAAE,CAAC;QACjB,wBAAwB,EAAE,IAAI;QAC9B,qBAAqB,EAAE,KAAK;KAC/B,CAAC,CAAC;AACP,CAAC,CAAC;AAEF,4EAA4E;AAC5E,uCAAuC;AACvC,MAAM,+BAA+B,GACjC,GAAG,EAAE;IACD,MAAM,MAAM,GAA6B,EAAE,CAAC;IAC5C,MAAM,EACF,cAAc,EACd,wBAAwB,EACxB,6BAA6B,EAC7B,qBAAqB,EACrB,0BAA0B,GAC7B,GAAG,QAAQ,EAAE,CAAC;IAEf,yBAAyB,EAAE,CAAC;IAE5B,IACI,OAAO,wBAAwB,KAAK,QAAQ;QAC5C,cAAc,KAAK,wBAAwB,EAC7C;QACE,MAAM,uBAAuB,GAAG,cAAc,CAC1C,SAAS,CAAC,WAAW,EAAE,wBAAwB,CAAC,CACnD,CAAC;QAEF,6BAA8B,CAAC,OAAO;YAClC,WAAW,CACP,aAAa,EACb,EAAE,EACF,MAAM,CAAC,wBAAwB,CAAC,EAChC;gBACI,kBAAkB,EAAE,IAAI;aAC3B,CACJ;gBACD,MAAM;gBACN,YAAY,uBAAuB,6BAA6B;gBAChE,cAAc,CACV,SAAS,CAAC,gBAAgB,EAAE,cAAc,IAAI,CAAC,CAAC,CACnD;gBACD,GAAG,CAAC;QAER,MAAM,CAAC,IAAI,CAAC;YACR,MAAM,EAAE,cAAc,CAAC,QAAQ,EAAE;YACjC,KAAK,EAAE,6BAA8B;YACrC,QAAQ,EAAE,wBAAwB,CAAC,QAAQ,EAAE;SAChD,CAAC,CAAC;KACN;IACD,IAAI,qBAAqB,IAAI,cAAc,KAAK,CAAC,EAAE;QAC/C,MAAM,QAAQ,GAAG,cAAc,CAAC,wBAAwB,CAAC,CAAC;QAC1D,MAAM,QAAQ,GAAG,cAAc,CAAC,eAAe,CAAC,CAAC;QAEjD,0BAA2B,CAAC,OAAO;YAC/B,WAAW,CAAC,gBAAgB,EAAE,EAAE,EAAE,EAAE,EAAE;gBAClC,kBAAkB,EAAE,IAAI;aAC3B,CAAC;gBACF,MAAM;gBACN,YAAY,QAAQ,qBAAqB,QAAQ,GAAG,CAAC;QAEzD,MAAM,CAAC,IAAI,CAAC;YACR,MAAM,EAAE,MAAM;YACd,KAAK,EAAE,0BAA2B;YAClC,QAAQ,EAAE,cAAc;SAC3B,CAAC,CAAC;KACN;IAED,OAAO,MAAM,CAAC;AAClB,CAAC,CAAC;AAEN,eAAe,+BAA+B,CAAC"}

package/src/get-type/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+declare type ValueType = 'array' | 'bigint' | 'boolean' | 'function' | 'null' | 'number' | 'object' | 'regexp' | 'map' | 'set' | 'date' | 'string' | 'symbol' | 'undefined';
+export declare function getType(value: unknown): ValueType;
+export declare const isPrimitive: (value: unknown) => boolean;
+export {};
+//# sourceMappingURL=index.d.ts.map