@longlast/equals 0.5.4 → 0.5.6

package/dist/index.js

@@ -67,40 +67,65 @@ export const equals = curry(_equals);
 function _equals(a, b) {
     // This is an optimized implementation. There is a simpler, equivalent one
     // in pkg/equals/alt/reference.ts.
+    if (a == null) {
+        return a === b;
+    }
     // TODO: (pre-1.0.0) decide if we should pass `equals` as the second
     // argument to [$equals]. This would open the "protocol" up a bit more,
     // since people could then define their own implementations of `equals`
     // that work consistently through custom equality comparisons.
-    // TODO: Compare cross-realm objects.
-    if (a != null && typeof a[$equals] === "function") {
+    if (typeof a[$equals] === "function") {
         return Boolean(a[$equals](b));
     }
     if (Object.is(a, b)) {
         return true;
     }
-    if (a instanceof Date && b instanceof Date) {
+    if (typeof a === "function" && typeof b === "function") {
+        const aUnapplied = a[$unapplied];
+        const bUnapplied = b[$unapplied];
+        return (aUnapplied != null &&
+            aUnapplied === bUnapplied &&
+            _equals(getBoundArguments(a), getBoundArguments(b)));
+    }
+    // If `a` is a primitive at this point, return false, since we already know
+    // it is not identical to `b`.
+    if (typeof a !== "object") {
+        return false;
+    }
+    const aConstructorString = functionString(constructorOf(a));
+    const bConstructorString = functionString(constructorOf(b));
+    if (aConstructorString !== bConstructorString) {
+        return false;
+    }
+    if (dateConstructorString === aConstructorString) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
         return Object.is(+a, +b);
     }
-    if (a instanceof RegExp && b instanceof RegExp) {
+    if (regexConstructorString === aConstructorString) {
         return String(a) === String(b);
     }
-    if (a instanceof Error && b instanceof Error) {
-        return a.message === b.message && protoOf(a) === protoOf(b);
+    if (a instanceof Error ||
+        nativeErrorConstructorStrings.includes(aConstructorString)) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
+        return a.message === b.message;
     }
-    if (Array.isArray(a) && Array.isArray(b)) {
+    if (Array.isArray(a)) {
+        unsafeNarrow(b);
         return a.length === b.length && a.every((_, i) => _equals(a[i], b[i]));
     }
-    if (a instanceof Set && b instanceof Set) {
+    if (setConstructorString === aConstructorString) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
         return a.size === b.size && [...a].every((v) => b.has(v));
     }
-    if (typeof a === "function" && typeof b === "function") {
-        const aUnapplied = a[$unapplied];
-        const bUnapplied = b[$unapplied];
-        return (aUnapplied != null &&
-            aUnapplied === bUnapplied &&
-            _equals(getBoundArguments(a), getBoundArguments(b)));
-    }
-    if (a && b && typeof a === "object" && protoOf(a) === protoOf(b)) {
+    // TODO: typed arrays
+    // TODO: Map
+    if (objectConstructorString === aConstructorString ||
+        protoOf(a) === protoOf(b)) {
+        unsafeNarrow(a);
+        unsafeNarrow(b);
         const aKeys = Object.keys(a);
         const bKeys = Object.keys(b);
         if (aKeys.length !== bKeys.length) {
@@ -123,4 +148,33 @@ function getBoundArguments(f) {
     // TODO: (pre-1.0.0) remove `f[$boundArguments]` fallback.
     return f[$getBoundArguments]?.() ?? f[$boundArguments];
 }
+function functionString(f) {
+    if (typeof f !== "function") {
+        return "";
+    }
+    return Function.prototype.toString.call(f);
+}
+function constructorOf(value) {
+    if (value == null) {
+        return null;
+    }
+    return protoOf(value)?.constructor;
+}
+function unsafeNarrow(value) {
+    value;
+}
 const protoOf = Object.getPrototypeOf;
+const objectConstructorString = functionString(Object);
+const dateConstructorString = functionString(Date);
+const regexConstructorString = functionString(RegExp);
+const setConstructorString = functionString(Set);
+const nativeErrorConstructorStrings = [
+    functionString(Error),
+    // TODO: add DOMException? Be sure to check the `name` property.
+    functionString(EvalError),
+    functionString(RangeError),
+    functionString(ReferenceError),
+    functionString(SyntaxError),
+    functionString(TypeError),
+    functionString(URIError),
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longlast/equals",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Deeply compares objects",
   "homepage": "https://longlast.js.org/",
   "license": "MIT",
@@ -19,5 +19,8 @@
   "dependencies": {
     "@longlast/curry": "^0.5.0",
     "@longlast/symbols": "^1.0.0"
+  },
+  "devDependencies": {
+    "fast-deep-equal": "3.1.3"
   }
 }