@bybrave/fast-deep-equal2 4.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2017 Evgeny Poberezkin
+Copyright (c) 2026 bybrave (maintained fork @bybrave/fast-deep-equal2)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# @bybrave/fast-deep-equal2
+
+Maintained, drop-in fork of [`fast-deep-equal`](https://github.com/epoberezkin/fast-deep-equal) — the fastest deep-equality check for JavaScript.
+
+The original has had no release since 2020 (`3.1.3`) while still pulling ~710M downloads/month. This fork fixes the null-prototype crash, adds a circular-safe variant, folds Map/Set/TypedArray support into the default function, and ships ESM plus improved bundled types.
+
+```sh
+npm install @bybrave/fast-deep-equal2
+```
+
+```js
+const equal = require('@bybrave/fast-deep-equal2');   // CommonJS
+import equal from '@bybrave/fast-deep-equal2';         // ESM
+import { equal, react, circular } from '@bybrave/fast-deep-equal2';
+
+equal({ a: 1, b: [2, 3] }, { a: 1, b: [2, 3] }); // true
+```
+
+The default `equal(a, b)` is the same fast function as upstream, and remains a TypeScript type guard (`a is T`). Map, Set, TypedArray and BigInt are compared out of the box — no separate `es6` entry needed.
+
+## What's fixed
+
+| Issue | Problem | Fix |
+|---|---|---|
+| [#49](https://github.com/epoberezkin/fast-deep-equal/issues/49) / [#111](https://github.com/epoberezkin/fast-deep-equal/issues/111) | Comparing objects created with `Object.create(null)` threw `a.valueOf is not a function` (21+ 👍). | `valueOf`/`toString` are only called when the object actually overrides them and they're callable — null-prototype objects compare by their own keys instead. |
+| [#17](https://github.com/epoberezkin/fast-deep-equal/issues/17) | Circular references caused a `RangeError` (stack overflow). | New `circular` export tracks visited pairs and handles cycles. The default `equal` stays allocation-free and fast. |
+| [#81](https://github.com/epoberezkin/fast-deep-equal/issues/81) | Type fixes weren't shipped. | Bundled, improved types (default + `react` + `circular`), verified with `tsc --strict`. |
+| — | Map/Set/TypedArray lived in a separate `es6` entry. | Folded into the default function (Node 18+ has them). |
+
+## Exports
+
+- **`equal(a, b)`** (default) — fast deep equality, Map/Set/TypedArray/BigInt aware, null-prototype safe. Throws on circular references (use `circular` for those).
+- **`circular(a, b)`** — same, but safe against circular references (tracks visited object pairs; slightly slower).
+- **`react(a, b)`** — ignores React elements' circular `_owner`. Also available as the subpath `@bybrave/fast-deep-equal2/react` for drop-in parity with `fast-deep-equal/react`.
+
+## Migration from `fast-deep-equal`
+
+Replace the dependency and the import. `equal` behaves the same, except comparing `Object.create(null)` objects now works instead of throwing. If you imported `fast-deep-equal/es6`, just use the default — Map/Set/TypedArray are built in. `fast-deep-equal/react` → `@bybrave/fast-deep-equal2/react`.
+
+## Support
+
+If this package saves you time, you can support maintenance:
+
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-buy%20me%20a%20coffee-FF5E5B?logo=kofi&logoColor=white)](https://ko-fi.com/bybrave)
+[![Bitcoin](https://img.shields.io/badge/Bitcoin-BTC-F7931A?logo=bitcoin&logoColor=white)](#support)
+
+Bitcoin (BTC): `bc1q37557q5jpeaxqydzwvf3jgj7zhnfpn2td3q40q`
+
+## Credits & license
+
+MIT, same as the original — see [LICENSE](./LICENSE).
+Based on [fast-deep-equal](https://github.com/epoberezkin/fast-deep-equal) by Evgeny Poberezkin.

package/dist/index.cjs

@@ -0,0 +1,107 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// index.js
+var fast_deep_equal2_exports = {};
+__export(fast_deep_equal2_exports, {
+  circular: () => circular,
+  default: () => fast_deep_equal2_default,
+  equal: () => equal,
+  react: () => react
+});
+module.exports = __toCommonJS(fast_deep_equal2_exports);
+function build(react2, cycles) {
+  return function equal2(a, b, seen) {
+    if (a === b) return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+      if (a.constructor !== b.constructor) return false;
+      var length, i, keys;
+      if (cycles) {
+        if (!seen) seen = /* @__PURE__ */ new WeakMap();
+        var seenB = seen.get(a);
+        if (seenB) {
+          if (seenB.has(b)) return true;
+          seenB.add(b);
+        } else {
+          seenB = /* @__PURE__ */ new WeakSet();
+          seenB.add(b);
+          seen.set(a, seenB);
+        }
+      }
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (!equal2(a[i], b[i], seen)) return false;
+        return true;
+      }
+      if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        for (i of a.entries())
+          if (!equal2(i[1], b.get(i[0]), seen)) return false;
+        return true;
+      }
+      if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        return true;
+      }
+      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (a[i] !== b[i]) return false;
+        return true;
+      }
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function")
+        return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString && typeof a.toString === "function")
+        return a.toString() === b.toString();
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+      for (i = length; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+      for (i = length; i-- !== 0; ) {
+        var key = keys[i];
+        if (react2 && key === "_owner" && a.$$typeof) {
+          continue;
+        }
+        if (!equal2(a[key], b[key], seen)) return false;
+      }
+      return true;
+    }
+    return a !== a && b !== b;
+  };
+}
+var equal = build(false, false);
+var react = build(true, false);
+var circular = build(false, true);
+var fast_deep_equal2_default = equal;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  circular,
+  equal,
+  react
+});
+if(module.exports.default)module.exports=Object.assign(module.exports.default,module.exports);

