fast-equals 4.0.3 → 5.0.0-beta.0

package/dist/umd/types/index.d.ts

@@ -0,0 +1,56 @@
+import type { CreateCustomComparatorConfig, CreateState, EqualityComparator } from './internalTypes';
+import { createInternalComparator, sameValueZeroEqual } from './utils';
+export { sameValueZeroEqual };
+interface DefaultEqualCreatorOptions<Meta> {
+    comparator?: EqualityComparator<Meta>;
+    circular?: boolean;
+    strict?: boolean;
+}
+interface CustomEqualCreatorOptions<Meta> extends DefaultEqualCreatorOptions<Meta> {
+    createCustomConfig?: CreateCustomComparatorConfig<Meta>;
+    createInternalComparator?: typeof createInternalComparator;
+    createState?: CreateState<Meta>;
+}
+/**
+ * Whether the items passed are deeply-equal in value.
+ */
+export declare const deepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value based on strict comparison.
+ */
+export declare const strictDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references.
+ */
+export declare const circularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are deeply-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularDeepEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value.
+ */
+export declare const shallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value based on strict comparison
+ */
+export declare const strictShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references.
+ */
+export declare const circularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Whether the items passed are shallowly-equal in value, including circular references,
+ * based on strict comparison.
+ */
+export declare const strictCircularShallowEqual: <A, B>(a: A, b: B) => boolean;
+/**
+ * Create a custom equality comparison method.
+ *
+ * This can be done to create very targeted comparisons in extreme hot-path scenarios
+ * where the standard methods are not performant enough, but can also be used to provide
+ * support for legacy environments that do not support expected features like
+ * `RegExp.prototype.flags` out of the box.
+ */
+export declare function createCustomEqual<Meta>(options?: CustomEqualCreatorOptions<Meta>): <A, B>(a: A, b: B, metaOverride?: Meta) => boolean;

package/dist/umd/types/internalTypes.d.ts

