@jest/expect-utils 29.1.2 → 29.2.1

package/build/immutableUtils.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', {
+  value: true
+});
+exports.isImmutableList = isImmutableList;
+exports.isImmutableOrderedKeyed = isImmutableOrderedKeyed;
+exports.isImmutableOrderedSet = isImmutableOrderedSet;
+exports.isImmutableRecord = isImmutableRecord;
+exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
+exports.isImmutableUnorderedSet = isImmutableUnorderedSet;
+/**
+ * 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.
+ *
+ */
+
+// SENTINEL constants are from https://github.com/immutable-js/immutable-js/tree/main/src/predicates
+const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
+const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
+const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
+const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
+const IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';
+function isObjectLiteral(source) {
+  return source != null && typeof source === 'object' && !Array.isArray(source);
+}
+function isImmutableUnorderedKeyed(source) {
+  return Boolean(
+    source &&
+      isObjectLiteral(source) &&
+      source[IS_KEYED_SENTINEL] &&
+      !source[IS_ORDERED_SENTINEL]
+  );
+}
+function isImmutableUnorderedSet(source) {
+  return Boolean(
+    source &&
+      isObjectLiteral(source) &&
+      source[IS_SET_SENTINEL] &&
+      !source[IS_ORDERED_SENTINEL]
+  );
+}
+function isImmutableList(source) {
+  return Boolean(source && isObjectLiteral(source) && source[IS_LIST_SENTINEL]);
+}
+function isImmutableOrderedKeyed(source) {
+  return Boolean(
+    source &&
+      isObjectLiteral(source) &&
+      source[IS_KEYED_SENTINEL] &&
+      source[IS_ORDERED_SENTINEL]
+  );
+}
+function isImmutableOrderedSet(source) {
+  return Boolean(
+    source &&
+      isObjectLiteral(source) &&
+      source[IS_SET_SENTINEL] &&
+      source[IS_ORDERED_SENTINEL]
+  );
+}
+function isImmutableRecord(source) {
+  return Boolean(source && isObjectLiteral(source) && source[IS_RECORD_SYMBOL]);
+}

package/build/index.d.ts

@@ -46,7 +46,7 @@ export declare const getPath: (
   propertyPath: string | Array<string>,
 ) => GetPath;
 
-export declare function isA(typeName: string, value: unknown): boolean;
+export declare function isA<T>(typeName: string, value: unknown): value is T;
 
 export declare const isError: (value: unknown) => value is Error;
 

package/build/index.js

@@ -19,11 +19,8 @@ Object.defineProperty(exports, 'isA', {
     return _jasmineUtils.isA;
   }
 });
-
 var _jasmineUtils = require('./jasmineUtils');
-
 var _utils = require('./utils');
