@superhero/deep 4.0.0 → 4.2.0

package/README.md

@@ -22,7 +22,7 @@ import deepassign from '@superhero/deep/assign'
 const target = { foo: { bar: 1 } }
 const source = { foo: { baz: 2 } }
 
-deepassign.assign(target, source)
+deepassign(target, source)
 
 console.log(target) // { foo: { bar: 1, baz: 2 } }
 ```
@@ -46,7 +46,7 @@ import deepmerge from '@superhero/deep/merge'
 const obj1 = { foo: { bar: 1 }, arr: [1, 2] }
 const obj2 = { foo: { baz: 2 }, arr: [2, 3] }
 
-const result = deepmerge.merge(obj1, obj2)
+const result = deepmerge(obj1, obj2)
 
 console.log(result)
 // { foo: { bar: 1, baz: 2 }, arr: [1, 2, 3] }
@@ -70,7 +70,7 @@ import deepfreeze from '@superhero/deep/freeze'
 const obj = { foo: { bar: 'baz' } }
 obj.foo.self = obj.foo // Circular reference
 
-deepfreeze.freeze(obj)
+deepfreeze(obj)
 
 obj.foo.bar = 'new value' // TypeError: Cannot assign to read-only property
 ```
@@ -93,7 +93,7 @@ import deepclone from '@superhero/deep/clone'
 
 const obj = { foo: { bar: 'baz' }, arr: [1, 2, 3] }
 
-const clone = deepclone.clone(obj)
+const clone = deepclone(obj)
 
 console.log(clone) // Deeply cloned object
 console.log(clone === obj) // false
@@ -101,6 +101,37 @@ console.log(clone === obj) // false
 
 ---
 
+## 5. **Deep**
+
+### Purpose:
+Makes the functions accessible through the imported default object.
+
+### Features:
+- Exports all the above mentioned functions.
+- Exports a default object with all the above mentioned functions as members.
+
+### Example:
+```javascript
+import deep from '@superhero/deep'
+
+deep.assign(/* ... */)
+deep.clone(/* ... */)
+deep.freeze(/* ... */)
+deep.merge(/* ... */)
+```
+
+### Example:
+```javascript
+import { assign, clone, freeze, merge } from '@superhero/deep'
+
+assign(/* ... */)
+clone(/* ... */)
+freeze(/* ... */)
+merge(/* ... */)
+```
+
+---
+
 ## Testing
 Each utility class has a set of unit tests to ensure correctness across different cases.
 