@@ -0,0 +1,36 @@
+export interface BaseCircular extends Pick<WeakMap<any, any>, 'delete' | 'get'> {
+    set(key: object, value: any): any;
+}
+export type State<Meta> = CircularState<Meta> | DefaultState<Meta>;
+export interface CircularState<Meta> {
+    readonly cache: BaseCircular;
+    readonly equals: InternalEqualityComparator<Meta>;
+    meta: Meta;
+    readonly strict: boolean;
+}
+export interface DefaultState<Meta> {
+    readonly cache: undefined;
+    readonly equals: InternalEqualityComparator<Meta>;
+    meta: Meta;
+    readonly strict: boolean;
+}
+export interface Dictionary<Value = any> {
+    [key: string | symbol]: Value;
+    $$typeof?: any;
+}
+export interface ComparatorConfig<Meta> {
+    areArraysEqual: TypeEqualityComparator<any, Meta>;
+    areDatesEqual: TypeEqualityComparator<any, Meta>;
+    areMapsEqual: TypeEqualityComparator<any, Meta>;
+    areObjectsEqual: TypeEqualityComparator<any, Meta>;
+    arePrimitiveWrappersEqual: TypeEqualityComparator<any, Meta>;
+    areRegExpsEqual: TypeEqualityComparator<any, Meta>;
+    areSetsEqual: TypeEqualityComparator<any, Meta>;
+}
+export type CreateCustomComparatorConfig<Meta> = (config: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;
+export type CreateState<Meta> = (comparator: EqualityComparator<Meta>) => Partial<State<Meta>>;
+export type EqualityComparator<Meta> = <A, B>(a: A, b: B, state: State<Meta>) => boolean;
+export type AnyEqualityComparator<Meta> = (a: any, b: any, state: State<Meta>) => boolean;
+export type EqualityComparatorCreator<Meta> = (fn: EqualityComparator<Meta>) => InternalEqualityComparator<Meta>;
+export type InternalEqualityComparator<Meta> = (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;
+export type TypeEqualityComparator<Type, Meta = undefined> = (a: Type, b: Type, state: State<Meta>) => boolean;

package/dist/umd/types/utils.d.ts

@@ -0,0 +1,19 @@
+import { AnyEqualityComparator, Dictionary, EqualityComparator, InternalEqualityComparator, State, TypeEqualityComparator } from './internalTypes';
+export declare function combineComparators<Meta>(comparatorA: AnyEqualityComparator<Meta>, comparatorB: AnyEqualityComparator<Meta>): <A, B>(a: A, b: B, state: State<Meta>) => boolean;
+/**
+ * Default equality comparator pass-through, used as the standard `isEqual` creator for
+ * use inside the built comparator.
+ */
+export declare function createInternalComparator<Meta>(compare: EqualityComparator<Meta>): InternalEqualityComparator<Meta>;
+/**
+ * Wrap the provided `areItemsEqual` method to manage the circular state, allowing
+ * for circular references to be safely included in the comparison without creating
+ * stack overflows.
+ */
+export declare function createIsCircular<AreItemsEqual extends TypeEqualityComparator<any, any>>(areItemsEqual: AreItemsEqual): AreItemsEqual;
+export declare function getStrictProperties(object: Dictionary): Array<string | symbol>;
+export declare const hasOwn: (o: object, v: PropertyKey) => boolean;
+/**
+ * Whether the values passed are strictly equal or both NaN.
+ */
+export declare function sameValueZeroEqual(a: any, b: any): boolean;

package/package.json

@@ -1,53 +1,69 @@
 {
   "author": "tony_quetano@planttheidea.com",
-  "browser": "dist/fast-equals.js",
+  "browser": "dist/umd/index.js",
   "bugs": {
     "url": "https://github.com/planttheidea/fast-equals/issues"
   },
   "description": "A blazing fast equality comparison, either shallow or deep",
   "devDependencies": {
-    "@rollup/plugin-node-resolve": "^13.1.3",
-    "@types/jest": "^28.1.8",
+    "@rollup/plugin-commonjs": "^24.0.0",
+    "@rollup/plugin-node-resolve": "^15.0.1",
+    "@rollup/plugin-replace": "^5.0.2",
+    "@rollup/plugin-terser": "^0.4.0",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/jest": "^29.2.5",
     "@types/lodash": "^4.14.184",
-    "@types/node": "^18.7.13",
-    "@types/ramda": "^0.28.15",
-    "@types/react": "^18.0.17",
-    "@typescript-eslint/eslint-plugin": "^5.35.1",
-    "@typescript-eslint/parser": "^5.35.1",
-    "benchee": "^1.1.0",
-    "cli-table3": "^0.6.1",
+    "@types/node": "^18.14.0",
+    "@types/ramda": "^0.28.23",
+    "@types/react": "^18.0.28",
+    "@types/react-dom": "^18.0.11",
+    "@typescript-eslint/eslint-plugin": "^5.52.0",
+    "@typescript-eslint/parser": "^5.52.0",
     "decircularize": "^1.0.0",
     "deep-eql": "^4.1.0",
     "deep-equal": "^2.0.5",
-    "eslint": "^8.22.0",
-    "eslint-config-airbnb": "^19.0.4",
-    "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-jsx-a11y": "^6.6.1",
-    "eslint-plugin-react": "^7.31.0",
-    "eslint-webpack-plugin": "^3.2.0",
+    "eslint": "^8.34.0",
+    "eslint-friendly-formatter": "^4.0.1",
+    "eslint-webpack-plugin": "^4.0.0",
     "fast-deep-equal": "^3.1.3",
-    "fs-extra": "^10.0.0",
     "html-webpack-plugin": "^5.5.0",
     "in-publish": "^2.0.0",
-    "jest": "^28.1.3",
+    "jest": "^29.4.3",
+    "jest-environment-jsdom": "^29.4.3",
+    "jest-expect-message": "^1.1.3",
     "lodash": "^4.17.21",
     "nano-equal": "^2.0.2",
-    "prettier": "^2.7.1",
+    "prettier": "^2.8.4",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "react-fast-compare": "^3.2.0",
-    "release-it": "^15.4.0",
-    "rollup": "^2.78.1",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.33.0",
+    "release-it": "^15.6.0",
+    "rollup": "^3.16.0",
     "shallow-equal-fuzzy": "^0.0.2",
-    "ts-jest": "^28.0.8",
-    "ts-loader": "^9.3.1",
-    "typescript": "^4.7.4",
+    "tinybench": "^2.3.1",
+    "ts-jest": "^29.0.3",
+    "ts-loader": "^9.4.2",
+    "typescript": "^4.9.5",
     "underscore": "^1.13.4",
-    "webpack": "^5.74.0",
-    "webpack-cli": "^4.10.0",
-    "webpack-dev-server": "^4.10.0"
+    "webpack": "^5.75.0",
+    "webpack-cli": "^5.0.1",
+    "webpack-dev-server": "^4.11.1"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/types/index.d.ts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/types/index.d.ts",
+        "default": "./dist/cjs/index.cjs"
+      },
+      "default": {
+        "types": "./dist/umd/types/index.d.ts",
+        "default": "./dist/umd/index.js"
+      }
+    }
   },
   "homepage": "https://github.com/planttheidea/fast-equals#readme",
   "keywords": [
@@ -58,32 +74,37 @@
     "equivalent"
   ],
   "license": "MIT",
-  "main": "dist/fast-equals.cjs.js",
-  "module": "dist/fast-equals.esm.js",
+  "main": "dist/cjs/index.cjs",
+  "module": "dist/esm/index.mjs",
   "name": "fast-equals",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/planttheidea/fast-equals.git"
   },
   "scripts": {
-    "benchmark": "npm run dist && node benchmark/index.js",
-    "build": "NODE_ENV=production rollup -c",
-    "dev": "NODE_ENV=development webpack serve --progress --config=webpack/webpack.config.js",
+    "benchmark": "npm run build:esm && node benchmark/index.js",
+    "build": "npm run build:esm && npm run build:cjs && npm run build:umd && npm run build:min",
+    "build:cjs": "rimraf dist/cjs && NODE_ENV=production rollup -c build/rollup/config.cjs.js && tsc -p ./build/tsconfig/cjs.json",
+    "build:esm": "rimraf dist/esm && NODE_ENV=production rollup -c build/rollup/config.esm.js && tsc -p ./build/tsconfig/esm.json",
+    "build:min": "rimraf dist/min && NODE_ENV=production rollup -c build/rollup/config.min.js && tsc -p ./build/tsconfig/min.json",
+    "build:umd": "rimraf dist/umd && NODE_ENV=production rollup -c build/rollup/config.umd.js && tsc -p ./build/tsconfig/umd.json",
+    "dev": "NODE_ENV=development webpack serve --progress --config=build/webpack.config.js",
     "dist": "rimraf dist && npm run build",
     "format": "prettier **/*.ts --write",
     "lint": "eslint src/*.ts",
     "lint:fix": "npm run lint -- --fix",
     "start": "npm run dev",
     "prepublish": "if in-publish; then npm run prepublish:compile; fi",
-    "prepublish:compile": "npm run typecheck && npm run lint && npm run test && npm run dist",
     "release": "release-it",
     "release:beta": "release-it --config=.release-it.beta.json",
+    "release:scripts": "npm run typecheck && npm run lint && npm run test && npm run dist",
     "test": "NODE_PATH=. jest",
-    "test:coverage": "npm test -- --coverage",
+    "test:coverage": "rimraf coverage && npm test -- --coverage",
     "test:watch": "npm test -- --watch",
     "typecheck": "tsc --noEmit"
   },
   "sideEffects": false,
