directed-graph-typed 1.53.7 → 1.53.9

package/src/data-structures/binary-tree/avl-tree-multi-map.ts

@@ -6,12 +6,12 @@
  * @license MIT License
  */
 import type {
-  AVLTreeMultiMapNested,
   AVLTreeMultiMapNodeNested,
   AVLTreeMultiMapOptions,
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
   BTNRep,
+  EntryCallback,
   IterationType
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
@@ -64,17 +64,10 @@ export class AVLTreeMultiMap<
     K = any,
     V = any,
     R = object,
-    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>,
-    TREE extends AVLTreeMultiMap<K, V, R, NODE, TREE> = AVLTreeMultiMap<
-      K,
-      V,
-      R,
-      NODE,
-      AVLTreeMultiMapNested<K, V, R, NODE>
-    >
+    NODE extends AVLTreeMultiMapNode<K, V, NODE> = AVLTreeMultiMapNode<K, V, AVLTreeMultiMapNodeNested<K, V>>
   >
-  extends AVLTree<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  extends AVLTree<K, V, R, NODE>
+  implements IBinaryTree<K, V, R, NODE>
 {
   /**
    * The constructor initializes a new AVLTreeMultiMap object with optional initial elements.
@@ -139,15 +132,16 @@ export class AVLTreeMultiMap<
    * @returns a new instance of the AVLTreeMultiMap class, with the specified options, as a TREE
    * object.
    */
-  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>): TREE {
-    return new AVLTreeMultiMap<K, V, R, NODE, TREE>([], {
+  // @ts-ignore
+  override createTree(options?: AVLTreeMultiMapOptions<K, V, R>) {
+    return new AVLTreeMultiMap<K, V, R, NODE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
-    }) as TREE;
+    });
   }
 
   /**
@@ -161,44 +155,6 @@ export class AVLTreeMultiMap<
     return keyNodeEntryOrRaw instanceof AVLTreeMultiMapNode;
   }
 
-  /**
-   * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
-   * a node object.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-   * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
-   * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
-   * `override` function. It represents the value associated with the key in the data structure. If no
-   * value is provided, it will default to `undefined`.
-   * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
-   * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
-   * @returns either a NODE object or undefined.
-   */
-  override keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V,
-    count = 1
-  ): [NODE | undefined, V | undefined] {
-    if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null) return [undefined, undefined];
-    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-
-    if (this.isEntry(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = keyNodeEntryOrRaw;
-      if (key === undefined || key === null) return [undefined, undefined];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue, count), finalValue];
-    }
-
-    if (this.isRaw(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
-      const finalValue = value ?? entryValue;
-      if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
-    }
-
-    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
-
-    return [undefined, undefined];
-  }
-
   /**
    * Time Complexity: O(log n)
    * Space Complexity: O(1)
@@ -217,7 +173,7 @@ export class AVLTreeMultiMap<
    * @returns a boolean value.
    */
   override add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V, count = 1): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value, count);
     if (newNode === undefined) return false;
 
     const orgNodeCount = newNode?.count || 0;
@@ -374,7 +330,8 @@ export class AVLTreeMultiMap<
    * The function overrides the clone method to create a deep copy of a tree object.
    * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
    */