@@ -114,75 +145,86 @@ npm test
 
 ```
 ▶ @superhero/deep/assign
-  ✔ Merges arrays correctly (2.205053ms)
-  ✔ Merges objects correctly (0.37599ms)
-  ✔ Overwrites non-object properties correctly (0.211516ms)
-  ✔ Handles undefined values correctly (0.174874ms)
+  ✔ Assigns arrays correctly (3.167398ms)
+  ✔ Assigns objects correctly (0.763768ms)
+  ✔ Overwrites non-object properties correctly (0.347727ms)
+  ✔ Handles undefined values correctly (0.521744ms)
+
   ▶ Descriptor properties
     ▶ Retains
-      ✔ non-writable, non-configurable and non-enumarable (0.302976ms)
-      ✔ writable but non-configurable and non-enumarable (0.250721ms)
-      ✔ writable and configurable but non-enumarable (0.148421ms)
-    ✔ Retains (0.912545ms)
+      ✔ non-writable, non-configurable and non-enumarable (0.474666ms)
+      ✔ writable but non-configurable and non-enumarable (0.649244ms)
+      ✔ writable and configurable but non-enumarable (0.298073ms)
+    ✔ Retains (1.918778ms)
+
     ▶ Assigns
-      ✔ non-writable, non-configurable and non-enumarable (0.266101ms)
-    ✔ Assigns (1.379408ms)
-  ✔ Descriptor properties (2.578897ms)
-  ✔ Merges nested arrays correctly (0.188364ms)
-  ✔ Merges nested objects correctly (0.159693ms)
-  ✔ Does not alter objects with no conflicts (0.127767ms)
-✔ @superhero/deep/assign (7.763161ms)
+      ✔ non-writable, non-configurable and non-enumarable (0.485428ms)
+    ✔ Assigns (0.889839ms)
+  ✔ Descriptor properties (3.74915ms)
+  
+  ✔ Merges nested arrays correctly (1.898073ms)
+  ✔ Merges nested objects correctly (0.761838ms)
+  ✔ Does not alter objects with no conflicts (0.277694ms)
+✔ @superhero/deep/assign (14.053485ms)
 
 ▶ @superhero/deep/clone
-  ✔ Clones simple objects (2.379372ms)
-  ✔ Clones nested objects (0.316103ms)
-  ✔ Clones arrays (0.31091ms)
-  ✔ Handles circular references (0.204913ms)
-  ✔ Clones objects with null prototype (0.385473ms)
-✔ @superhero/deep/clone (5.133978ms)
+  ✔ Clones simple objects (7.235299ms)
+  ✔ Clones nested objects (0.634553ms)
+  ✔ Clones arrays (0.650244ms)
+  ✔ Handles circular references (0.382144ms)
+  ✔ Clones objects with null prototype (0.375334ms)
+✔ @superhero/deep/clone (11.89498ms)
 
 ▶ @superhero/deep/freeze
-  ✔ Freezes a simple object (1.831304ms)
-  ✔ Freezes nested objects recursively (0.242757ms)
-  ✔ Handles circular references gracefully (0.155595ms)
-  ✔ Freezes objects with symbols (0.190945ms)
-  ✔ Handles already frozen objects without error (0.129469ms)
-  ✔ Freezes objects with non-enumerable properties (0.193278ms)
-  ✔ Freezes arrays (0.168815ms)
-  ✔ Handles objects with null prototype (0.160426ms)
-  ✔ Freezes objects with multiple property types (0.351257ms)
-✔ @superhero/deep/freeze (5.204715ms)
+  ✔ Freezes a simple object (3.683567ms)
+  ✔ Freezes nested objects recursively (0.406919ms)
+  ✔ Handles circular references gracefully (0.309979ms)
+  ✔ Freezes objects with symbols (0.405137ms)
+  ✔ Handles already frozen objects without error (0.337038ms)
+  ✔ Freezes objects with non-enumerable properties (0.354681ms)
+  ✔ Freezes arrays (0.662049ms)
+  ✔ Handles objects with null prototype (0.387428ms)
+  ✔ Freezes objects with multiple property types (0.626902ms)
+✔ @superhero/deep/freeze (10.607326ms)
+
+▶ @superhero/deep
+  ✔ All functions are accessible as a member to the default import object (1.734551ms)
+  ✔ All functions are accessible to import from the default import object (0.255022ms)
+✔ @superhero/deep (5.188429ms)
 
 ▶ @superhero/deep/merge
-  ✔ Merges arrays with unique values (2.511877ms)
-  ✔ Merges arrays with order preserved (0.324244ms)
-  ✔ Handles empty arrays correctly (0.319828ms)
-  ✔ Handles arrays with duplicate values (0.258181ms)
-  ✔ Merges objects and prioritizes restrictive descriptors (0.462677ms)
-  ✔ Merges objects with non-enumerable properties (0.203703ms)
-  ✔ Handles nested object merging (0.198121ms)
-  ✔ Stops at circular references (0.137618ms)
-  ✔ Stops when nested and with circular references (0.34896ms)
-  ✔ Returns second value for non-object types (0.230399ms)
-  ✔ Handles multiple merges sequentially (0.294846ms)
-✔ @superhero/deep/merge (7.196893ms)
-
-tests 36
-pass 36
+  ✔ Merges arrays with unique values (3.271451ms)
+  ✔ Merges arrays with order preserved (0.455376ms)
+  ✔ Handles empty arrays correctly (0.283857ms)
+  ✔ Handles arrays with duplicate values (0.538911ms)
+  ✔ Merges objects and prioritizes restrictive descriptors (0.592729ms)
+  ✔ Merges objects with non-enumerable properties (0.343159ms)
+  ✔ Handles nested object merging (0.359878ms)
+  ✔ Stops at circular references (0.554345ms)
+  ✔ Stops when nested and with circular references (0.667265ms)
+  ✔ Returns second value for non-object types (0.744991ms)
+  ✔ Handles multiple merges sequentially (0.327608ms)
+✔ @superhero/deep/merge (11.803686ms)
+
+tests 38
+suites 8
+pass 38
 
 -----------------------------------------------------------------
 file             | line % | branch % | funcs % | uncovered lines
 -----------------------------------------------------------------
 assign.js        | 100.00 |   100.00 |  100.00 | 
 assign.test.js   | 100.00 |   100.00 |  100.00 | 
-clone.js         | 100.00 |   100.00 |  100.00 | 
-clone.test.js    |  96.34 |    87.50 |  100.00 | 56-58
+clone.js         |  95.83 |    92.86 |  100.00 | 22-23
+clone.test.js    | 100.00 |   100.00 |  100.00 | 
 freeze.js        | 100.00 |   100.00 |  100.00 | 
 freeze.test.js   | 100.00 |   100.00 |  100.00 | 
+index.js         | 100.00 |   100.00 |  100.00 | 
+index.test.js    | 100.00 |   100.00 |  100.00 | 
 merge.js         | 100.00 |   100.00 |  100.00 | 
 merge.test.js    | 100.00 |   100.00 |  100.00 | 
 -----------------------------------------------------------------
-all files        |  99.65 |    99.15 |  100.00 | 
+all files        |  99.78 |    99.25 |  100.00 | 
 -----------------------------------------------------------------
 ```
 

package/assign.js