+  "type": "module",
   "types": "index.d.ts",
-  "version": "4.0.3"
+  "version": "5.0.0-beta.0"
 }

package/recipes/explicit-property-check.md

@@ -18,11 +18,9 @@ interface SpecialObject {
 const areObjectsEqual: TypeEqualityComparator<SpecialObject, undefined> = (
   a,
   b,
-) => {
-  return a.foo === b.foo && a.bar.baz === b.bar.baz;
-};
+) => a.foo === b.foo && a.bar.baz === b.bar.baz;
 
-const isSpecialObjectEqual = createCustomEqual(() => ({
-  areObjectsEqual,
-}));
+const isSpecialObjectEqual = createCustomEqual({
+  createCustomConfig: () => ({ areObjectsEqual }),
+});
 ```

package/recipes/legacy-circular-equal-support.md

@@ -3,14 +3,9 @@
 Starting in `4.x.x`, `WeakMap` is expected to be available in the environment. All modern browsers support this global object, however there may be situations where a legacy environmental support is required (example: IE11). If you need to support such an environment, creating a custom comparator that uses a custom cache implementation with the same contract is a simple solution.
 
 ```ts
-import { createCustomEqual, sameValueZeroEqual } from 'deep-Equals';
+import { createCustomEqual, sameValueZeroEqual } from 'fast-equals';
 