-
 Object.keys(_utils).forEach(function (key) {
   if (key === 'default' || key === '__esModule') return;
   if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;

package/build/jasmineUtils.js

@@ -5,13 +5,6 @@ Object.defineProperty(exports, '__esModule', {
 });
 exports.equals = void 0;
 exports.isA = isA;
-exports.isImmutableList = isImmutableList;
-exports.isImmutableOrderedKeyed = isImmutableOrderedKeyed;
-exports.isImmutableOrderedSet = isImmutableOrderedSet;
-exports.isImmutableRecord = isImmutableRecord;
-exports.isImmutableUnorderedKeyed = isImmutableUnorderedKeyed;
-exports.isImmutableUnorderedSet = isImmutableUnorderedSet;
-
 /*
 Copyright (c) 2008-2016 Pivotal Labs
 
@@ -36,71 +29,57 @@ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 */
 
-/* eslint-disable */
 // Extracted out of jasmine 2.5.2
 const equals = (a, b, customTesters, strictCheck) => {
   customTesters = customTesters || [];
   return eq(a, b, [], [], customTesters, strictCheck);
 };
-
 exports.equals = equals;
-
 function isAsymmetric(obj) {
   return !!obj && isA('Function', obj.asymmetricMatch);
 }
-
 function asymmetricMatch(a, b) {
-  var asymmetricA = isAsymmetric(a),
-    asymmetricB = isAsymmetric(b);
-
+  const asymmetricA = isAsymmetric(a);
+  const asymmetricB = isAsymmetric(b);
   if (asymmetricA && asymmetricB) {
     return undefined;
   }
-
   if (asymmetricA) {
     return a.asymmetricMatch(b);
   }
-
   if (asymmetricB) {
     return b.asymmetricMatch(a);
   }
-} // Equality function lovingly adapted from isEqual in
-//   [Underscore](http://underscorejs.org)
+}
 
+// Equality function lovingly adapted from isEqual in
+//   [Underscore](http://underscorejs.org)
 function eq(a, b, aStack, bStack, customTesters, strictCheck) {
-  var result = true;
-  var asymmetricResult = asymmetricMatch(a, b);
-
+  let result = true;
+  const asymmetricResult = asymmetricMatch(a, b);
   if (asymmetricResult !== undefined) {
     return asymmetricResult;
   }
-
-  for (var i = 0; i < customTesters.length; i++) {
-    var customTesterResult = customTesters[i](a, b);
-
+  for (let i = 0; i < customTesters.length; i++) {
+    const customTesterResult = customTesters[i](a, b);
     if (customTesterResult !== undefined) {
       return customTesterResult;
     }
   }
-
   if (a instanceof Error && b instanceof Error) {
     return a.message == b.message;
   }
-
   if (Object.is(a, b)) {
     return true;
-  } // A strict comparison is necessary because `null == undefined`.
-
+  }
+  // A strict comparison is necessary because `null == undefined`.
   if (a === null || b === null) {
     return a === b;
   }
-
-  var className = Object.prototype.toString.call(a);
-
+  const className = Object.prototype.toString.call(a);
   if (className != Object.prototype.toString.call(b)) {
     return false;
   }
-
   switch (className) {
     case '[object Boolean]':
     case '[object String]':
@@ -115,28 +94,26 @@ function eq(a, b, aStack, bStack, customTesters, strictCheck) {
         // both are `new Primitive()`s
         return Object.is(a.valueOf(), b.valueOf());
       }
-
     case '[object Date]':
       // Coerce dates to numeric primitive values. Dates are compared by their
       // millisecond representations. Note that invalid dates with millisecond representations
       // of `NaN` are not equivalent.
       return +a == +b;
     // RegExps are compared by their source patterns and flags.
-
     case '[object RegExp]':
       return a.source === b.source && a.flags === b.flags;
   }
-
   if (typeof a !== 'object' || typeof b !== 'object') {
     return false;
-  } // Use DOM3 method isEqualNode (IE>=9)
+  }
 
+  // Use DOM3 method isEqualNode (IE>=9)
   if (isDomNode(a) && isDomNode(b)) {
     return a.isEqualNode(b);
-  } // Used to detect circular references.
-
-  var length = aStack.length;
+  }
 
+  // Used to detect circular references.
+  let length = aStack.length;
   while (length--) {
     // Linear search. Performance is inversely proportional to the number of
     // unique nested structures.
@@ -147,47 +124,45 @@ function eq(a, b, aStack, bStack, customTesters, strictCheck) {
     } else if (bStack[length] === b) {
       return false;
     }
-  } // Add the first object to the stack of traversed objects.
-
+  }
+  // Add the first object to the stack of traversed objects.
   aStack.push(a);
-  bStack.push(b); // Recursively compare objects and arrays.
+  bStack.push(b);
+  // Recursively compare objects and arrays.
   // Compare array lengths to determine if a deep comparison is necessary.
-
   if (strictCheck && className == '[object Array]' && a.length !== b.length) {
     return false;
-  } // Deep compare objects.
-
-  var aKeys = keys(a, hasKey),
-    key;
-  var bKeys = keys(b, hasKey); // Add keys corresponding to asymmetric matchers if they miss in non strict check mode
+  }
 