@@ -1,89 +1,86 @@
-export default new class DeepAssign
+export default function assign(a, ...b)
 {
-  assign(a, ...b)
+  b.forEach((b) => assignB2A(a, b))
+}
+
+function assignB2A(a, b)
+{
+  if(b === undefined)
   {
-    b.forEach((b) => this.#assign(a, b))
+    return a
   }
 
-  #assign(a, b)
+  if(Object.prototype.toString.call(a) === '[object Array]'
+  && Object.prototype.toString.call(b) === '[object Array]')
   {
-    if(b === undefined)
-    {
-      return a
-    }
-
-    if(Object.prototype.toString.call(a) === '[object Array]'
-    && Object.prototype.toString.call(b) === '[object Array]')
-    {
-      return this.#assignArray(a, b)
-    }
-
-    if(Object.prototype.toString.call(a) === '[object Object]'
-    && Object.prototype.toString.call(b) === '[object Object]')
-    {
-      return this.#assignObject(a, b)
-    }
-
-    return b
+    return assignArray(a, b)
   }
 
-  #assignArray(a, b)
+  if(Object.prototype.toString.call(a) === '[object Object]'
+  && Object.prototype.toString.call(b) === '[object Object]')
   {
-    const values = new Set(a.concat(b))
-    a.length = 0
-    a.push(...values)
-    return a
+    return assignObject(a, b)
   }
 
-  /**
-   * @param {Object} a 
-   * @param {Object} b 
-   * 
-   * @throws {TypeError} If a property in "a" is also in "b", 
-   *                     but the property in "a" is not configurable.
-   * 
-   * @returns {Object} a
-   */
-  #assignObject(a, b)
+  return b
+}
+
+function assignArray(a, b)
+{
+  const values = new Set(a.concat(b))
+  a.length = 0
+  a.push(...values)
+  return a
+}
+
+/**
+ * @param {Object} a 
+ * @param {Object} b 
+ * 
+ * @throws {TypeError} If a property in "a" is also in "b", 
+ *                     but the property in "a" is not configurable.
+ * 
+ * @returns {Object} a
+ */
+function assignObject(a, b)
+{
+  for (const key of Object.getOwnPropertyNames(b))
   {
-    for (const key of Object.getOwnPropertyNames(b))
+    if(Object.prototype.toString.call(a[key]) === '[object Object]'
+    && Object.prototype.toString.call(b[key]) === '[object Object]')
+    {
+      assignObject(a[key], b[key])
+    }
+    else if(Object.hasOwnProperty.call(a, key))
     {
-      if(Object.prototype.toString.call(a[key]) === '[object Object]'
-      && Object.prototype.toString.call(b[key]) === '[object Object]')
+      const descriptor_a = Object.getOwnPropertyDescriptor(a, key)
+
+      if(descriptor_a.configurable)
       {
-        this.#assignObject(a[key], b[key])
+        assignPropertyDescriptor(a, b, key)
       }
-      else if(Object.hasOwnProperty.call(a, key))
+      else if(descriptor_a.writable)
       {
-        const descriptor_a = Object.getOwnPropertyDescriptor(a, key)
-
-        if(descriptor_a.configurable)
-        {
-          this.#assignPropertyDescriptor(a, b, key)
-        }
-        else if(descriptor_a.writable)
-        {
-          descriptor_a.value = b[key]
-          Object.defineProperty(a, key, descriptor_a)
-        }
-        else
-        {
-          continue
-        }
+        descriptor_a.value = b[key]
+        Object.defineProperty(a, key, descriptor_a)
       }
       else
       {
-        this.#assignPropertyDescriptor(a, b, key)
+        continue
       }
     }
-
-    return a
+    else
+    {
+      assignPropertyDescriptor(a, b, key)
+    }
   }
 
-  #assignPropertyDescriptor(a, b, key)
-  {
-    const descriptor_b = Object.getOwnPropertyDescriptor(b, key)
-    descriptor_b.value = this.#assign(a[key], b[key])
-    Object.defineProperty(a, key, descriptor_b)
-  }
+  return a
+}
+
+function assignPropertyDescriptor(a, b, key)
+{
+  const descriptor_b = Object.getOwnPropertyDescriptor(b, key)
+  descriptor_b.value = assignB2A(a[key], b[key])
+  Object.defineProperty(a, key, descriptor_b)
 }

package/assign.test.js

@@ -4,25 +4,25 @@ import deepassign       from '@superhero/deep/assign'
 
 suite('@superhero/deep/assign', () =>
 {
-  test('Merges arrays correctly', () => 
+  test('Assigns arrays correctly', () => 
   {
     const 
       a         = [1, 2, 3],
       b         = [3, 4, 5],
       expected  = [1, 2, 3, 4, 5]
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Arrays should merge with unique values')
   })
 
-  test('Merges objects correctly', () => 
+  test('Assigns objects correctly', () => 
   {
     const 
       a         = { foo: 1, bar: { baz: 2 } },
-      b         = { bar: { qux: 3 }, hello: 'world' },
-      expected  = { foo: 1, bar: { baz: 2, qux: 3 }, hello: 'world' }
+      b         = { foo: 2, bar: { qux: 3 }, hello: 'world' },
+      expected  = { foo: 2, bar: { baz: 2, qux: 3 }, hello: 'world' }
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Objects should deep merge')
   })
   
@@ -33,7 +33,7 @@ suite('@superhero/deep/assign', () =>
       b         = { foo: 2 },
       expected  = { foo: 2 }
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Properties should be overwritten')
   })
   
@@ -44,7 +44,7 @@ suite('@superhero/deep/assign', () =>
       b         = { foo: undefined },
       expected  = { foo: 1 }
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Undefined values should not overwrite existing properties')
   })
 
@@ -66,7 +66,7 @@ suite('@superhero/deep/assign', () =>
       
         const b = { foo: 2 }
       
-        deepassign.assign(a, b)
+        deepassign(a, b)
       
         const descriptor_a = Object.getOwnPropertyDescriptor(a, 'foo')
       
@@ -90,7 +90,7 @@ suite('@superhero/deep/assign', () =>
       
         const b = { foo: 2 }
       
-        deepassign.assign(a, b)
+        deepassign(a, b)
       
         const descriptor_a = Object.getOwnPropertyDescriptor(a, 'foo')
       
@@ -114,7 +114,7 @@ suite('@superhero/deep/assign', () =>
       
         const b = { foo: 2 }
       
-        deepassign.assign(a, b)
+        deepassign(a, b)
       
         const descriptor_a = Object.getOwnPropertyDescriptor(a, 'foo')
       
@@ -141,7 +141,7 @@ suite('@superhero/deep/assign', () =>
           enumerable    : false
         })
       
-        deepassign.assign(a, b)
+        deepassign(a, b)
       
         const descriptor_a = Object.getOwnPropertyDescriptor(a, 'foo')
       
@@ -160,7 +160,7 @@ suite('@superhero/deep/assign', () =>
       b         = { foo: [2, 3] },
       expected  = { foo: [1, 2, 3] }
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Nested arrays should merge with unique values')
   })
   
@@ -171,7 +171,7 @@ suite('@superhero/deep/assign', () =>
       b         = { foo: { bar: { qux: 2 }}},
       expected  = { foo: { bar: { baz: 1, qux: 2 }}}
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Nested objects should deep merge')
   })
   
@@ -182,7 +182,7 @@ suite('@superhero/deep/assign', () =>
       b         = { bar: 2 },
       expected  = { foo: 1, bar: 2 }
   
-    deepassign.assign(a, b)
+    deepassign(a, b)
     assert.deepStrictEqual(a, expected, 'Objects without conflicts should merge correctly')
   })
 })

