remove dependency on @magic/deep

package.json

@@ -32,9 +32,6 @@
     "src"
   ],
   "homepage": "https://github.com/magic/types",
-  "dependencies": {
-    "@magic/deep": "0.1.1"
-  },
   "devDependencies": {
     "@magic-modules/gdpr": "0.0.12",
     "@magic-modules/git-badges": "0.0.3",

src/deep/different.mjs

@@ -0,0 +1,18 @@
+import is from '@magic/types'
+
+import equal from './equal.mjs'
+
+export const different = (a, b) => {
+  if (is.undefined(b)) {
+    if (is.undefined(a)) {
+      // this most likely is an argument error.
+      return false
+    }
+
+    return c => different(a, c)
+  }
+
+  return !equal(a, b)
+}
+
+export default different

src/deep/equal.mjs

@@ -0,0 +1,101 @@
+// Written by Substack <3
+
+import is from '@magic/types'
+
+export const equal = (a, b) => {
+  // curry
+  if (is.undefined(b)) {
+    if (is.undefined(a)) {
+      // this is not true, but it has to be assumed this is an unintentional comparation
+      return false
+    }
+
+    return c => equal(a, c)
+  }
+
+  if (is.null(b)) {
+    return a === b
+  }
+
+  // types must match
+  if (typeof a !== typeof b) {
+    return false
+  }
+
+  // bool, string, number, falsy values
+  if (is.comparable(a) || is.comparable(b)) {
+    return a === b
+  }
+
+  // if (is.<arguments(a)) {
+  //  return is.length.eq(a, b)
+  // }
+
+  // identical 'prototype' property.
+  if (a.prototype !== b.prototype) {
+    return false
+  }
+
+  // real types must match too
+  if (Object.prototype.toString.call(a) !== Object.prototype.toString.call(b)) {
+    return false
+  }
+
+  // dates
+  if (is.date(a)) {
+    return a === b
+  }
+
+  // functions
+  if (is.function(a)) {
+    return a.toString() === b.toString()
+  }
+
+  // buffers
+  if (is.buffer(a)) {
+    if (a.length !== b.length) {
+      return false
+    }
+
+    for (let i = 0; i < a.length; i++) {
+      if (a[i] !== b[i]) {
+        return false
+      }
+    }
+
+    return true
+  }
+
+  // objects
+  const ka = Object.keys(a)
+  const kb = Object.keys(b)
+
+  // having the same number of owned properties (keys incorporates
+  // hasOwnProperty)
+  if (ka.length !== kb.length) {
+    return false
+  }
+  // the same set of keys (although not necessarily the same order),
+  ka.sort()
+  kb.sort()
+  // ~~~cheap key test
+  for (let i = ka.length - 1; i >= 0; i--) {
+    if (ka[i] !== kb[i]) {
+      return false
+    }
+  }
+
+  // equivalent values for every corresponding key, and
+  // ~~~possibly expensive deep test
+  let key
+  for (let i = ka.length - 1; i >= 0; i--) {
+    key = ka[i]
+    if (!equal(a[key], b[key])) {
+      return false
+    }
+  }
+
+  return typeof a === typeof b
+}
+
+export default equal

src/deep/index.mjs

@@ -0,0 +1,7 @@
+import { equal } from './equal.mjs'
+import { different } from './different.mjs'
+
+export default {
+  equal,
+  different,
+}

src/index.mjs

@@ -1,4 +1,4 @@
-import deep from '@magic/deep'
+import deep from './deep/index.mjs'
 
 export const isArray = e => Array.isArray(e)
 
@@ -388,15 +388,23 @@ export const is = {
   isFalsy,
   falsy: isFalsy,
 
-  isDeepEqual: deep.eq,
-  deepEqual: deep.eq,
-  deepEq: deep.eq,
+  isDeepEqual: deep.equal,
+  deepEqual: deep.equal,
+  deepEq: deep.equal,
 
-  isDeepDifferent: deep.diff,
-  deepDifferent: deep.diff,
-  deepDiff: deep.diff,
+  isDeepDifferent: deep.different,
+  deepDifferent: deep.different,
+  deepDiff: deep.different,
 
-  deep,
+  deep: {
+    isDifferent: deep.different,
+    different: deep.different,
+    diff: deep.different,
+
+    isEqual: deep.equal,
+    equal: deep.equal,
+    eq: deep.equal,
+  },
 
   isLengthGreater,
   isLengthGreaterOrEqual,
@@ -442,12 +450,4 @@ const ln = {
 const lenKeys = ['count', 'length', 'len', 'ln']
 Object.entries(ln).forEach(([k, v]) => lenKeys.forEach(key => (is[key][k] = v)))
 
-is.deep.isDifferent = deep.diff
-is.deep.different = deep.diff
-is.deep.diff = deep.diff
-
-is.deep.isEqual = deep.eq
-is.deep.equal = deep.eq
-is.deep.eq = deep.eq
-
 export default is