-interface Cache extends BaseCircularMeta {
-  customMethod(): void;
-  customValue: string;
-}
-
-function getCache(): Cache {
+function getCache(): BaseCircular {
   const entries: Array<[object, any]> = [];
 
   return {
@@ -45,22 +40,35 @@ function getCache(): Cache {
 
       return this;
     },
-
-    customMethod() {
-      console.log('hello!');
-    },
-    customValue: 'goodbye',
   };
 }
 
-const customDeepCircularHandler = createCustomCircularEqual<Cache>(() => ({}));
+interface Meta {
+  customMethod(): void;
+  customValue: string;
+}
+
+const meta = {
+  customMethod() {
+    console.log('hello!');
+  },
+  customValue: 'goodbye',
+};
 
-const customDeepCircularHandler = createCustomCircularEqual<Cache>(() => ({
-  createIsNestedEqual: () => sameValueZeroEqual,
-}));
+const circularDeepEqual = createCustomEqual<Cache>({
+  circular: true,
+  createState: () => ({
+    cache: getCache(),
+    meta,
+  }),
+});
 
-const circularDeepEqual = <A, B>(a: A, b: B) =>
-  customDeepCircularHandler(a, b, getCache());
-const circularShallowEqual = <A, B>(a: A, b: B) =>
-  customShallowCircularHandler(a, b, getCache());
+const circularShallowEqual = createCustomEqual<Cache>({
+  circular: true,
+  comparator: sameValueZeroEqual,
+  createState: () => ({
+    cache: getCache(),
+    meta,
+  }),
+});
 ```

package/recipes/legacy-regexp-support.md

@@ -6,21 +6,20 @@ Starting in `4.x.x`, `RegExp.prototype.flags` is expected to be available in the
 import { createCustomEqual, sameValueZeroEqual } from 'deep-Equals';
 import type { TypeEqualityComparator } from 'fast-equals';
 
-const areRegExpsEqual: TypeEqualityComparator<RegExp, undefined> = (a, b) => {
-  return (
-    a.source === b.source &&
-    a.global === b.global &&
-    a.ignoreCase === b.ignoreCase &&
-    a.multiline === b.multiline &&
-    a.unicode === b.unicode &&
-    a.sticky === b.sticky &&
-    a.lastIndex === b.lastIndex
-  );
-};
+const areRegExpsEqual: TypeEqualityComparator<RegExp, undefined> = (a, b) =>
+  a.source === b.source &&
+  a.global === b.global &&
+  a.ignoreCase === b.ignoreCase &&
+  a.multiline === b.multiline &&
+  a.unicode === b.unicode &&
+  a.sticky === b.sticky &&
+  a.lastIndex === b.lastIndex;
 
-const deepEqual = createCustomEqual(() => ({ areRegExpsEqual }));
-const shallowEqual = createCustomEqual(() => ({
-  areRegExpsEqual,
-  createIsNestedEqual: () => sameValueZeroEqual,
-}));
+const deepEqual = createCustomEqual({
+  createCustomConfig: () => ({ areRegExpsEqual }),
+});
+const shallowEqual = createCustomEqual({
+  comparator: sameValueZero,
+  createCustomConfig: () => ({ areRegExpsEqual }),
+});
 ```

package/recipes/non-standard-properties.md

@@ -1,34 +1,46 @@
 # Non-standard properties
 
-Sometimes, objects require a comparison that extend beyond its own keys. Perhaps there is a non-enumerable property that is important, or perhaps there are symbols as keys. In this case, the standard validators will return false positives, because internally `fast-equals` uses `Object.keys()` for object comparisons.
-
-Using a custom object comparator with `createCustomEqual` allows these kinds of comparisons.
+Sometimes, objects require a comparison that extend beyond its own keys, or even its own properties or symbols. Using a custom object comparator with `createCustomEqual` allows these kinds of comparisons.
 
 ```ts
 import { createCustomEqual } from 'fast-equals';
 import type { TypeEqualityComparator } from 'fast-equals';
 
-const areObjectsEqual: TypeEqualityComparator<Record<any, any>, undefined> = (
-  a,
-  b,
-) => {
-  const propertiesA = [
-    ...Object.getOwnPropertyNames(a),
-    ...Object.getOwnPropertySymbols(a),
-  ];
-  const propertiesB = [
-    ...Object.getOwnPropertyNames(b),
-    ...Object.getOwnPropertySymbols(b),
-  ];
-
-  if (propertiesA.length !== propertiesB.length) {
-    return false;
+class HiddenProperty {
+  visible: boolean;
+  #hidden: string;
+
+  constructor(value: string) {
+    this.visible = true;
+    this.#hidden = value;
+  }
+
+  get hidden() {
+    return this.#hidden;
   }
+}
+
+function createAreObjectsEqual(
+  areObjectsEqual: TypeEqualityComparator<Record<any, any>, undefined>,
+): TypeEqualityComparator<Record<any, any>, undefined> {
+  return function (a, b, state) {
+    if (!areObjectsEqual(a, b, state)) {
+      return false;
+    }
+
+    const aInstance = a instanceof HiddenProperty;
+    const bInstance = b instanceof HiddenProperty;
+
+    if (aInstance || bInstance) {
+      return aInstance && bInstance && a.hidden === b.hidden;
+    }
 
-  return propertiesA.every(
-    (property) => a[property as any] === b[property as any],
-  );
-};
+    return true;
+  };
+}
 
-const deepEqual = createCustomEqual(() => ({ areObjectsEqual }));
+const deepEqual = createCustomEqual({
+  createCustomConfig: ({ areObjectsEqual }) =>
+    createAreObjectsEqual(areObjectsEqual),
+});
 ```

package/recipes/using-meta-in-comparison.md

@@ -1,23 +1,20 @@
 # Using `meta` in comparison
 
-Sometimes a "pure" equality between two objects is insufficient, because the comparison relies on some external state. While these kinds of scenarios should generally be avoided, it is possible to handle them with a custom comparator that checks `meta` values.
+Sometimes a "pure" equality between two objects is insufficient, because the comparison relies on some external state. While these kinds of scenarios should generally be avoided, it is possible to handle them with a custom internal comparator that checks `meta` values.
 
 ```ts
 import { createCustomEqual } from 'fast-equals';
-import type {
-  EqualityComparator,
-  InternalEqualityComparator,
-} from 'fast-equals';
 
-interface MutableState {
-  state: string;
+interface Meta {
+  value: string;
 }
 
-const mutableState: MutableState = { state: 'baz' };
+const meta: Meta = { value: 'baz' };
 
-const createIsNestedEqual: EqualityComparatorCreator<MutableState> =
-  (deepEqual) => (a, b, keyA, keyB, parentA, parentB, meta) =>
-    deepEqual(a, b, meta) || a === meta.state || b === meta.state;
-
-const deepEqual = createCustomEqual(() => ({ createIsNestedEqual }));
+const deepEqual = createCustomEqual<Meta>({
+  createInternalComparator:
+    (compare) => (a, b, _keyA, _keyB, _parentA, _parentB, state) =>
+      compare(a, b, state) || a === state.meta.value || b === state.meta.value,
+  createState: () => ({ meta }),
+});
 ```

package/src/comparator.ts

@@ -1,37 +1,37 @@
-import { isPlainObject, isPromiseLike, sameValueZeroEqual } from './utils';
-
 import type {
-  CreateComparatorCreatorOptions,
+  ComparatorConfig,
   EqualityComparator,
-} from '../index.d';
+  State,
+} from './internalTypes';
 
 const ARGUMENTS_TAG = '[object Arguments]';
 const BOOLEAN_TAG = '[object Boolean]';
 const DATE_TAG = '[object Date]';