package/clone.js

@@ -1,9 +1,48 @@
-export default new class DeepClone
+export default function clone(input) 
 {
-  clone(a, legacy = false)
+  const seen = new WeakSet()
+  return deepClone(input, seen)
+}
+
+function deepClone(value, seen) 
+{
+  switch(Object.prototype.toString.call(value))
+  {
+    case '[object Array]'  : return cloneArray(value, seen)
+    case '[object Object]' : return cloneObject(value, seen)
+  }
+
+  return structuredClone(value)
+}
+
+function cloneArray(array, seen) 
+{
+  if(seen.has(array)) 
+  {
+    return array
+  }
+
+  seen.add(array)
+  return array.map((item) => deepClone(item, seen))
+}
+
+function cloneObject(obj, seen) 
+{
+  if(seen.has(obj)) 
+  {
+    return obj
+  }
+
+  seen.add(obj)
+
+  const output = {}
+
+  for(const key of Object.getOwnPropertyNames(obj)) 
   {
-    return structuredClone && false === legacy
-         ? structuredClone(a)
-         : JSON.parse(JSON.stringify(a))
+    const descriptor = Object.getOwnPropertyDescriptor(obj, key)
+    Object.defineProperty(output, key, 
+      { ...descriptor, value : deepClone(descriptor.value, seen) })
   }
+
+  return output
 }

package/clone.test.js