+  // Deep compare objects.
+  const aKeys = keys(a, hasKey);
+  let key;
+  const bKeys = keys(b, hasKey);
+  // Add keys corresponding to asymmetric matchers if they miss in non strict check mode
   if (!strictCheck) {
-    for (var index = 0; index !== bKeys.length; ++index) {
+    for (let index = 0; index !== bKeys.length; ++index) {
       key = bKeys[index];
-
       if ((isAsymmetric(b[key]) || b[key] === undefined) && !hasKey(a, key)) {
         aKeys.push(key);
       }
     }
-
-    for (var index = 0; index !== aKeys.length; ++index) {
+    for (let index = 0; index !== aKeys.length; ++index) {
       key = aKeys[index];
-
       if ((isAsymmetric(a[key]) || a[key] === undefined) && !hasKey(b, key)) {
         bKeys.push(key);
       }
     }
-  } // Ensure that both objects contain the same number of properties before comparing deep equality.
-
-  var size = aKeys.length;
+  }
 
+  // Ensure that both objects contain the same number of properties before comparing deep equality.
+  let size = aKeys.length;
   if (bKeys.length !== size) {
     return false;
   }
-
   while (size--) {
-    key = aKeys[size]; // Deep compare each member
+    key = aKeys[size];
 
+    // Deep compare each member
     if (strictCheck)
       result =
         hasKey(b, key) &&
@@ -196,41 +171,34 @@ function eq(a, b, aStack, bStack, customTesters, strictCheck) {
       result =
         (hasKey(b, key) || isAsymmetric(a[key]) || a[key] === undefined) &&
         eq(a[key], b[key], aStack, bStack, customTesters, strictCheck);
-
     if (!result) {
       return false;
     }
-  } // Remove the first object from the stack of traversed objects.
-
+  }
+  // Remove the first object from the stack of traversed objects.
   aStack.pop();
   bStack.pop();
   return result;
 }