package/dist/react.cjs

@@ -0,0 +1,106 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// react.js
+var react_exports = {};
+__export(react_exports, {
+  default: () => react_default,
+  react: () => react
+});
+module.exports = __toCommonJS(react_exports);
+
+// index.js
+function build(react2, cycles) {
+  return function equal2(a, b, seen) {
+    if (a === b) return true;
+    if (a && b && typeof a == "object" && typeof b == "object") {
+      if (a.constructor !== b.constructor) return false;
+      var length, i, keys;
+      if (cycles) {
+        if (!seen) seen = /* @__PURE__ */ new WeakMap();
+        var seenB = seen.get(a);
+        if (seenB) {
+          if (seenB.has(b)) return true;
+          seenB.add(b);
+        } else {
+          seenB = /* @__PURE__ */ new WeakSet();
+          seenB.add(b);
+          seen.set(a, seenB);
+        }
+      }
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (!equal2(a[i], b[i], seen)) return false;
+        return true;
+      }
+      if (a instanceof Map && b instanceof Map) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        for (i of a.entries())
+          if (!equal2(i[1], b.get(i[0]), seen)) return false;
+        return true;
+      }
+      if (a instanceof Set && b instanceof Set) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        return true;
+      }
+      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0; )
+          if (a[i] !== b[i]) return false;
+        return true;
+      }
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function")
+        return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString && typeof a.toString === "function")
+        return a.toString() === b.toString();
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+      for (i = length; i-- !== 0; )
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+      for (i = length; i-- !== 0; ) {
+        var key = keys[i];
+        if (react2 && key === "_owner" && a.$$typeof) {
+          continue;
+        }
+        if (!equal2(a[key], b[key], seen)) return false;
+      }
+      return true;
+    }
+    return a !== a && b !== b;
+  };
+}
+var equal = build(false, false);
+var react = build(true, false);
+var circular = build(false, true);
+
+// react.js
+var react_default = react;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  react
+});
+if(module.exports.default)module.exports=Object.assign(module.exports.default,module.exports);

package/index.d.ts

@@ -0,0 +1,15 @@
+declare function equal<T>(a: any, b: T): a is T;
+
+export default equal;
+export {equal};
+
+/**
+ * Deep equality that ignores React elements' circular `_owner` field.
+ */
+export function react<T>(a: any, b: T): a is T;
+
+/**
+ * Deep equality that is safe against circular references (tracks visited
+ * object pairs). Slightly slower than the default `equal`.
+ */
+export function circular<T>(a: any, b: T): a is T;

package/index.js