@@ -8,75 +8,76 @@ suite('@superhero/deep/clone', () =>
   {
     const 
       obj     = { foo: 'bar', baz: 42 },
-      result  = deepclone.clone(obj),
-      legacy  = deepclone.clone(obj, true)
+      cloned  = deepclone(obj)
 
-    assert.deepStrictEqual(result, obj, 'Cloned object should be equal to the original')
-    assert.deepStrictEqual(legacy, obj, 'Cloned object should be equal to the original (legacy mode)')
-
-    assert.notStrictEqual(result, obj, 'Cloned object should not be the same reference as the original')
-    assert.notStrictEqual(legacy, obj, 'Cloned object should not be the same reference as the original (legacy mode)')
+    assert.deepStrictEqual(cloned, obj, 'Cloned object should be equal to the original')
+    assert.notStrictEqual(cloned, obj, 'Not the same reference as the original')
   })
 
   test('Clones nested objects', () =>
   {
-    const obj = { foo: { bar: { baz: 'qux' } } }
-
     const 
-      result = deepclone.clone(obj),
-      legacy = deepclone.clone(obj, true)
+      obj     = { foo: { bar: { baz: 'qux' } } },
+      cloned  = deepclone(obj)
+
+    assert.deepStrictEqual(cloned, obj, 'Cloned nested object should be equal to the original')
+    assert.notStrictEqual(cloned.foo, obj.foo, 'Not the same reference as the original')
+  })
+
+  test('Preserves descriptors', () =>
+  {
+    const origin = {}
+
+    Object.defineProperty(origin, 'foo', { value: {}, enumerable: true,  writable: true,  configurable: true  })
+    Object.defineProperty(origin, 'bar', { value: {}, enumerable: false, writable: true,  configurable: true  })
+    Object.defineProperty(origin, 'baz', { value: {}, enumerable: false, writable: false, configurable: true  })
+    Object.defineProperty(origin, 'qux', { value: {}, enumerable: false, writable: false, configurable: false })
+
+    const cloned = deepclone(origin)
+
+    assert.deepStrictEqual(cloned,    origin,     'Cloned nested object should be equal to the original')
+    assert.notStrictEqual(cloned,     origin,     'Not the same reference as the original')
+    assert.notStrictEqual(cloned.foo, origin.foo, 'Cloned nested object should not share reference with the original')
 
-    assert.deepStrictEqual(result, obj, 'Cloned nested object should be equal to the original')
-    assert.deepStrictEqual(legacy, obj, 'Cloned nested object should be equal to the original (legacy mode)')
+    const
+      clonedDescriptors = Object.getOwnPropertyDescriptors(cloned),
+      originDescriptors = Object.getOwnPropertyDescriptors(origin)
 
-    assert.notStrictEqual(result.foo, obj.foo, 'Cloned nested object should not share reference with the original')
-    assert.notStrictEqual(legacy.foo, obj.foo, 'Cloned nested object should not share reference with the original (legacy mode)')
+    for(const key in originDescriptors)
+    {
+      assert.equal(clonedDescriptors[key].enumerable,    originDescriptors[key].enumerable)
+      assert.equal(clonedDescriptors[key].writable,      originDescriptors[key].writable)
+      assert.equal(clonedDescriptors[key].configurable,  originDescriptors[key].configurable)
+    }
   })
 
   test('Clones arrays', () =>
   {
-    const arr = [1, 2, 3, [4, 5]]
-
     const 
-      result = deepclone.clone(arr),
-      legacy = deepclone.clone(arr, true)
+      array   = [1, 2, 3, [4, 5]],
+      cloned  = deepclone(array)
 
-    assert.deepStrictEqual(result, arr, 'Cloned array should be equal to the original')
-    assert.deepStrictEqual(legacy, arr, 'Cloned array should be equal to the original (legacy mode)')
+    assert.deepStrictEqual(cloned, array, 'Cloned array should be equal to the original')
+    assert.notStrictEqual(cloned, array, 'Not the same reference as the original')
+    assert.notStrictEqual(cloned[3], array[3], 'Nested array in clone should not share reference with the original')
+  })
 
-    assert.notStrictEqual(result, arr, 'Cloned array should not share reference with the original')
-    assert.notStrictEqual(legacy, arr, 'Cloned array should not share reference with the original (legacy mode)')
+  test('Handles circular references', () =>
+  {
+    const obj = {}
+    obj.self = obj
 
-    assert.notStrictEqual(result[3], arr[3], 'Nested array in clone should not share reference with the original')
-    assert.notStrictEqual(legacy[3], arr[3], 'Nested array in clone should not share reference with the original (legacy mode)')
+    const cloned = deepclone(obj)
+    assert.strictEqual(cloned.self, obj, 'Circular references should be preserved in the clone')
   })
 
-  if(false === !!structuredClone)
-  {
-    test.skip('Handles circular references (structuredClone not available)')
-    test.skip('Clones objects with null prototype (structuredClone not available)')
-  }
-  else
+  test('Clones objects with null prototype', () =>
   {
-    test('Handles circular references', () =>
-    {
-      const obj = {}
-      obj.self = obj
-  
-      const result = deepclone.clone(obj)
-  
-      assert.strictEqual(result.self, result, 'Circular references should be preserved in the clone')
-    })
-  
-    test('Clones objects with null prototype', () =>
-    {
-      const obj = Object.create(null)
-      obj.foo = 'bar'
-  
-      const result = deepclone.clone(obj)
-  
-      assert.deepEqual(result, obj, 'Cloned object with null prototype should be equal to the original')
-      assert.notStrictEqual(result, obj, 'Cloned object with null prototype should not share reference with the original')
-    })
-  }
+    const obj = Object.create(null)
+    obj.foo = 'bar'
+
+    const cloned = deepclone(obj)
+    assert.deepEqual(cloned, obj, 'Cloned object with null prototype should be equal to the original')
+    assert.notStrictEqual(cloned, obj, 'Not the same reference as the original')
+  })
 })