-
 function keys(obj, hasKey) {
-  var keys = [];
-
-  for (var key in obj) {
+  const keys = [];
+  for (const key in obj) {
     if (hasKey(obj, key)) {
       keys.push(key);
     }
   }
-
   return keys.concat(
     Object.getOwnPropertySymbols(obj).filter(
       symbol => Object.getOwnPropertyDescriptor(obj, symbol).enumerable
     )
   );
 }
-
 function hasKey(obj, key) {
   return Object.prototype.hasOwnProperty.call(obj, key);
 }
-
 function isA(typeName, value) {
-  return Object.prototype.toString.apply(value) === '[object ' + typeName + ']';
+  return Object.prototype.toString.apply(value) === `[object ${typeName}]`;
 }
-
 function isDomNode(obj) {
   return (
     obj !== null &&
@@ -239,50 +207,4 @@ function isDomNode(obj) {
     typeof obj.nodeName === 'string' &&
     typeof obj.isEqualNode === 'function'
   );
-} // SENTINEL constants are from https://github.com/immutable-js/immutable-js/tree/main/src/predicates
-
-const IS_KEYED_SENTINEL = '@@__IMMUTABLE_KEYED__@@';
-const IS_SET_SENTINEL = '@@__IMMUTABLE_SET__@@';
-const IS_LIST_SENTINEL = '@@__IMMUTABLE_LIST__@@';
-const IS_ORDERED_SENTINEL = '@@__IMMUTABLE_ORDERED__@@';
-const IS_RECORD_SYMBOL = '@@__IMMUTABLE_RECORD__@@';
-
-function isImmutableUnorderedKeyed(maybeKeyed) {
-  return !!(
-    maybeKeyed &&
-    maybeKeyed[IS_KEYED_SENTINEL] &&
-    !maybeKeyed[IS_ORDERED_SENTINEL]
-  );
-}
-
-function isImmutableUnorderedSet(maybeSet) {
-  return !!(
-    maybeSet &&
-    maybeSet[IS_SET_SENTINEL] &&
-    !maybeSet[IS_ORDERED_SENTINEL]
-  );
-}
-
-function isImmutableList(maybeList) {
-  return !!(maybeList && maybeList[IS_LIST_SENTINEL]);
-}
-
-function isImmutableOrderedKeyed(maybeKeyed) {
-  return !!(
-    maybeKeyed &&
-    maybeKeyed[IS_KEYED_SENTINEL] &&
-    maybeKeyed[IS_ORDERED_SENTINEL]
-  );
-}
-
-function isImmutableOrderedSet(maybeSet) {
-  return !!(
-    maybeSet &&
-    maybeSet[IS_SET_SENTINEL] &&
-    maybeSet[IS_ORDERED_SENTINEL]
-  );
-}
-
-function isImmutableRecord(maybeSet) {
-  return !!(maybeSet && maybeSet[IS_RECORD_SYMBOL]);
 }

package/build/utils.js

@@ -16,40 +16,32 @@ exports.typeEquality =
   exports.getPath =
   exports.getObjectSubset =
     void 0;
-
 var _jestGetType = require('jest-get-type');
-
+var _immutableUtils = require('./immutableUtils');
 var _jasmineUtils = require('./jasmineUtils');
-
 var Symbol = globalThis['jest-symbol-do-not-touch'] || globalThis.Symbol;
-
 /**
  * Checks if `hasOwnProperty(object, key)` up the prototype chain, stopping at `Object.prototype`.
  */
 const hasPropertyInObject = (object, key) => {
   const shouldTerminate =
     !object || typeof object !== 'object' || object === Object.prototype;
-
   if (shouldTerminate) {
     return false;
   }
-
   return (
     Object.prototype.hasOwnProperty.call(object, key) ||
     hasPropertyInObject(Object.getPrototypeOf(object), key)
   );
 };
-
 const getPath = (object, propertyPath) => {
   if (!Array.isArray(propertyPath)) {
     propertyPath = pathAsArray(propertyPath);
   }
-
   if (propertyPath.length) {
     const lastProp = propertyPath.length === 1;
     const prop = propertyPath[0];
     const newObject = object[prop];
-
     if (!lastProp && (newObject === null || newObject === undefined)) {
       // This is not the last prop in the chain. If we keep recursing it will
       // hit a `can't access property X of undefined | null`. At this point we
@@ -60,15 +52,11 @@ const getPath = (object, propertyPath) => {
         traversedPath: []
       };
     }
-
     const result = getPath(newObject, propertyPath.slice(1));
-
     if (result.lastTraversedObject === null) {
       result.lastTraversedObject = object;
     }
-
     result.traversedPath.unshift(prop);
-
     if (lastProp) {
       // Does object have the property with an undefined value?
       // Although primitive values support bracket notation (above)
@@ -76,27 +64,23 @@ const getPath = (object, propertyPath) => {
       result.endPropIsDefined =
         !(0, _jestGetType.isPrimitive)(object) && prop in object;
       result.hasEndProp = newObject !== undefined || result.endPropIsDefined;
-
       if (!result.hasEndProp) {
         result.traversedPath.shift();
       }
     }
-
     return result;
   }
-
   return {
     lastTraversedObject: null,
     traversedPath: [],
     value: object
   };
-}; // Strip properties from object that are not present in the subset. Useful for
-// printing the diff for toMatchObject() without adding unrelated noise.
+};
 
+// Strip properties from object that are not present in the subset. Useful for
+// printing the diff for toMatchObject() without adding unrelated noise.
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-
 exports.getPath = getPath;
-
 const getObjectSubset = (object, subset, seenReferences = new WeakMap()) => {
   /* eslint-enable @typescript-eslint/explicit-module-boundary-types */
   if (Array.isArray(object)) {
@@ -116,7 +100,6 @@ const getObjectSubset = (object, subset, seenReferences = new WeakMap()) => {
       // Avoid unnecessary copy which might return Object instead of subclass.
       return subset;
     }
-
     const trimmed = {};
     seenReferences.set(object, trimmed);
     Object.keys(object)
@@ -126,25 +109,20 @@ const getObjectSubset = (object, subset, seenReferences = new WeakMap()) => {
           ? seenReferences.get(object[key])
           : getObjectSubset(object[key], subset[key], seenReferences);
       });
-
     if (Object.keys(trimmed).length > 0) {
       return trimmed;
     }
   }
-
   return object;
 };
-
 exports.getObjectSubset = getObjectSubset;
 const IteratorSymbol = Symbol.iterator;
-
 const hasIterator = object => !!(object != null && object[IteratorSymbol]);
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 const iterableEquality = (
   a,
-  b,
-  /* eslint-enable @typescript-eslint/explicit-module-boundary-types */
+  b /* eslint-enable @typescript-eslint/explicit-module-boundary-types */,
   aStack = [],
   bStack = []
 ) => {
@@ -158,13 +136,10 @@ const iterableEquality = (
   ) {
     return undefined;
   }
-
   if (a.constructor !== b.constructor) {
     return false;
   }
-
   let length = aStack.length;
-
   while (length--) {
     // Linear search. Performance is inversely proportional to the number of
     // unique nested structures.
@@ -174,52 +149,44 @@ const iterableEquality = (
       return bStack[length] === b;
     }
   }
-
   aStack.push(a);
   bStack.push(b);
-
   const iterableEqualityWithStack = (a, b) =>
     iterableEquality(a, b, [...aStack], [...bStack]);
-
   if (a.size !== undefined) {
     if (a.size !== b.size) {
       return false;
     } else if (
       (0, _jasmineUtils.isA)('Set', a) ||
-      (0, _jasmineUtils.isImmutableUnorderedSet)(a)
+      (0, _immutableUtils.isImmutableUnorderedSet)(a)
     ) {
       let allFound = true;
-
       for (const aValue of a) {
         if (!b.has(aValue)) {
           let has = false;
-
           for (const bValue of b) {
             const isEqual = (0, _jasmineUtils.equals)(aValue, bValue, [
               iterableEqualityWithStack
             ]);
-
             if (isEqual === true) {
               has = true;
             }
           }
-
           if (has === false) {
             allFound = false;
             break;
           }
         }
-      } // Remove the first value from the stack of traversed values.
-
+      }
+      // Remove the first value from the stack of traversed values.
       aStack.pop();
       bStack.pop();
       return allFound;
     } else if (
       (0, _jasmineUtils.isA)('Map', a) ||
-      (0, _jasmineUtils.isImmutableUnorderedKeyed)(a)
+      (0, _immutableUtils.isImmutableUnorderedKeyed)(a)
     ) {
       let allFound = true;
-
       for (const aEntry of a) {
         if (
           !b.has(aEntry[0]) ||
@@ -228,42 +195,35 @@ const iterableEquality = (
           ])
         ) {
           let has = false;
-
           for (const bEntry of b) {
             const matchedKey = (0, _jasmineUtils.equals)(aEntry[0], bEntry[0], [
               iterableEqualityWithStack
             ]);
             let matchedValue = false;
-
             if (matchedKey === true) {
               matchedValue = (0, _jasmineUtils.equals)(aEntry[1], bEntry[1], [
                 iterableEqualityWithStack
               ]);
             }
-
             if (matchedValue === true) {
               has = true;
             }
           }
-
           if (has === false) {
             allFound = false;
             break;
           }
         }
-      } // Remove the first value from the stack of traversed values.
-
+      }
+      // Remove the first value from the stack of traversed values.
       aStack.pop();
       bStack.pop();
       return allFound;
     }
   }