@@ -0,0 +1,109 @@
+'use strict';
+
+var envHasBigInt64Array = typeof BigInt64Array !== 'undefined';
+
+// Build a deep-equality function with compile-time flags baked in, so the hot
+// path carries no per-call option overhead. `react` skips React elements'
+// circular `_owner`; `cycles` tracks visited object pairs to survive circular
+// references (#17).
+function build(react, cycles) {
+  return function equal(a, b, seen) {
+    if (a === b) return true;
+
+    if (a && b && typeof a == 'object' && typeof b == 'object') {
+      if (a.constructor !== b.constructor) return false;
+
+      var length, i, keys;
+
+      if (cycles) {
+        if (!seen) seen = new WeakMap();
+        var seenB = seen.get(a);
+        if (seenB) {
+          // If we've already started comparing this pair, assume equal to break
+          // the cycle; a real mismatch elsewhere will still surface.
+          if (seenB.has(b)) return true;
+          seenB.add(b);
+        } else {
+          seenB = new WeakSet();
+          seenB.add(b);
+          seen.set(a, seenB);
+        }
+      }
+
+      if (Array.isArray(a)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0;)
+          if (!equal(a[i], b[i], seen)) return false;
+        return true;
+      }
+
+      if ((a instanceof Map) && (b instanceof Map)) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        for (i of a.entries())
+          if (!equal(i[1], b.get(i[0]), seen)) return false;
+        return true;
+      }
+
+      if ((a instanceof Set) && (b instanceof Set)) {
+        if (a.size !== b.size) return false;
+        for (i of a.entries())
+          if (!b.has(i[0])) return false;
+        return true;
+      }
+
+      if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+        length = a.length;
+        if (length != b.length) return false;
+        for (i = length; i-- !== 0;)
+          if (a[i] !== b[i]) return false;
+        return true;
+      }
+
+      if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+      // Only defer to valueOf/toString when the object actually overrides them
+      // AND they are callable — objects created with `Object.create(null)` have
+      // neither, and calling a missing valueOf used to throw (#49/#111).
+      if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === 'function')
+        return a.valueOf() === b.valueOf();
+      if (a.toString !== Object.prototype.toString && typeof a.toString === 'function')
+        return a.toString() === b.toString();
+
+      keys = Object.keys(a);
+      length = keys.length;
+      if (length !== Object.keys(b).length) return false;
+
+      for (i = length; i-- !== 0;)
+        if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+
+      for (i = length; i-- !== 0;) {
+        var key = keys[i];
+
+        if (react && key === '_owner' && a.$$typeof) {
+          // React elements' _owner contains circular references and is not part
+          // of the element's identity.
+          continue;
+        }
+
+        if (!equal(a[key], b[key], seen)) return false;
+      }
+
+      return true;
+    }
+
+    // true if both NaN, false otherwise
+    return a !== a && b !== b;
+  };
+}
+
+// eslint keeps envHasBigInt64Array referenced for parity with upstream's es6 build.
+void envHasBigInt64Array;
+
+var equal = build(false, false);
+var react = build(true, false);
+var circular = build(false, true);
+
+export default equal;
+export {equal, react, circular};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@bybrave/fast-deep-equal2",
+  "version": "4.0.0",
+  "description": "Maintained fork of fast-deep-equal — fast deep equality with the null-prototype crash fixed (#49), a circular-safe variant (#17), Map/Set/TypedArray support built in, ESM, and bundled types",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./react": {
+      "types": "./react.d.ts",
+      "import": "./react.js",
+      "require": "./dist/react.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": ["index.js", "index.d.ts", "react.js", "react.d.ts", "dist/"],
+  "scripts": {
+    "build": "node build/build.js",
+    "test": "node --test test/*.test.js",
+    "test-types": "tsc --noEmit --strict test/type-declarations.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {"type": "git", "url": "git+https://github.com/bybraveHQ/fast-deep-equal2.git"},
+  "bugs": {"url": "https://github.com/bybraveHQ/fast-deep-equal2/issues"},
+  "homepage": "https://github.com/bybraveHQ/fast-deep-equal2#readme",
+  "keywords": ["fast", "deep", "equal", "equality", "compare", "deepequal", "circular", "react", "esm", "typescript"],
+  "author": "bybrave (https://github.com/bybraveHQ)",
+  "contributors": ["Evgeny Poberezkin (author of the original fast-deep-equal)"],
+  "license": "MIT",
+  "funding": "https://ko-fi.com/bybrave",
+  "engines": {"node": ">=18"},
+  "devDependencies": {"@types/node": "^20.14.0", "esbuild": "^0.23.0", "typescript": "^5.5.0"}
+}

package/react.d.ts

@@ -0,0 +1,3 @@
+declare function equalReact<T>(a: any, b: T): a is T;
+export default equalReact;
+export {equalReact as react};

package/react.js

@@ -0,0 +1,3 @@
+import {react} from './index.js';
+export default react;
+export {react};