package/freeze.js

@@ -1,33 +1,30 @@
-export default new class DeepFreeze
+export default function freeze(obj)
 {
-  freeze(obj)
-  {
-    const seen = new WeakSet
-    this.#freeze(obj, seen)
-  }
+  const seen = new WeakSet
+  freezeIterator(obj, seen)
+}
 
-  #freeze(obj, seen)
-  {
-    const objType = Object.prototype.toString.call(obj)
+function freezeIterator(obj, seen)
+{
+  const objType = Object.prototype.toString.call(obj)
 
-    if('[object Array]'   === objType
-    || '[object Object]'  === objType)
+  if('[object Array]'   === objType
+  || '[object Object]'  === objType)
+  {
+    if(seen.has(obj))
     {
-      if(seen.has(obj))
-      {
-        return
-      }
-      else
-      {
-        seen.add(obj)
-      }
-
-      for(const key of [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)])
-      {
-        this.#freeze(obj[key], seen)
-      }
+      return
+    }
+    else
+    {
+      seen.add(obj)
+    }
 
-      Object.freeze(obj)
+    for(const key of [...Object.getOwnPropertyNames(obj), ...Object.getOwnPropertySymbols(obj)])
+    {
+      freezeIterator(obj[key], seen)
     }
+
+    Object.freeze(obj)
   }
 }

package/freeze.test.js

@@ -8,7 +8,7 @@ suite('@superhero/deep/freeze', () =>
   {
     const obj = { foo: 'bar' }
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj.foo = 'baz' }, TypeError, 'Should not allow modifying a frozen object')
     assert.strictEqual(Object.isFrozen(obj), true,      'Object should be frozen')
@@ -18,7 +18,7 @@ suite('@superhero/deep/freeze', () =>
   {
     const obj = { foo: { bar: { baz: 'qux' } } }
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj.foo.bar.baz = 'changed' }, TypeError, 'Should not allow modifying nested properties')
     assert.strictEqual(Object.isFrozen(obj.foo.bar),  true, 'Nested object should be frozen')
@@ -30,7 +30,7 @@ suite('@superhero/deep/freeze', () =>
     const obj = {}
     obj.self = obj
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.strictEqual(Object.isFrozen(obj),      true, 'Object with circular reference should be frozen')
     assert.strictEqual(Object.isFrozen(obj.self), true, 'Circular reference should also be frozen')
@@ -41,7 +41,7 @@ suite('@superhero/deep/freeze', () =>
     const sym = Symbol('test')
     const obj = { [sym]: 'value' }
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj[sym] = 'new value' }, TypeError,  'Should not allow modifying properties with symbols')
     assert.strictEqual(Object.isFrozen(obj), true,              'Object with symbols should be frozen')
@@ -51,7 +51,7 @@ suite('@superhero/deep/freeze', () =>
   {
     const obj = Object.freeze({ foo: 'bar' })
 
-    deepfreeze.freeze(obj) // Should not throw an error
+    deepfreeze(obj) // Should not throw an error
     assert.strictEqual(Object.isFrozen(obj), true, 'Already frozen object should remain frozen')
   })
 
@@ -66,7 +66,7 @@ suite('@superhero/deep/freeze', () =>
       writable      : true
     })
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj.foo = 'baz' }, TypeError, 'Should not allow modifying non-enumerable properties')
     assert.strictEqual(Object.isFrozen(obj), true,      'Object with non-enumerable properties should be frozen')
@@ -76,7 +76,7 @@ suite('@superhero/deep/freeze', () =>
   {
     const arr = [1, 2, 3]
 
-    deepfreeze.freeze(arr)
+    deepfreeze(arr)
 
     assert.throws(() => { arr[0] = 4 }, TypeError, 'Should not allow modifying an array')
     assert.strictEqual(Object.isFrozen(arr), true, 'Array should be frozen')
@@ -87,7 +87,7 @@ suite('@superhero/deep/freeze', () =>
     const obj = Object.create(null)
     obj.foo = 'bar'
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj.foo = 'baz' }, TypeError, 'Should not allow modifying properties of objects with null prototype')
     assert.strictEqual(Object.isFrozen(obj), true,      'Object with null prototype should be frozen')
@@ -112,7 +112,7 @@ suite('@superhero/deep/freeze', () =>
       writable      : true
     })
 
-    deepfreeze.freeze(obj)
+    deepfreeze(obj)
 
     assert.throws(() => { obj.nested.baz  = 'changed'   }, TypeError, 'Should not allow modifying nested properties')
     assert.throws(() => { obj[sym]        = 'new value' }, TypeError, 'Should not allow modifying symbol properties')