-
   const bIterator = b[IteratorSymbol]();
-
   for (const aValue of a) {
     const nextB = bIterator.next();
-
     if (
       nextB.done ||
       !(0, _jasmineUtils.equals)(aValue, nextB.value, [
@@ -273,40 +233,34 @@ const iterableEquality = (
       return false;
     }
   }
-
   if (!bIterator.next().done) {
     return false;
   }
-
   if (
-    !(0, _jasmineUtils.isImmutableList)(a) &&
-    !(0, _jasmineUtils.isImmutableOrderedKeyed)(a) &&
-    !(0, _jasmineUtils.isImmutableOrderedSet)(a) &&
-    !(0, _jasmineUtils.isImmutableRecord)(a)
+    !(0, _immutableUtils.isImmutableList)(a) &&
+    !(0, _immutableUtils.isImmutableOrderedKeyed)(a) &&
+    !(0, _immutableUtils.isImmutableOrderedSet)(a) &&
+    !(0, _immutableUtils.isImmutableRecord)(a)
   ) {
     const aEntries = Object.entries(a);
     const bEntries = Object.entries(b);
-
     if (!(0, _jasmineUtils.equals)(aEntries, bEntries)) {
       return false;
     }
-  } // Remove the first value from the stack of traversed values.
+  }
 
+  // Remove the first value from the stack of traversed values.
   aStack.pop();
   bStack.pop();
   return true;
 };
-
 exports.iterableEquality = iterableEquality;
-
 const isObject = a => a !== null && typeof a === 'object';
-
 const isObjectWithKeys = a =>
   isObject(a) &&
   !(a instanceof Error) &&
   !(a instanceof Array) &&
   !(a instanceof Date);
-
 const subsetEquality = (object, subset) => {
   // subsetEquality needs to keep track of the references
   // it has already visited to avoid infinite loops in case
@@ -317,7 +271,6 @@ const subsetEquality = (object, subset) => {
       if (!isObjectWithKeys(subset)) {
         return undefined;
       }
-
       return Object.keys(subset).every(key => {
         if (isObjectWithKeys(subset[key])) {
           if (seenReferences.has(subset[key])) {
@@ -325,70 +278,63 @@ const subsetEquality = (object, subset) => {
               iterableEquality
             ]);
           }
-
           seenReferences.set(subset[key], true);
         }
-
         const result =
           object != null &&
           hasPropertyInObject(object, key) &&
           (0, _jasmineUtils.equals)(object[key], subset[key], [
             iterableEquality,
             subsetEqualityWithContext(seenReferences)
-          ]); // The main goal of using seenReference is to avoid circular node on tree.
+          ]);
+        // The main goal of using seenReference is to avoid circular node on tree.
         // It will only happen within a parent and its child, not a node and nodes next to it (same level)
         // We should keep the reference for a parent and its child only
         // Thus we should delete the reference immediately so that it doesn't interfere
         // other nodes within the same level on tree.
-
         seenReferences.delete(subset[key]);
         return result;
       });
     };