-const REG_EXP_TAG = '[object RegExp]';
 const MAP_TAG = '[object Map]';
 const NUMBER_TAG = '[object Number]';
 const OBJECT_TAG = '[object Object]';
+const REG_EXP_TAG = '[object RegExp]';
 const SET_TAG = '[object Set]';
 const STRING_TAG = '[object String]';
 
-const { toString } = Object.prototype;
+const { isArray } = Array;
+const getTag = Object.prototype.toString.call.bind(
+  Object.prototype.toString,
+) as (a: object) => string;
 
 export function createComparator<Meta>({
   areArraysEqual,
   areDatesEqual,
   areMapsEqual,
   areObjectsEqual,
+  arePrimitiveWrappersEqual,
   areRegExpsEqual,
   areSetsEqual,
-  createIsNestedEqual,
-}: CreateComparatorCreatorOptions<Meta>): EqualityComparator<Meta> {
-  const isEqual = createIsNestedEqual(comparator as EqualityComparator<Meta>);
-
+}: ComparatorConfig<Meta>): EqualityComparator<Meta> {
   /**
    * compare the value of the two objects and return true if they are equivalent in values
    */
-  function comparator(a: any, b: any, meta: Meta): boolean {
+  return function comparator(a: any, b: any, state: State<Meta>): boolean {
     // If the items are strictly equal, no need to do a value comparison.
     if (a === b) {
       return true;
@@ -57,64 +57,69 @@ export function createComparator<Meta>({
     // `isPlainObject` only checks against the object's own realm. Cross-realm
     // comparisons are rare, and will be handled in the ultimate fallback, so
     // we can avoid the `toString.call()` cost unless necessary.
-    if (isPlainObject(a) && isPlainObject(b)) {
-      return areObjectsEqual(a, b, isEqual, meta);
+    if (a.constructor === Object && b.constructor === Object) {
+      return areObjectsEqual(a, b, state);
     }
 
     // `isArray()` works on subclasses and is cross-realm, so we can again avoid
     // the `toString.call()` cost unless necessary by just checking if either
     // and then both are arrays.
-    const aArray = Array.isArray(a);
-    const bArray = Array.isArray(b);
+    const aArray = isArray(a);
+    const bArray = isArray(b);
 
     if (aArray || bArray) {
-      return aArray === bArray && areArraysEqual(a, b, isEqual, meta);
+      return aArray === bArray && areArraysEqual(a, b, state);
     }
 
     // Since this is a custom object, use the classic `toString.call()` to get its
     // type. This is reasonably performant in modern environments like v8 and
     // SpiderMonkey, and allows for cross-realm comparison when other checks like
     // `instanceof` do not.
-    const aTag = toString.call(a);
+    const tag = getTag(a);
 
-    if (aTag !== toString.call(b)) {
+    if (tag !== getTag(b)) {
       return false;
     }
 
-    if (aTag === DATE_TAG) {
-      // `getTime()` showed better results compared to alternatives like `valueOf()`
-      // or the unary `+` operator.
-      return areDatesEqual(a, b, isEqual, meta);
+    if (tag === DATE_TAG) {
+      return areDatesEqual(a, b, state);
     }
 
-    if (aTag === REG_EXP_TAG) {
-      return areRegExpsEqual(a, b, isEqual, meta);
+    if (tag === REG_EXP_TAG) {
+      return areRegExpsEqual(a, b, state);
     }
 
-    if (aTag === MAP_TAG) {
-      return areMapsEqual(a, b, isEqual, meta);
+    if (tag === MAP_TAG) {
+      return areMapsEqual(a, b, state);
     }
 
-    if (aTag === SET_TAG) {
-      return areSetsEqual(a, b, isEqual, meta);
+    if (tag === SET_TAG) {
+      return areSetsEqual(a, b, state);
     }
 
     // If a simple object tag, then we can prioritize a simple object comparison because
-    // it is likely a custom class. If an arguments tag, it should be treated as a standard
-    // object.
-    if (aTag === OBJECT_TAG || aTag === ARGUMENTS_TAG) {
+    // it is likely a custom class.
+    if (tag === OBJECT_TAG) {
       // The exception for value comparison is `Promise`-like contracts. These should be
-      // treated the same as standard `Promise` objects, which means strict equality.
-      return isPromiseLike(a) || isPromiseLike(b)
-        ? false
-        : areObjectsEqual(a, b, isEqual, meta);
+      // treated the same as standard `Promise` objects, which means strict equality, and if
+      // it reaches this point then that strict equality comparison has already failed.
+      return (
+        typeof a.then !== 'function' &&
+        typeof b.then !== 'function' &&
+        areObjectsEqual(a, b, state)
+      );
+    }
+
+    // If an arguments tag, it should be treated as a standard object.
+    if (tag === ARGUMENTS_TAG) {
+      return areObjectsEqual(a, b, state);
     }
 
     // As the penultimate fallback, check if the values passed are primitive wrappers. This
     // is very rare in modern JS, which is why it is deprioritized compared to all other object
     // types.
-    if (aTag === BOOLEAN_TAG || aTag === NUMBER_TAG || aTag === STRING_TAG) {
-      return sameValueZeroEqual(a.valueOf(), b.valueOf());
+    if (tag === BOOLEAN_TAG || tag === NUMBER_TAG || tag === STRING_TAG) {
+      return arePrimitiveWrappersEqual(a, b, state);
     }
 
     // If not matching any tags that require a specific type of comparison, then we hard-code false because
@@ -129,7 +134,5 @@ export function createComparator<Meta>({
     // In all cases, these decisions should be reevaluated based on changes to the language and
     // common development practices.
     return false;
-  }
-
-  return comparator as EqualityComparator<Meta>;
+  };
 }