package/index.js

@@ -1,4 +1,7 @@
-export * from '@superhero/deep/assign'
-export * from '@superhero/deep/clone'
-export * from '@superhero/deep/freeze'
-export * from '@superhero/deep/merge'
+import assign from '@superhero/deep/assign'
+import clone  from '@superhero/deep/clone'
+import freeze from '@superhero/deep/freeze'
+import merge  from '@superhero/deep/merge'
+
+export          { assign, clone, freeze, merge }
+export default  { assign, clone, freeze, merge }

package/index.test.js

@@ -0,0 +1,23 @@
+import assert           from 'assert'
+import { suite, test }  from 'node:test'
+import deep             from '@superhero/deep'
+import { assign, clone, freeze, merge } from '@superhero/deep'
+
+suite('@superhero/deep', () =>
+{
+  test('All functions are accessible as a member to the default import object', () =>
+  {
+    assert.ok('function' === typeof deep.assign,  'Shold export the assign function')
+    assert.ok('function' === typeof deep.clone,   'Shold export the clone function')
+    assert.ok('function' === typeof deep.freeze,  'Shold export the freeze function')
+    assert.ok('function' === typeof deep.merge,   'Shold export the merge function')
+  })
+
+  test('All functions are accessible to import from the default import object', () =>
+  {
+    assert.ok('function' === typeof assign, 'Shold export the assign function')
+    assert.ok('function' === typeof clone,  'Shold export the clone function')
+    assert.ok('function' === typeof freeze, 'Shold export the freeze function')
+    assert.ok('function' === typeof merge,  'Shold export the merge function')
+  })
+})

package/merge.js

@@ -56,97 +56,94 @@
  * @example if array "a" with values [1, 1, 2, 2] is merged with array "b" with
  * values [2, 2, 3, 3], the new array will have values [1, 2, 3].
  */
-export default new class DeepMerge
+export default function merge(a, b, ...c)
 {
-  merge(a, b, ...c)
-  {
-    const 
-      seen    = new WeakSet,
-      output  = this.#merge(a, b, seen)
+  const 
+    seen    = new WeakSet,
+    output  = mergeAandB(a, b, seen)
+
+  return c.length
+  ? merge(output, ...c)
+  : output
+}
 
-    return c.length
-    ? this.merge(output, ...c)
-    : output
+function mergeAandB(a, b, seen)
+{
+  if(b === undefined)
+  {
+    return a
   }
 
-  #merge(a, b, seen)
+  const
+    aType = Object.prototype.toString.call(a),
+    bType = Object.prototype.toString.call(b)
+
+  if('[object Array]' === aType
+  && '[object Array]' === bType)
   {
-    if(b === undefined)
-    {
-      return a
-    }
+    return mergeArray(a, b)
+  }
 
-    const
-      aType = Object.prototype.toString.call(a),
-      bType = Object.prototype.toString.call(b)
+  if('[object Object]' === aType
+  && '[object Object]' === bType)
+  {
+    return mergeObject(a, b, seen)
+  }
 
-    if('[object Array]' === aType
-    && '[object Array]' === bType)
-    {
-      return this.#mergeArray(a, b)
-    }
+  return b
+}
 
-    if('[object Object]' === aType
-    && '[object Object]' === bType)
-    {
-      return this.#mergeObject(a, b, seen)
-    }
+function mergeArray(a, b)
+{
+  return [...new Set(a.concat(b))]
+}
 
+function mergeObject(a, b, seen)
+{
+  if(seen.has(a))
+  {
     return b
   }
 
-  #mergeArray(a, b)
-  {
-    return [...new Set(a.concat(b))]
-  }
+  seen.add(a)
 
-  #mergeObject(a, b, seen)
+  const output = {}
+
+  for(const key of Object.getOwnPropertyNames(a))
   {
-    if(seen.has(a))
+    if(key in b)
     {
-      return b
+      continue
     }
-
-    seen.add(a)
-
-    const output = {}
-
-    for(const key of Object.getOwnPropertyNames(a))
+    else
     {
-      if(key in b)
-      {
-        continue
-      }
-      else
-      {
-        const descriptor = Object.getOwnPropertyDescriptor(a, key)
-        Object.defineProperty(output, key, descriptor)
-      }
+      const descriptor = Object.getOwnPropertyDescriptor(a, key)
+      Object.defineProperty(output, key, descriptor)
     }
+  }
 
-    for(const key of Object.getOwnPropertyNames(b))
+  for(const key of Object.getOwnPropertyNames(b))
+  {
+    if(key in a)
     {
-      if(key in a)
-      {
-        const
-          descriptor_a = Object.getOwnPropertyDescriptor(a, key),
-          descriptor_b = Object.getOwnPropertyDescriptor(b, key)
-  
-        Object.defineProperty(output, key,
-        {
-          configurable : descriptor_a.configurable && descriptor_b.configurable,
-          enumerable   : descriptor_a.enumerable   && descriptor_b.enumerable,
-          writable     : descriptor_a.writable     && descriptor_b.writable,
-          value        : this.#merge(a[key], b[key], seen)
-        })
-      }
-      else
+      const
+        descriptor_a = Object.getOwnPropertyDescriptor(a, key),
+        descriptor_b = Object.getOwnPropertyDescriptor(b, key)
+
+      Object.defineProperty(output, key,
       {
-        const descriptor = Object.getOwnPropertyDescriptor(b, key)
-        Object.defineProperty(output, key, descriptor)
-      }
+        configurable : descriptor_a.configurable && descriptor_b.configurable,
+        enumerable   : descriptor_a.enumerable   && descriptor_b.enumerable,
+        writable     : descriptor_a.writable     && descriptor_b.writable,
+        value        : mergeAandB(a[key], b[key], seen)
+      })
+    }
+    else
+    {
+      const descriptor = Object.getOwnPropertyDescriptor(b, key)
+      Object.defineProperty(output, key, descriptor)
     }
-
-    return output
   }
+
+  return output
 }

