fast-equals 4.0.3 → 5.0.0-beta.1

package/src/objects.ts

@@ -1,62 +0,0 @@
-import { createIsCircular } from './utils';
-
-import type { InternalEqualityComparator } from '../index.d';
-
-interface Dictionary<Value> {
-  [key: string]: Value;
-  $$typeof?: any;
-}
-
-const OWNER = '_owner';
-const { hasOwnProperty } = Object.prototype;
-
-/**
- * Whether the objects are equal in value.
- */
-export function areObjectsEqual(
-  a: Dictionary<any>,
-  b: Dictionary<any>,
-  isEqual: InternalEqualityComparator<any>,
-  meta: any,
-): boolean {
-  const keysA = Object.keys(a);
-
-  let index = keysA.length;
-
-  if (Object.keys(b).length !== index) {
-    return false;
-  }
-
-  let key: string;
-
-  // Decrementing `while` showed faster results than either incrementing or
-  // decrementing `for` loop and than an incrementing `while` loop. Declarative
-  // methods like `some` / `every` were not used to avoid incurring the garbage
-  // cost of anonymous callbacks.
-  while (index-- > 0) {
-    key = keysA[index];
-
-    if (key === OWNER) {
-      const reactElementA = !!a.$$typeof;
-      const reactElementB = !!b.$$typeof;
-
-      if ((reactElementA || reactElementB) && reactElementA !== reactElementB) {
-        return false;
-      }
-    }
-
-    if (
-      !hasOwnProperty.call(b, key) ||
-      !isEqual(a[key], b[key], key, key, a, b, meta)
-    ) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Whether the objects are equal in value, including circular references.
- */
-export const areObjectsEqualCircular = createIsCircular(areObjectsEqual);

package/src/regexps.ts

@@ -1,11 +0,0 @@
-/**
- * Whether the regexps passed are equal in value.
- *
- * @NOTE
- * This is a standalone function instead of done inline in the comparator
- * to allow for overrides. An example of this would be supporting a
- * pre-ES2015 environment where the `flags` property is not available.
- */
-export function areRegExpsEqual(a: RegExp, b: RegExp): boolean {
-  return a.source === b.source && a.flags === b.flags;
-}

package/src/sets.ts

@@ -1,61 +0,0 @@
-import { createIsCircular } from './utils';
-
-import type { InternalEqualityComparator } from '../index.d';
-
-/**
- * Whether the `Set`s are equal in value.
- */
-export function areSetsEqual(
-  a: Set<any>,
-  b: Set<any>,
-  isEqual: InternalEqualityComparator<any>,
-  meta: any,
-): boolean {
-  let isValueEqual = a.size === b.size;
-
-  if (!isValueEqual) {
-    return false;
-  }
-
-  if (!a.size) {
-    return true;
-  }
-
-  // The use of `forEach()` is to avoid the transpilation cost of `for...of` comparisons, and
-  // the inability to control the performance of the resulting code. It also avoids excessive
-  // iteration compared to doing comparisons of `keys()` and `values()`. As a result, though,
-  // we cannot short-circuit the iterations; bookkeeping must be done to short-circuit the
-  // equality checks themselves.
-
-  const matchedIndices: Record<number, true> = {};
-
-  a.forEach((aValue, aKey) => {
-    if (!isValueEqual) {
-      return;
-    }
-
-    let hasMatch = false;
-    let matchIndex = 0;
-
-    b.forEach((bValue, bKey) => {
-      if (
-        !hasMatch &&
-        !matchedIndices[matchIndex] &&
-        (hasMatch = isEqual(aValue, bValue, aKey, bKey, a, b, meta))
-      ) {
-        matchedIndices[matchIndex] = true;
-      }
-
-      matchIndex++;
-    });
-
-    isValueEqual = hasMatch;
-  });
-
-  return isValueEqual;
-}
-
-/**
- * Whether the `Set`s are equal in value, including circular references.
- */
-export const areSetsEqualCircular = createIsCircular(areSetsEqual);