{"_id":"@cjser/fast-equals__v5_4_2","name":"@cjser/fast-equals__v5_4_2","dist-tags":{"latest":"5.4.2-cjser.2"},"versions":{"5.4.2-cjser.2":{"author":{"name":"Tony Quetano","email":"tony.quetano@planttheidea.com","url":"https://www.planttheidea.com/"},"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":{"@planttheidea/build-tools":"^2.0.2","@types/lodash":"^4.17.24","@types/node":"^24.13.3","@types/ramda":"^0.31.1","@types/react":"^19.2.17","@types/react-dom":"^19.2.3","@typescript-eslint/eslint-plugin":"^8.63.0","@typescript-eslint/parser":"^8.63.0","@vitest/coverage-v8":"^4.1.10","cli-table3":"^0.6.5","decircularize":"^1.0.0","deep-eql":"^5.0.2","deep-equal":"^2.2.3","dequal":"^2.0.3","eslint":"^9.39.4","eslint-friendly-formatter":"^4.0.1","eslint-plugin-import":"^2.32.0","fast-deep-equal":"^3.1.3","fast-glob":"^3.3.3","lodash":"^4.18.1","nano-equal":"^2.0.2","prettier":"^3.9.4","react":"^19.2.7","react-dom":"^19.2.7","react-fast-compare":"^3.2.2","release-it":"^20.2.1","rollup":"^4.62.2","shallow-equal-fuzzy":"^0.0.2","tinybench":"^6.0.2","typescript":"^5.9.3","typescript-eslint":"^8.63.0","underscore":"^1.13.8","vite":"^8.1.4","vitest":"^4.1.10"},"engines":{"node":">=6.0.0"},"exports":{".":{"require":"./dist-cjser/index.cjs","import":{"types":"./dist/es/index.d.mts","default":"./dist/es/index.mjs"},"default":{"types":"./dist/umd/index.d.ts","default":"./dist/umd/index.js"}}},"homepage":"https://github.com/planttheidea/fast-equals#readme","keywords":["fast","equal","equals","deep-equal","equivalent"],"license":"MIT","main":"./dist-cjser/index.cjs","module":"./dist/es/index.mjs","name":"@cjser/fast-equals__v5_4_2","publishConfig":{"access":"public"},"repository":{"type":"git","url":"https://code.moenext.com/3rdeye/cjser.git"},"scripts":{"benchmark":"npm run build && node benchmark/index.js","build":"npm run clean && npm run build:dist","build:dist":"NODE_ENV=production rollup -c config/rollup.config.js","build:types":"pti fix-types -l dist","clean":"rm -rf dist","clean:cjs":"rm -rf dist/cjs","clean:es":"rm -rf dist/es","clean:umd":"rm -rf dist/umd","dev":"vite --config=config/vite.config.ts","format":"prettier . --log-level=warn --write","format:check":"prettier . --log-level=warn --check","lint":"eslint --max-warnings=0","lint:fix":"npm run lint -- --fix","release:alpha":"release-it --config=config/release-it/alpha.json","release:beta":"release-it --config=config/release-it/beta.json","release:rc":"release-it --config=config/release-it/rc.json","release:scripts":"npm run format:check && npm run typecheck && npm run lint && npm run test && npm run build","release:stable":"release-it --config=config/release-it/stable.json","start":"npm run dev","test":"vitest run --config=config/vitest.config.ts","typecheck":"tsc --noEmit"},"sideEffects":false,"type":"module","types":"./index.d.ts","version":"5.4.2-cjser.2","cjser":{"sourceVersion":"5.4.2","cjserVersion":2,"original":{"name":"fast-equals","version":"5.4.2","main":"./dist/cjs/index.cjs","exports":{".":{"import":{"types":"./dist/es/index.d.mts","default":"./dist/es/index.mjs"},"require":{"types":"./dist/cjs/index.d.cts","default":"./dist/cjs/index.cjs"},"default":{"types":"./dist/umd/index.d.ts","default":"./dist/umd/index.js"}}},"repository":{"type":"git","url":"git+https://github.com/planttheidea/fast-equals.git"},"files":["dist","LICENSE","README.md","index.d.ts","package.json"],"scripts":{"benchmark":"npm run build && node benchmark/index.js","build":"npm run clean && npm run build:dist","build:dist":"NODE_ENV=production rollup -c config/rollup.config.js","build:types":"pti fix-types -l dist","clean":"rm -rf dist","clean:cjs":"rm -rf dist/cjs","clean:es":"rm -rf dist/es","clean:umd":"rm -rf dist/umd","dev":"vite --config=config/vite.config.ts","format":"prettier . --log-level=warn --write","format:check":"prettier . --log-level=warn --check","lint":"eslint --max-warnings=0","lint:fix":"npm run lint -- --fix","release:alpha":"release-it --config=config/release-it/alpha.json","release:beta":"release-it --config=config/release-it/beta.json","release:rc":"release-it --config=config/release-it/rc.json","release:scripts":"npm run format:check && npm run typecheck && npm run lint && npm run test && npm run build","release:stable":"release-it --config=config/release-it/stable.json","start":"npm run dev","test":"vitest run --config=config/vitest.config.ts","typecheck":"tsc --noEmit"}}},"gitHead":"a4bef54d7d22d3d9a6b84528457938d84cd65fe7","_id":"@cjser/fast-equals__v5_4_2@5.4.2-cjser.2","_nodeVersion":"24.14.0","_npmVersion":"11.9.0","dist":{"integrity":"sha512-XQAJLfF37EJXNvrPmoLG6viZ0S32OJPYPei6veHjzxFgsMPTPz8oBAaoSRpq5f0TvswZlbW4IOs+dad4UGr4mw==","shasum":"0e776ffc12b76bc1988e757c71c9b71f059343b0","tarball":"https://registry.npmjs.org/@cjser/fast-equals__v5_4_2/-/fast-equals__v5_4_2-5.4.2-cjser.2.tgz","fileCount":14,"unpackedSize":310454,"signatures":[{"keyid":"SHA256:DhQ8wR5APBvFHLF/+Tc+AYvPOdTpcIDqOhxsBHRwC7U","sig":"MEQCICx2X7uZpn4b4zIdtjPXr8eiMYGNSjg1uD4lOa/hR0cGAiB87JrbGX39X5OVuXyzXiOuaLc0KV3ig6cnoR2A0CFL3g=="}]},"_npmUser":{"name":"nanahira","email":"nanahira@momobako.com"},"directories":{},"maintainers":[{"name":"nanahira","email":"nanahira@momobako.com"}],"_npmOperationalInternal":{"host":"s3://npm-registry-packages-npm-production","tmp":"tmp/fast-equals__v5_4_2_5.4.2-cjser.2_1788454276753_0.9811108936709731"},"_hasShrinkwrap":false}},"time":{"created":"2026-09-03T16:51:16.531Z","5.4.2-cjser.2":"2026-09-03T16:51:16.892Z","modified":"2026-09-03T16:51:17.213Z"},"maintainers":[{"name":"nanahira","email":"nanahira@momobako.com"}],"description":"A blazing fast equality comparison, either shallow or deep","homepage":"https://github.com/planttheidea/fast-equals#readme","keywords":["fast","equal","equals","deep-equal","equivalent"],"repository":{"type":"git","url":"https://code.moenext.com/3rdeye/cjser.git"},"author":{"name":"Tony Quetano","email":"tony.quetano@planttheidea.com","url":"https://www.planttheidea.com/"},"bugs":{"url":"https://github.com/planttheidea/fast-equals/issues"},"license":"MIT","readme":"# fast-equals\n\n<img src=\"https://img.shields.io/badge/build-passing-brightgreen.svg\"/>\n<img src=\"https://img.shields.io/badge/coverage-100%25-brightgreen.svg\"/>\n<img src=\"https://img.shields.io/badge/license-MIT-blue.svg\"/>\n\nPerform [blazing fast](#benchmarks) equality comparisons (either deep or shallow) on two objects passed, while also\nmaintaining a high degree of flexibility for various implementation use-cases. It has no dependencies, and is ~2.3kB\nwhen minified and gzipped.\n\nThe following types are handled out-of-the-box:\n\n- Plain objects (including `react` elements and `Arguments`)\n- Arrays\n- `ArrayBuffer` / `TypedArray` / `DataView` instances\n- `Date` objects\n- `RegExp` objects\n- `Map` / `Set` iterables\n- `Promise` objects\n- `Error` objects, including subclasses and their own properties\n- `URL` objects\n- Primitive wrappers (`new Boolean()` / `new Number()` / `new String()`)\n- Custom class instances, including subclasses of native classes\n\nMethods are available for deep, shallow, or referential equality comparison. In addition, you can opt into support for\ncircular objects, or performing a \"strict\" comparison with unconventional property definition, or both. You can also\ncustomize any specific type comparison based on your application's use-cases.\n\n## Table of contents\n\n- [fast-equals](#fast-equals)\n  - [Table of contents](#table-of-contents)\n  - [Usage](#usage)\n    - [Specific builds](#specific-builds)\n  - [Available methods](#available-methods)\n    - [deepEqual](#deepequal)\n      - [Comparing `Map`s](#comparing-maps)\n    - [shallowEqual](#shallowequal)\n    - [sameValueZeroEqual](#samevaluezeroequal)\n    - [circularDeepEqual](#circulardeepequal)\n    - [circularShallowEqual](#circularshallowequal)\n    - [strictDeepEqual](#strictdeepequal)\n    - [strictShallowEqual](#strictshallowequal)\n    - [strictCircularDeepEqual](#strictcirculardeepequal)\n    - [strictCircularShallowEqual](#strictcircularshallowequal)\n    - [createCustomEqual](#createcustomequal)\n      - [unknownTagComparators](#unknowntagcomparators)\n      - [Recipes](#recipes)\n  - [Benchmarks](#benchmarks)\n  - [Development](#development)\n\n## Usage\n\n```ts\nimport { deepEqual } from 'fast-equals';\n\nconsole.log(deepEqual({ foo: 'bar' }, { foo: 'bar' })); // true\n```\n\n### Specific builds\n\nBy default, npm should resolve the correct build of the package based on your consumption (ESM vs CommonJS). However, if\nyou want to force use of a specific build, they can be located here:\n\n- ESM => `fast-equals/dist/esm/index.mjs`\n- CommonJS => `fast-equals/dist/cjs/index.cjs`\n- UMD => `fast-equals/dist/umd/index.js`\n- Minified UMD => `fast-equals/dist/min/index.js`\n\nIf you are having issues loading a specific build type,\n[please file an issue](https://github.com/planttheidea/fast-equals/issues).\n\n## Available methods\n\n### deepEqual\n\nPerforms a deep equality comparison on the two objects passed and returns a boolean representing the value equivalency\nof the objects.\n\n```ts\nimport { deepEqual } from 'fast-equals';\n\nconst objectA = { foo: { bar: 'baz' } };\nconst objectB = { foo: { bar: 'baz' } };\n\nconsole.log(objectA === objectB); // false\nconsole.log(deepEqual(objectA, objectB)); // true\n```\n\n#### Comparing `Map`s\n\n`Map` objects support complex keys (objects, Arrays, etc.), however\n[the spec for key lookups in `Map` are based on `SameZeroValue`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map#key_equality).\nIf the spec were followed for comparison, the following would always be `false`:\n\n```ts\nconst mapA = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);\nconst mapB = new Map([[{ foo: 'bar' }, { baz: 'quz' }]]);\n\ndeepEqual(mapA, mapB);\n```\n\nTo support true deep equality of all contents, `fast-equals` will perform a deep equality comparison for key and value\nparirs. Therefore, the above would be `true`.\n\n### shallowEqual\n\nPerforms a shallow equality comparison on the two objects passed and returns a boolean representing the value\nequivalency of the objects.\n\n```ts\nimport { shallowEqual } from 'fast-equals';\n\nconst nestedObject = { bar: 'baz' };\n\nconst objectA = { foo: nestedObject };\nconst objectB = { foo: nestedObject };\nconst objectC = { foo: { bar: 'baz' } };\n\nconsole.log(objectA === objectB); // false\nconsole.log(shallowEqual(objectA, objectB)); // true\nconsole.log(shallowEqual(objectA, objectC)); // false\n```\n\n### sameValueZeroEqual\n\nPerforms a [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) comparison on the two\nobjects passed and returns a boolean representing the value equivalency of the objects. In simple terms, this means\neither strictly equal or both `NaN`.\n\n```ts\nimport { sameValueZeroEqual } from 'fast-equals';\n\nconst mainObject = { foo: NaN, bar: 'baz' };\n\nconst objectA = 'baz';\nconst objectB = NaN;\nconst objectC = { foo: NaN, bar: 'baz' };\n\nconsole.log(sameValueZeroEqual(mainObject.bar, objectA)); // true\nconsole.log(sameValueZeroEqual(mainObject.foo, objectB)); // true\nconsole.log(sameValueZeroEqual(mainObject, objectC)); // false\n```\n\n### circularDeepEqual\n\nPerforms the same comparison as `deepEqual` but supports circular objects. It is slower than `deepEqual`, so only use if\nyou know circular objects are present.\n\n```ts\nfunction Circular(value) {\n  this.me = {\n    deeply: {\n      nested: {\n        reference: this,\n      },\n    },\n    value,\n  };\n}\n\nconsole.log(circularDeepEqual(new Circular('foo'), new Circular('foo'))); // true\nconsole.log(circularDeepEqual(new Circular('foo'), new Circular('bar'))); // false\n```\n\nJust as with `deepEqual`, [both keys and values are compared for deep equality](#comparing-maps).\n\n### circularShallowEqual\n\nPerforms the same comparison as `shallowequal` but supports circular objects. It is slower than `shallowEqual`, so only\nuse if you know circular objects are present.\n\n```ts\nconst array = ['foo'];\n\narray.push(array);\n\nconsole.log(circularShallowEqual(array, ['foo', array])); // true\nconsole.log(circularShallowEqual(array, [array])); // false\n```\n\n### strictDeepEqual\n\nPerforms the same comparison as `deepEqual` but performs a strict comparison of the objects. In this includes:\n\n- Checking symbol properties\n- Checking non-enumerable properties in object comparisons\n- Checking full descriptor of properties on the object to match\n- Checking non-index properties on arrays\n- Checking non-key properties on `Map` / `Set` objects\n\n```ts\nconst array = [{ foo: 'bar' }];\nconst otherArray = [{ foo: 'bar' }];\n\narray.bar = 'baz';\notherArray.bar = 'baz';\n\nconsole.log(strictDeepEqual(array, otherArray)); // true;\nconsole.log(strictDeepEqual(array, [{ foo: 'bar' }])); // false;\n```\n\n### strictShallowEqual\n\nPerforms the same comparison as `shallowEqual` but performs a strict comparison of the objects. In this includes:\n\n- Checking non-enumerable properties in object comparisons\n- Checking full descriptor of properties on the object to match\n- Checking non-index properties on arrays\n- Checking non-key properties on `Map` / `Set` objects\n\n```ts\nconst array = ['foo'];\nconst otherArray = ['foo'];\n\narray.bar = 'baz';\notherArray.bar = 'baz';\n\nconsole.log(strictDeepEqual(array, otherArray)); // true;\nconsole.log(strictDeepEqual(array, ['foo'])); // false;\n```\n\n### strictCircularDeepEqual\n\nPerforms the same comparison as `circularDeepEqual` but performs a strict comparison of the objects. In this includes:\n\n- Checking `Symbol` properties on the object\n- Checking non-enumerable properties in object comparisons\n- Checking full descriptor of properties on the object to match\n- Checking non-index properties on arrays\n- Checking non-key properties on `Map` / `Set` objects\n\n```ts\nfunction Circular(value) {\n  this.me = {\n    deeply: {\n      nested: {\n        reference: this,\n      },\n    },\n    value,\n  };\n}\n\nconst first = new Circular('foo');\n\nObject.defineProperty(first, 'bar', {\n  enumerable: false,\n  value: 'baz',\n});\n\nconst second = new Circular('foo');\n\nObject.defineProperty(second, 'bar', {\n  enumerable: false,\n  value: 'baz',\n});\n\nconsole.log(circularDeepEqual(first, second)); // true\nconsole.log(circularDeepEqual(first, new Circular('foo'))); // false\n```\n\n### strictCircularShallowEqual\n\nPerforms the same comparison as `circularShallowEqual` but performs a strict comparison of the objects. In this\nincludes:\n\n- Checking non-enumerable properties in object comparisons\n- Checking full descriptor of properties on the object to match\n- Checking non-index properties on arrays\n- Checking non-key properties on `Map` / `Set` objects\n\n```ts\nconst array = ['foo'];\nconst otherArray = ['foo'];\n\narray.push(array);\notherArray.push(otherArray);\n\narray.bar = 'baz';\notherArray.bar = 'baz';\n\nconsole.log(circularShallowEqual(array, otherArray)); // true\nconsole.log(circularShallowEqual(array, ['foo', array])); // false\n```\n\n### createCustomEqual\n\nCreates a custom equality comparator that will be used on nested values in the object. Unlike `deepEqual` and\n`shallowEqual`, this is a factory method that receives the default options used internally, and allows you to override\nthe defaults as needed. This is generally for extreme edge-cases, or supporting legacy environments.\n\nThe signature is as follows:\n\n```ts\ninterface Cache<Key extends object, Value> {\n  delete(key: Key): boolean;\n  get(key: Key): Value | undefined;\n  set(key: Key, value: any): any;\n}\n\ninterface ComparatorConfig<Meta> {\n  areArraysEqual: TypeEqualityComparator<any[], Meta>;\n  areDatesEqual: TypeEqualityComparator<Date, Meta>;\n  areErrorsEqual: TypeEqualityComparator<Error, Meta>;\n  areFunctionsEqual: TypeEqualityComparator<(...args: any[]) => any, Meta>;\n  areMapsEqual: TypeEqualityComparator<Map<any, any>, Meta>;\n  areObjectsEqual: TypeEqualityComparator<Record<string, any>, Meta>;\n  arePrimitiveWrappersEqual: TypeEqualityComparator<boolean | string | number, Meta>;\n  areRegExpsEqual: TypeEqualityComparator<RegExp, Meta>;\n  areSetsEqual: TypeEqualityComparator<Set<any>, Meta>;\n  areTypedArraysEqual: TypeEqualityComparator<TypedArray, Meta>;\n  areUrlsEqual: TypeEqualityComparator<URL, Meta>;\n  unknownTagComparators: Record<string, TypeEqualityComparator<string, any>>;\n}\n\nfunction createCustomEqual<Meta>(options: {\n  circular?: boolean;\n  createCustomConfig?: (defaultConfig: ComparatorConfig<Meta>) => Partial<ComparatorConfig<Meta>>;\n  createInternalComparator?: (\n    compare: <A, B>(a: A, b: B, state: State<Meta>) => boolean,\n  ) => (a: any, b: any, indexOrKeyA: any, indexOrKeyB: any, parentA: any, parentB: any, state: State<Meta>) => boolean;\n  createState?: () => { cache?: Cache; meta?: Meta };\n  strict?: boolean;\n}): <A, B>(a: A, b: B) => boolean;\n```\n\nCreate a custom equality comparator. This allows complete control over building a bespoke equality method, in case your\nuse-case requires a higher degree of performance, legacy environment support, or any other non-standard usage. The\n[recipes](#recipes) provide examples of use in different use-cases, but if you have a specific goal in mind and would\nlike assistance feel free to [file an issue](https://github.com/planttheidea/fast-equals/issues).\n\n_**NOTE**: `Map` implementations compare equality for both keys and value. When using a custom comparator and comparing\nequality of the keys, the iteration index is provided as both `indexOrKeyA` and `indexOrKeyB` to help use-cases where\nordering of keys matters to equality._\n\n#### unknownTagComparators\n\nIf you want to compare objects that have a custom `@@toStringTag`, you can provide a map of the custom tags you want to\nsupport via the `unknownTagComparators` option. See [this recipe]('./recipes/special-objects.md) for an example.\n\n#### Recipes\n\nSome recipes have been created to provide examples of use-cases for `createCustomEqual`. Even if not directly applicable\nto the problem you are solving, they can offer guidance of how to structure your solution.\n\n- [Legacy environment support for `RegExp` comparators](./recipes/legacy-regexp-support.md)\n- [Explicit property check](./recipes/explicit-property-check.md)\n- [Using `meta` in comparison](./recipes//using-meta-in-comparison.md)\n- [Comparing non-standard properties](./recipes/non-standard-properties.md)\n- [Strict property descriptor comparison](./recipes/strict-property-descriptor-check.md)\n- [Legacy environment support for circualr equal comparators](./recipes/legacy-circular-equal-support.md)\n- [Custom `@@toStringTag` support](./recipes/special-objects.md)\n\n## Benchmarks\n\nAll benchmarks were performed on an i9-11900H Ubuntu Linux 24.04 laptop with 64GB of memory using NodeJS version\n`20.17.0`, and are based on averages of running comparisons based deep equality on the following object types:\n\n- Primitives (`String`, `Number`, `null`, `undefined`)\n- `Function`\n- `Object`\n- `Array`\n- `Date`\n- `RegExp`\n- `react` elements\n- A mixed object with a combination of all the above types\n\n```bash\nTesting mixed objects equal...\n┌────────────────────────────────────────┬────────────────┐\n│ Name                                   │ Ops / sec      │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (passed)                   │ 1416193.769468 │\n├────────────────────────────────────────┼────────────────┤\n│ fast-deep-equal (passed)               │ 1284824.583215 │\n├────────────────────────────────────────┼────────────────┤\n│ react-fast-compare (passed)            │ 1246947.505444 │\n├────────────────────────────────────────┼────────────────┤\n│ shallow-equal-fuzzy (passed)           │ 1238082.379207 │\n├────────────────────────────────────────┼────────────────┤\n│ nano-equal (failed)                    │ 946782.33704   │\n├────────────────────────────────────────┼────────────────┤\n│ dequal/lite (passed)                   │ 758213.632866  │\n├────────────────────────────────────────┼────────────────┤\n│ dequal (passed)                        │ 756789.655029  │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (circular) (passed)        │ 726093.253185  │\n├────────────────────────────────────────┼────────────────┤\n│ underscore.isEqual (passed)            │ 489748.701783  │\n├────────────────────────────────────────┼────────────────┤\n│ assert.deepStrictEqual (passed)        │ 453761.890107  │\n├────────────────────────────────────────┼────────────────┤\n│ lodash.isEqual (passed)                │ 288264.867811  │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (strict) (passed)          │ 217221.619705  │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (strict circular) (passed) │ 186916.942934  │\n├────────────────────────────────────────┼────────────────┤\n│ deep-eql (passed)                      │ 162487.877883  │\n├────────────────────────────────────────┼────────────────┤\n│ deep-equal (passed)                    │ 916.680714     │\n└────────────────────────────────────────┴────────────────┘\n\nTesting mixed objects not equal...\n┌────────────────────────────────────────┬────────────────┐\n│ Name                                   │ Ops / sec      │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (passed)                   │ 4687012.640614 │\n├────────────────────────────────────────┼────────────────┤\n│ fast-deep-equal (passed)               │ 3418170.156109 │\n├────────────────────────────────────────┼────────────────┤\n│ react-fast-compare (passed)            │ 3283516.669966 │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (circular) (passed)        │ 3268062.099602 │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (strict) (passed)          │ 1747578.66456  │\n├────────────────────────────────────────┼────────────────┤\n│ fast-equals (strict circular) (passed) │ 1477873.624956 │\n├────────────────────────────────────────┼────────────────┤\n│ dequal/lite (passed)                   │ 1335397.839502 │\n├────────────────────────────────────────┼────────────────┤\n│ dequal (passed)                        │ 1319426.71146  │\n├────────────────────────────────────────┼────────────────┤\n│ shallow-equal-fuzzy (failed)           │ 1237432.986615 │\n├────────────────────────────────────────┼────────────────┤\n│ nano-equal (passed)                    │ 1064383.319776 │\n├────────────────────────────────────────┼────────────────┤\n│ underscore.isEqual (passed)            │ 920462.516736  │\n├────────────────────────────────────────┼────────────────┤\n│ lodash.isEqual (passed)                │ 379370.998021  │\n├────────────────────────────────────────┼────────────────┤\n│ deep-eql (passed)                      │ 184111.383127  │\n├────────────────────────────────────────┼────────────────┤\n│ assert.deepStrictEqual (passed)        │ 20775.59065    │\n├────────────────────────────────────────┼────────────────┤\n│ deep-equal (passed)                    │ 3678.51009     │\n└────────────────────────────────────────┴────────────────┘\n```\n\nCaveats that impact the benchmark (and accuracy of comparison):\n\n- `Map`s, `Promise`s, and `Set`s were excluded from the benchmark entirely because no library other than `deep-eql`\n  fully supported their comparison\n- `fast-deep-equal`, `react-fast-compare` and `nano-equal` throw on objects with `null` as prototype\n  (`Object.create(null)`)\n- `assert.deepStrictEqual` does not support `NaN` or `SameValueZero` equality for dates\n- `deep-eql` does not support `SameValueZero` equality for zero equality (positive and negative zero are not equal)\n- `deep-equal` does not support `NaN` and does not strictly compare object type, or date / regexp values, nor uses\n  `SameValueZero` equality for dates\n- `fast-deep-equal` does not support `NaN` or `SameValueZero` equality for dates\n- `nano-equal` does not strictly compare object property structure, array length, or object type, nor `SameValueZero`\n  equality for dates\n- `react-fast-compare` does not support `NaN` or `SameValueZero` equality for dates, and does not compare `function`\n  equality\n- `shallow-equal-fuzzy` does not strictly compare object type or regexp values, nor `SameValueZero` equality for dates\n- `underscore.isEqual` does not support `SameValueZero` equality for primitives or dates\n\nAll of these have the potential of inflating the respective library's numbers in comparison to `fast-equals`, but it was\nthe closest apples-to-apples comparison I could create of a reasonable sample size. It should be noted that `react`\nelements can be circular objects, however simple elements are not; I kept the `react` comparison very basic to allow it\nto be included.\n\n## Development\n\nStandard practice, clone the repo and `npm i` to get the dependencies. The following npm scripts are available:\n\n- benchmark => run benchmark tests against other equality libraries\n- build => build `main`, `module`, and `browser` distributables with `rollup`\n- clean => run `rimraf` on the `dist` folder\n- dev => start `vite` playground App\n- dist => run `build`\n- lint => run ESLint on all files in `src` folder (also runs on `dev` script)\n- lint:fix => run `lint` script, but with auto-fixer\n- prepublish:compile => run `lint`, `test:coverage`, `transpile:lib`, `transpile:es`, and `dist` scripts\n- start => run `dev`\n- test => run AVA with NODE_ENV=test on all files in `test` folder\n- test:coverage => run same script as `test` with code coverage calculation via `nyc`\n- test:watch => run same script as `test` but keep persistent watcher\n\n## cjser\n\nThis package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.\nOriginal repository: https://github.com/planttheidea/fast-equals\n","readmeFilename":"README.md","_rev":"1-05e11697fb3eefdec5a461c20bfdd5ef"}