package/merge.test.js

@@ -11,7 +11,7 @@ suite('@superhero/deep/merge', () =>
       b         = [2, 3, 4],
       expected  = [1, 2, 3, 4]
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Arrays should merge with unique values')
   })
 
@@ -22,7 +22,7 @@ suite('@superhero/deep/merge', () =>
       b         = [1, 2, 3],
       expected  = [2, 3, 4, 1]
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Order of values should be preserved')
   })
 
@@ -33,7 +33,7 @@ suite('@superhero/deep/merge', () =>
       b         = [],
       expected  = [1, 2, 3]
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Merging with empty array should not alter values')
   })
 
@@ -44,7 +44,7 @@ suite('@superhero/deep/merge', () =>
       b         = [2, 2, 3, 3],
       expected  = [1, 2, 3]
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Duplicate values should be removed')
   })
 
@@ -71,7 +71,7 @@ suite('@superhero/deep/merge', () =>
     })
 
     const 
-      result      = deepmerge.merge(a, b),
+      result      = deepmerge(a, b),
       descriptor  = Object.getOwnPropertyDescriptor(result, 'foo')
 
     assert.strictEqual(descriptor.value,        2,      'Value should prioritize the second object')
@@ -103,7 +103,7 @@ suite('@superhero/deep/merge', () =>
     })
 
     const 
-      result      = deepmerge.merge(a, b),
+      result      = deepmerge(a, b),
       descriptor  = Object.getOwnPropertyDescriptor(result, 'foo')
 
     assert.strictEqual(descriptor.value,        2,      'Value should prioritize the second object')
@@ -119,7 +119,7 @@ suite('@superhero/deep/merge', () =>
       b         = { foo: { baz: 2 } },
       expected  = { foo: { bar: 1, baz: 2 } }
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Nested objects should merge correctly')
   })
 
@@ -132,7 +132,7 @@ suite('@superhero/deep/merge', () =>
     a.self = a
     b.self = b
 
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
 
     assert.strictEqual(result.self, b.self, 'Circular references should not merge further')
   })
@@ -146,8 +146,8 @@ suite('@superhero/deep/merge', () =>
     b.foo.bar = b
 
     const 
-      resultA = deepmerge.merge(a, b),
-      resultB = deepmerge.merge(b, a)
+      resultA = deepmerge(a, b),
+      resultB = deepmerge(b, a)
 
       assert.strictEqual(resultA.foo.bar.foo.bar, b,      'Circular references should not interfare with the merged result')
       assert.strictEqual(resultB.foo.bar.foo.bar, 'baz',  'Circular references should not interfare with the merged result')
@@ -160,7 +160,7 @@ suite('@superhero/deep/merge', () =>
       b         = { foo: 42 },
       expected  = { foo: 42 }
     
-    const result = deepmerge.merge(a, b)
+    const result = deepmerge(a, b)
     assert.deepStrictEqual(result, expected, 'Non-object types should replace with the second value')
   })
 
@@ -172,10 +172,10 @@ suite('@superhero/deep/merge', () =>
       c         = { baz: 3 },
       expected  = { foo: 1, bar: 2, baz: 3 }
 
-    const resultA = deepmerge.merge(a, b, c)
+    const resultA = deepmerge(a, b, c)
     assert.deepStrictEqual(resultA, expected, 'Multiple objects should merge sequentially')
 
-    const resultB = deepmerge.merge(a, b, undefined, c)
+    const resultB = deepmerge(a, b, undefined, c)
     assert.deepStrictEqual(resultB, expected, 'Ignore undefined attributes')
   })
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@superhero/deep",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "A collection of deep structure operations",
   "keywords": ["deep", "assign", "clone", "freeze", "merge"],
   "main": "index.js",