-  override clone(): TREE {
+  // @ts-ignore
+  override clone() {
     const cloned = this.createTree();
     if (this._isMapMode) this.bfs(node => cloned.add(node.key, undefined, node.count));
     else this.bfs(node => cloned.add(node.key, node.value, node.count));
@@ -382,6 +339,76 @@ export class AVLTreeMultiMap<
     return cloned;
   }
 
+  /**
+   * The `map` function in TypeScript overrides the default behavior to create a new AVLTreeMultiMap
+   * with modified entries based on a provided callback.
+   * @param callback - The `callback` parameter is a function that will be called for each entry in the
+   * AVLTreeMultiMap. It takes four arguments:
+   * @param [options] - The `options` parameter in the `override map` function is of type
+   * `AVLTreeMultiMapOptions<MK, MV, MR>`. This parameter allows you to provide additional
+   * configuration options when creating a new `AVLTreeMultiMap` instance within the `map` function.
+   * These options
+   * @param {any} [thisArg] - The `thisArg` parameter in the `override map` function is used to specify
+   * the value of `this` when executing the `callback` function. It allows you to set the context
+   * (value of `this`) for the callback function. This can be useful when you want to access properties
+   * or
+   * @returns The `map` method is returning a new `AVLTreeMultiMap` instance with the entries
+   * transformed by the provided `callback` function. Each entry in the original tree is passed to the
+   * `callback` function along with the index and the original tree itself. The transformed entries are
+   * then added to the new `AVLTreeMultiMap` instance, which is returned at the end.
+   */
+  // @ts-ignore
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: AVLTreeMultiMapOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new AVLTreeMultiMap<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
+    }
+    return newTree;
+  }
+
+  /**
+   * The function `keyValueNodeEntryRawToNodeAndValue` converts a key, value, entry, or raw element into
+   * a node object.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+   * `keyNodeEntryOrRaw` parameter can be of type `R` or `BTNRep<K, V, NODE>`.
+   * @param {V} [value] - The `value` parameter is an optional value that can be passed to the
+   * `override` function. It represents the value associated with the key in the data structure. If no
+   * value is provided, it will default to `undefined`.
+   * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+   * times the key-value pair should be added to the data structure. If not provided, it defaults to 1.
+   * @returns either a NODE object or undefined.
+   */
+  protected override _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V,
+    count = 1
+  ): [NODE | undefined, V | undefined] {
+    if (keyNodeEntryOrRaw === undefined || keyNodeEntryOrRaw === null) return [undefined, undefined];
+    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+
+    if (this.isEntry(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = keyNodeEntryOrRaw;
+      if (key === undefined || key === null) return [undefined, undefined];
+      const finalValue = value ?? entryValue;
+      return [this.createNode(key, finalValue, count), finalValue];
+    }
+
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
+    }
+
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
+
+    return [undefined, undefined];
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/binary-tree/avl-tree.ts

@@ -7,12 +7,12 @@
  */
 import { BST, BSTNode } from './bst';
 import type {
-  AVLTreeNested,
   AVLTreeNodeNested,
   AVLTreeOptions,
   BinaryTreeDeleteResult,
   BSTNOptKeyOrNode,
-  BTNRep
+  BTNRep,
+  EntryCallback
 } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 
@@ -67,11 +67,10 @@ export class AVLTree<
     K = any,
     V = any,
     R = object,
-    NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>,
-    TREE extends AVLTree<K, V, R, NODE, TREE> = AVLTree<K, V, R, NODE, AVLTreeNested<K, V, R, NODE>>
+    NODE extends AVLTreeNode<K, V, NODE> = AVLTreeNode<K, V, AVLTreeNodeNested<K, V>>
   >
-  extends BST<K, V, R, NODE, TREE>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  extends BST<K, V, R, NODE>
+  implements IBinaryTree<K, V, R, NODE>
 {
   /**
    * This is a constructor function for an AVLTree class that initializes the tree with keys, nodes,
@@ -103,21 +102,25 @@ export class AVLTree<
   }
 
   /**
-   * The function creates a new AVL tree with the specified options and returns it.
-   * @param {AVLTreeOptions} [options] - The `options` parameter is an optional object that can be
-   * passed to the `createTree` function. It is used to customize the behavior of the AVL tree that is
-   * being created.
-   * @returns a new AVLTree object.
+   * The function `createTree` in TypeScript overrides the default AVLTree creation with the provided
+   * options.
+   * @param [options] - The `options` parameter in the `createTree` function is an object that contains
+   * configuration options for creating an AVL tree. These options can include properties such as
+   * `iterationType`, `isMapMode`, `specifyComparable`, `toEntryFn`, and `isReverse`. The function
+   * creates a
+   * @returns An AVLTree object is being returned with the specified options and properties inherited
+   * from the current object.
    */
-  override createTree(options?: AVLTreeOptions<K, V, R>): TREE {
-    return new AVLTree<K, V, R, NODE, TREE>([], {
+  // @ts-ignore
+  override createTree(options?: AVLTreeOptions<K, V, R>) {
+    return new AVLTree<K, V, R, NODE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      extractComparable: this._extractComparable,
+      specifyComparable: this._specifyComparable,
       toEntryFn: this._toEntryFn,
       isReverse: this._isReverse,
       ...options
-    }) as TREE;
+    });
   }
 
   /**
@@ -174,6 +177,20 @@ export class AVLTree<
     return deletedResults;
   }
 
+  // @ts-ignore
+  override map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: AVLTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new AVLTree<MK, MV, MR>([], options);
+    let index = 0;
+    for (const [key, value] of this) {
+      newTree.add(callback.call(thisArg, key, value, index++, this));
+    }
+    return newTree;
+  }
+
   /**
    * Time Complexity: O(1)
    * Space Complexity: O(1)

package/src/data-structures/binary-tree/binary-tree.ts

@@ -8,7 +8,6 @@
 
 import {
   BinaryTreeDeleteResult,
-  BinaryTreeNested,
   BinaryTreeNodeNested,
   BinaryTreeOptions,
   BinaryTreePrintOptions,
@@ -105,11 +104,10 @@ export class BinaryTree<
     K = any,
     V = any,
     R = object,
-    NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>,
-    TREE extends BinaryTree<K, V, R, NODE, TREE> = BinaryTree<K, V, R, NODE, BinaryTreeNested<K, V, R, NODE>>
+    NODE extends BinaryTreeNode<K, V, NODE> = BinaryTreeNode<K, V, BinaryTreeNodeNested<K, V>>
   >
   extends IterableEntryBase<K, V | undefined>
-  implements IBinaryTree<K, V, R, NODE, TREE>
+  implements IBinaryTree<K, V, R, NODE>
 {
   iterationType: IterationType = 'ITERATIVE';
 
@@ -172,6 +170,9 @@ export class BinaryTree<
   }
 
   /**
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
    * The function creates a new binary tree node with a specified key and optional value.
    * @param {K} key - The `key` parameter is the key of the node being created in the binary tree.
    * @param {V} [value] - The `value` parameter in the `createNode` function is optional, meaning it is
@@ -185,63 +186,26 @@ export class BinaryTree<
   }
 
   /**
-   * The function creates a binary tree with the specified options.
-   * @param [options] - The `options` parameter in the `createTree` function is an optional parameter
-   * that allows you to provide partial configuration options for creating a binary tree. It is of type
-   * `Partial<BinaryTreeOptions<K, V, R>>`, which means you can pass in an object containing a subset
-   * of properties
-   * @returns A new instance of a binary tree with the specified options is being returned.
+   * Time Complexity: O(1)
+   * Space Complexity: O(1)
+   *
+   * The `createTree` function creates a new binary tree based on the provided options.
+   * @param [options] - The `options` parameter in the `createTree` method is of type
+   * `BinaryTreeOptions<K, V, R>`. This type likely contains configuration options for creating a
+   * binary tree, such as the iteration type, whether the tree is in map mode, and functions for
+   * converting entries.
+   * @returns The `createTree` method is returning an instance of the `BinaryTree` class with the
+   * provided options. The method is creating a new `BinaryTree` object with an empty array as the
+   * initial data, and then setting various options such as `iterationType`, `isMapMode`, and
+   * `toEntryFn` based on the current object's properties and the provided `options`. Finally, it
    */
-  createTree(options?: BinaryTreeOptions<K, V, R>): TREE {
-    return new BinaryTree<K, V, R, NODE, TREE>([], {
+  createTree(options?: BinaryTreeOptions<K, V, R>): typeof this {
+    return new BinaryTree<K, V, R>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
       toEntryFn: this._toEntryFn,
       ...options
-    }) as TREE;
-  }
-
-  /**
-   * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
-   * or returns null.
-   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
-   * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
-   * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
-   * node, an entry
-   * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
-   * an optional parameter of type `V`. It represents the value associated with the key in the node
-   * being created. If a `value` is provided, it will be used when creating the node. If
-   * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
-   * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
-   * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
-   * value.
-   */
-  keyValueNodeEntryRawToNodeAndValue(
-    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
-    value?: V
-  ): [OptNodeOrNull<NODE>, V | undefined] {
-    if (keyNodeEntryOrRaw === undefined) return [undefined, undefined];
-    if (keyNodeEntryOrRaw === null) return [null, undefined];
-
-    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
-
-    if (this.isEntry(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = keyNodeEntryOrRaw;
-      if (key === undefined) return [undefined, undefined];
-      else if (key === null) return [null, undefined];
-      const finalValue = value ?? entryValue;
-      return [this.createNode(key, finalValue), finalValue];
-    }
-
-    if (this.isRaw(keyNodeEntryOrRaw)) {
-      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
-      const finalValue = value ?? entryValue;
-      if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
-    }
-
-    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
-
-    return [undefined, undefined];
+    }) as unknown as typeof this;
   }
 
   /**
@@ -420,7 +384,7 @@ export class BinaryTree<
    * key was found and the node was replaced instead of inserted.
    */
   add(keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R, value?: V): boolean {
-    const [newNode, newValue] = this.keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
+    const [newNode, newValue] = this._keyValueNodeEntryRawToNodeAndValue(keyNodeEntryOrRaw, value);
     if (newNode === undefined) return false;
 
     // If the tree is empty, directly set the new node as the root node
@@ -526,7 +490,7 @@ export class BinaryTree<
    * elements from the other tree.
    * @param anotherTree - `BinaryTree<K, V, R, NODE, TREE>`
    */
-  merge(anotherTree: BinaryTree<K, V, R, NODE, TREE>) {
+  merge(anotherTree: this) {
     this.addMany(anotherTree, []);
   }
 
@@ -1635,7 +1599,7 @@ export class BinaryTree<
    * original tree using breadth-first search (bfs), and adds the nodes to the new tree. If a node in
    * the original tree is null, a null node is added to the cloned tree. If a node
    */
-  clone(): TREE {
+  clone() {
     const cloned = this.createTree();
     this.bfs(
       node => {
@@ -1673,7 +1637,7 @@ export class BinaryTree<
     const newTree = this.createTree();
     let index = 0;
     for (const [key, value] of this) {
-      if (predicate.call(thisArg, value, key, index++, this)) {
+      if (predicate.call(thisArg, key, value, index++, this)) {
         newTree.add([key, value]);
       }
     }
@@ -1684,36 +1648,34 @@ export class BinaryTree<
    * Time Complexity: O(n)
    * Space Complexity: O(n)
    *
-   * The `map` function iterates over key-value pairs in a tree data structure, applies a callback
-   * function to each value, and returns a new tree with the updated values.
-   * @param callback - The `callback` parameter in the `map` method is a function that will be called
-   * on each entry in the tree. It takes four arguments:
-   * @param {any} [thisArg] - The `thisArg` parameter in the `map` function is an optional parameter
-   * that specifies the value to be passed as `this` when executing the callback function. If provided,
-   * the `thisArg` value will be used as the `this` value within the callback function. If `thisArg
-   * @returns The `map` method is returning a new tree with the entries modified by the provided
-   * callback function. Each entry in the original tree is passed to the callback function, and the
-   * result of the callback function is added to the new tree.
+   * The `map` function in TypeScript creates a new BinaryTree by applying a callback function to each
+   * entry in the original BinaryTree.
+   * @param callback - A function that will be called for each entry in the current binary tree. It
+   * takes the key, value (which can be undefined), and an array containing the mapped key and value as
+   * arguments.
+   * @param [options] - The `options` parameter in the `map` method is of type `BinaryTreeOptions<MK,
+   * MV, MR>`. It is an optional parameter that allows you to specify additional options for the binary
+   * tree being created during the mapping process. These options could include things like custom
+   * comparators, initial
+   * @param {any} [thisArg] - The `thisArg` parameter in the `map` method is used to specify the value
+   * of `this` when executing the `callback` function. It allows you to set the context (value of
+   * `this`) within the callback function. If `thisArg` is provided, it will be passed
+   * @returns The `map` function is returning a new `BinaryTree` instance filled with entries that are
+   * the result of applying the provided `callback` function to each entry in the original tree.
    */
-  map(callback: EntryCallback<K, V | undefined, V>, thisArg?: any) {
-    const newTree = this.createTree();
+  map<MK, MV, MR>(
+    callback: EntryCallback<K, V | undefined, [MK, MV]>,
+    options?: BinaryTreeOptions<MK, MV, MR>,
+    thisArg?: any
+  ) {
+    const newTree = new BinaryTree<MK, MV, MR>([], options);
     let index = 0;
     for (const [key, value] of this) {
-      newTree.add([key, callback.call(thisArg, value, key, index++, this)]);
+      newTree.add(callback.call(thisArg, key, value, index++, this));
     }
     return newTree;
   }
 
-  // // TODO Type error, need to return a TREE<NV> that is a value type only for callback function.
-  // // map<NV>(callback: (entry: [K, V | undefined], tree: this) => NV) {
-  // //   const newTree = this.createTree();
-  // //   for (const [key, value] of this) {
-  // //     newTree.add(key, callback([key, value], this));
-  // //   }
-  // //   return newTree;
-  // // }
-  //
-
   /**
    * Time Complexity: O(n)
    * Space Complexity: O(n)
@@ -1743,7 +1705,7 @@ export class BinaryTree<
     if (opts.isShowRedBlackNIL) output += `S for Sentinel Node(NIL)\n`;
 
     const display = (root: OptNodeOrNull<NODE>): void => {
-      const [lines, , ,] = this._displayAux(root, opts);
+      const [lines, ,] = this._displayAux(root, opts);
       let paragraph = '';
       for (const line of lines) {
         paragraph += line + '\n';
@@ -1774,6 +1736,49 @@ export class BinaryTree<
     console.log(this.toVisual(startNode, options));
   }
 
+  /**
+   * The function `keyValueNodeEntryRawToNodeAndValue` converts various input types into a node object
+   * or returns null.
+   * @param {BTNRep<K, V, NODE> | R} keyNodeEntryOrRaw - The
+   * `keyValueNodeEntryRawToNodeAndValue` function takes in a parameter `keyNodeEntryOrRaw`, which
+   * can be of type `BTNRep<K, V, NODE>` or `R`. This parameter represents either a key, a
+   * node, an entry
+   * @param {V} [value] - The `value` parameter in the `keyValueNodeEntryRawToNodeAndValue` function is
+   * an optional parameter of type `V`. It represents the value associated with the key in the node
+   * being created. If a `value` is provided, it will be used when creating the node. If
+   * @returns The `keyValueNodeEntryRawToNodeAndValue` function returns an optional node
+   * (`OptNodeOrNull<NODE>`) based on the input parameters provided. The function checks the type of the
+   * input parameter (`keyNodeEntryOrRaw`) and processes it accordingly to return a node or null
+   * value.
+   */
+  protected _keyValueNodeEntryRawToNodeAndValue(
+    keyNodeEntryOrRaw: BTNRep<K, V, NODE> | R,
+    value?: V
+  ): [OptNodeOrNull<NODE>, V | undefined] {
+    if (keyNodeEntryOrRaw === undefined) return [undefined, undefined];
+    if (keyNodeEntryOrRaw === null) return [null, undefined];
+
+    if (this.isNode(keyNodeEntryOrRaw)) return [keyNodeEntryOrRaw, value];
+
+    if (this.isEntry(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = keyNodeEntryOrRaw;
+      if (key === undefined) return [undefined, undefined];
+      else if (key === null) return [null, undefined];
+      const finalValue = value ?? entryValue;
+      return [this.createNode(key, finalValue), finalValue];
+    }
+
+    if (this.isRaw(keyNodeEntryOrRaw)) {
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue), finalValue];
+    }
+
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value), value];
+
+    return [undefined, undefined];
+  }
+
   /**
    * Time complexity: O(n)
    * Space complexity: O(n)