-
   return subsetEqualityWithContext()(object, subset);
-}; // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+};
 
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
 exports.subsetEquality = subsetEquality;
-
 const typeEquality = (a, b) => {
   if (a == null || b == null || a.constructor === b.constructor) {
     return undefined;
   }
-
   return false;
 };
-
 exports.typeEquality = typeEquality;
-
 const arrayBufferEquality = (a, b) => {
   if (!(a instanceof ArrayBuffer) || !(b instanceof ArrayBuffer)) {
     return undefined;
   }
-
   const dataViewA = new DataView(a);
-  const dataViewB = new DataView(b); // Buffers are not equal when they do not have the same byte length
+  const dataViewB = new DataView(b);
 
+  // Buffers are not equal when they do not have the same byte length
   if (dataViewA.byteLength !== dataViewB.byteLength) {
     return false;
-  } // Check if every byte value is equal to each other
+  }
 
+  // Check if every byte value is equal to each other
   for (let i = 0; i < dataViewA.byteLength; i++) {
     if (dataViewA.getUint8(i) !== dataViewB.getUint8(i)) {
       return false;
     }
   }
-
   return true;
 };
-
 exports.arrayBufferEquality = arrayBufferEquality;
-
 const sparseArrayEquality = (a, b) => {
   if (!Array.isArray(a) || !Array.isArray(b)) {
     return undefined;
-  } // A sparse array [, , 1] will have keys ["2"] whereas [undefined, undefined, 1] will have keys ["0", "1", "2"]
+  }
 
+  // A sparse array [, , 1] will have keys ["2"] whereas [undefined, undefined, 1] will have keys ["0", "1", "2"]
   const aKeys = Object.keys(a);
   const bKeys = Object.keys(b);
   return (
@@ -396,63 +342,53 @@ const sparseArrayEquality = (a, b) => {
     (0, _jasmineUtils.equals)(aKeys, bKeys)
   );
 };
-
 exports.sparseArrayEquality = sparseArrayEquality;
-
 const partition = (items, predicate) => {
   const result = [[], []];
   items.forEach(item => result[predicate(item) ? 0 : 1].push(item));
   return result;
 };
-
 exports.partition = partition;
-
 const pathAsArray = propertyPath => {
   const properties = [];
-
   if (propertyPath === '') {
     properties.push('');
     return properties;
-  } // will match everything that's not a dot or a bracket, and "" for consecutive dots.
+  }
 
-  const pattern = RegExp('[^.[\\]]+|(?=(?:\\.)(?:\\.|$))', 'g'); // Because the regex won't match a dot in the beginning of the path, if present.
+  // will match everything that's not a dot or a bracket, and "" for consecutive dots.
+  const pattern = RegExp('[^.[\\]]+|(?=(?:\\.)(?:\\.|$))', 'g');
 
+  // Because the regex won't match a dot in the beginning of the path, if present.
   if (propertyPath[0] === '.') {
     properties.push('');
   }
-
   propertyPath.replace(pattern, match => {
     properties.push(match);
     return match;
   });
   return properties;
-}; // Copied from https://github.com/graingert/angular.js/blob/a43574052e9775cbc1d7dd8a086752c979b0f020/src/Angular.js#L685-L693
+};
 
+// Copied from https://github.com/graingert/angular.js/blob/a43574052e9775cbc1d7dd8a086752c979b0f020/src/Angular.js#L685-L693
 exports.pathAsArray = pathAsArray;
-
 const isError = value => {
   switch (Object.prototype.toString.call(value)) {
     case '[object Error]':
     case '[object Exception]':
     case '[object DOMException]':
       return true;
-
     default:
       return value instanceof Error;
   }
 };
-
 exports.isError = isError;
-
 function emptyObject(obj) {
   return obj && typeof obj === 'object' ? !Object.keys(obj).length : false;
 }
-
 const MULTILINE_REGEXP = /[\r\n]/;
-
 const isOneline = (expected, received) =>
   typeof expected === 'string' &&
   typeof received === 'string' &&
   (!MULTILINE_REGEXP.test(expected) || !MULTILINE_REGEXP.test(received));
-
 exports.isOneline = isOneline;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jest/expect-utils",
-  "version": "29.1.2",
+  "version": "29.2.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/jest.git",
@@ -17,11 +17,13 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "jest-get-type": "^29.0.0"
+    "jest-get-type": "^29.2.0"
   },
   "devDependencies": {
+    "@tsd/typescript": "~4.8.2",
     "immutable": "^4.0.0",
-    "jest-matcher-utils": "^29.1.2"
+    "jest-matcher-utils": "^29.2.1",
+    "tsd-lite": "^0.6.0"
   },
   "engines": {
     "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
@@ -29,5 +31,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "3c31dd619e8c022cde53f40fa12ea2a67f4752ce"
+  "gitHead": "4551c0fdd4d25b7206824957c7bcc6baf61e63bf"
 }