data-structure-typed 1.47.9 → 1.48.1

package/dist/umd/data-structure-typed.js

@@ -127,6 +127,7 @@ var dataStructureTyped = (() => {
     HashTableNode: () => HashTableNode,
     Heap: () => Heap,
     IterationType: () => IterationType,
+    LinkedHashMap: () => LinkedHashMap,
     LinkedListQueue: () => LinkedListQueue,
     MapEdge: () => MapEdge,
     MapGraph: () => MapGraph,
@@ -517,6 +518,299 @@ var dataStructureTyped = (() => {
 
   // src/data-structures/hash/hash-map.ts
   var HashMap = class _HashMap {
+    /**
+     * The constructor function initializes a new instance of a class with optional elements and options.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs `[K, V]`. It
+     * is optional and defaults to an empty array `[]`. This parameter is used to initialize the map with
+     * key-value pairs.
+     * @param [options] - The `options` parameter is an optional object that can contain additional
+     * configuration options for the constructor. In this case, it has one property:
+     */
+    constructor(elements = [], options) {
+      __publicField(this, "_store", {});
+      __publicField(this, "_objMap", /* @__PURE__ */ new Map());
+      __publicField(this, "_size", 0);
+      __publicField(this, "_hashFn", (key) => String(key));
+      if (options) {
+        const { hashFn } = options;
+        if (hashFn) {
+          this._hashFn = hashFn;
+        }
+      }
+      if (elements) {
+        this.setMany(elements);
+      }
+    }
+    get size() {
+      return this._size;
+    }
+    isEmpty() {
+      return this.size === 0;
+    }
+    clear() {
+      this._store = {};
+      this._objMap.clear();
+      this._size = 0;
+    }
+    /**
+     * The `set` function adds a key-value pair to a map-like data structure, incrementing the size if
+     * the key is not already present.
+     * @param {K} key - The key parameter is the key used to identify the value in the data structure. It
+     * can be of any type, but if it is an object, it will be stored in a Map, otherwise it will be
+     * stored in a regular JavaScript object.
+     * @param {V} value - The value parameter represents the value that you want to associate with the
+     * key in the data structure.
+     */
+    set(key, value) {
+      if (this._isObjKey(key)) {
+        if (!this._objMap.has(key)) {
+          this._size++;
+        }
+        this._objMap.set(key, value);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        if (this._store[strKey] === void 0) {
+          this._size++;
+        }
+        this._store[strKey] = { key, value };
+      }
+    }
+    /**
+     * The function "setMany" sets multiple key-value pairs in a map.
+     * @param elements - The `elements` parameter is an iterable containing key-value pairs. Each
+     * key-value pair is represented as an array with two elements: the key and the value.
+     */
+    setMany(elements) {
+      for (const [key, value] of elements)
+        this.set(key, value);
+    }
+    /**
+     * The `get` function retrieves a value from a map based on a given key, either from an object map or
+     * a string map.
+     * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
+     * of any type, but it should be compatible with the key type used when the map was created.
+     * @returns The method `get(key: K)` returns a value of type `V` if the key exists in the `_objMap`
+     * or `_store`, otherwise it returns `undefined`.
+     */
+    get(key) {
+      var _a;
+      if (this._isObjKey(key)) {
+        return this._objMap.get(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        return (_a = this._store[strKey]) == null ? void 0 : _a.value;
+      }
+    }
+    /**
+     * The `has` function checks if a given key exists in the `_objMap` or `_store` based on whether it
+     * is an object key or not.
+     * @param {K} key - The parameter "key" is of type K, which means it can be any type.
+     * @returns The `has` method is returning a boolean value.
+     */
+    has(key) {
+      if (this._isObjKey(key)) {
+        return this._objMap.has(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        return strKey in this._store;
+      }
+    }
+    /**
+     * The `delete` function removes an element from a map-like data structure based on the provided key.
+     * @param {K} key - The `key` parameter is the key of the element that you want to delete from the
+     * data structure.
+     * @returns The `delete` method returns a boolean value. It returns `true` if the key was
+     * successfully deleted from the map, and `false` if the key was not found in the map.
+     */
+    delete(key) {
+      if (this._isObjKey(key)) {
+        if (this._objMap.has(key)) {
+          this._size--;
+        }
+        return this._objMap.delete(key);
+      } else {
+        const strKey = this._getNoObjKey(key);
+        if (strKey in this._store) {
+          delete this._store[strKey];
+          this._size--;
+          return true;
+        }
+        return false;
+      }
+    }
+    /**
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
+     */
+    *[Symbol.iterator]() {
+      for (const node of Object.values(this._store)) {
+        yield [node.key, node.value];
+      }
+      for (const node of this._objMap) {
+        yield node;
+      }
+    }
+    /**
+     * The function returns an iterator that yields key-value pairs from the object.
+     */
+    *entries() {
+      for (const item of this) {
+        yield item;
+      }
+    }
+    /**
+     * The function `keys()` returns an iterator that yields all the keys of the object.
+     */
+    *keys() {
+      for (const [key] of this) {
+        yield key;
+      }
+    }
+    *values() {
+      for (const [, value] of this) {
+        yield value;
+      }
+    }
+    /**
+     * The `every` function checks if every element in a HashMap satisfies a given predicate function.
+     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+     * index, and map. It is used to test each element in the map against a condition. If the predicate
+     * function returns false for any element, the every() method will return false. If the predicate
+     * function returns true for all
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The method is returning a boolean value. It returns true if the predicate function
+     * returns true for every element in the map, and false otherwise.
+     */
+    every(predicate, thisArg) {
+      let index = 0;
+      for (const [key, value] of this) {
+        if (!predicate.call(thisArg, value, key, index++, this)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    /**
+     * The "some" function checks if at least one element in a HashMap satisfies a given predicate.
+     * @param predicate - The `predicate` parameter is a function that takes four arguments: `value`,
+     * `key`, `index`, and `map`. It is used to determine whether a specific condition is met for a given
+     * key-value pair in the `HashMap`.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns a boolean value. It returns true if the predicate function returns true for any element
+     * in the map, and false otherwise.
+     */
+    some(predicate, thisArg) {
+      let index = 0;
+      for (const [key, value] of this) {
+        if (predicate.call(thisArg, value, key, index++, this)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    /**
+     * The `forEach` function iterates over the elements of a HashMap and applies a callback function to
+     * each element.
+     * @param callbackfn - A function that will be called for each key-value pair in the HashMap. It
+     * takes four parameters:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value inside the `callbackfn` function. If `thisArg
+     */
+    forEach(callbackfn, thisArg) {
+      let index = 0;
+      for (const [key, value] of this) {
+        callbackfn.call(thisArg, value, key, index++, this);
+      }
+    }
+    /**
+     * The `map` function in TypeScript creates a new HashMap by applying a callback function to each
+     * key-value pair in the original HashMap.
+     * @param callbackfn - The callback function that will be called for each key-value pair in the
+     * HashMap. It takes four parameters:
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `callbackfn` function. If `thisArg` is provided, it will
+     * be passed as the `this` value to the `callbackfn` function. If `thisArg
+     * @returns The `map` method is returning a new `HashMap` object with the transformed values based on
+     * the provided callback function.
+     */
+    map(callbackfn, thisArg) {
+      const resultMap = new _HashMap();
+      let index = 0;
+      for (const [key, value] of this) {
+        resultMap.set(key, callbackfn.call(thisArg, value, key, index++, this));
+      }
+      return resultMap;
+    }
+    /**
+     * The `filter` function creates a new HashMap containing key-value pairs from the original HashMap
+     * that satisfy a given predicate function.
+     * @param predicate - The predicate parameter is a function that takes four arguments: value, key,
+     * index, and map. It is used to determine whether an element should be included in the filtered map
+     * or not. The function should return a boolean value - true if the element should be included, and
+     * false otherwise.
+     * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
+     * to be used as `this` when executing the `predicate` function. If `thisArg` is provided, it will be
+     * passed as the `this` value to the `predicate` function. If `thisArg` is
+     * @returns The `filter` method is returning a new `HashMap` object that contains the key-value pairs
+     * from the original `HashMap` that pass the provided `predicate` function.
+     */
+    filter(predicate, thisArg) {
+      const filteredMap = new _HashMap();
+      let index = 0;
+      for (const [key, value] of this) {
+        if (predicate.call(thisArg, value, key, index++, this)) {
+          filteredMap.set(key, value);
+        }
+      }
+      return filteredMap;
+    }
+    /**
+     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * each element, accumulating a single value.
+     * @param callbackfn - The callback function that will be called for each element in the HashMap. It
+     * takes five parameters:
+     * @param {U} initialValue - The initialValue parameter is the initial value of the accumulator. It
+     * is the value that will be used as the first argument of the callback function when reducing the
+     * elements of the map.
+     * @returns The `reduce` method is returning the final value of the accumulator after iterating over
+     * all the elements in the `HashMap`.
+     */
+    reduce(callbackfn, initialValue) {
+      let accumulator = initialValue;
+      let index = 0;
+      for (const [key, value] of this) {
+        accumulator = callbackfn(accumulator, value, key, index++, this);
+      }
+      return accumulator;
+    }
+    print() {
+      console.log([...this.entries()]);
+    }
+    _isObjKey(key) {
+      const keyType = typeof key;
+      return (keyType === "object" || keyType === "function") && key !== null;
+    }
+    _getNoObjKey(key) {
+      const keyType = typeof key;
+      let strKey;
+      if (keyType !== "string" && keyType !== "number" && keyType !== "symbol") {
+        strKey = this._hashFn(key);
+      } else {
+        if (keyType === "number") {
+          strKey = key;
+        } else {
+          strKey = key;
+        }
+      }
+      return strKey;
+    }
+  };
+  var LinkedHashMap = class _LinkedHashMap {
     constructor(elements, options = {
       hashFn: (key) => String(key),
       objHashFn: (key) => key
@@ -604,39 +898,65 @@ var dataStructureTyped = (() => {
      */
     set(key, value) {
       let node;
+      const isNewKey = !this.has(key);
       if (isWeakKey(key)) {
         const hash = this._objHashFn(key);
         node = this._objMap.get(hash);
-        if (node) {
-          node.value = value;
-        } else {
+        if (!node && isNewKey) {
           node = { key: hash, value, prev: this._tail, next: this._sentinel };
           this._objMap.set(hash, node);
+        } else if (node) {
+          node.value = value;
         }
       } else {
         const hash = this._hashFn(key);
         node = this._noObjMap[hash];
-        if (node) {
+        if (!node && isNewKey) {
+          this._noObjMap[hash] = node = { key, value, prev: this._tail, next: this._sentinel };
+        } else if (node) {
           node.value = value;
+        }
+      }
+      if (node && isNewKey) {
+        if (this._size === 0) {
+          this._head = node;
+          this._sentinel.next = node;
         } else {
-          this._noObjMap[hash] = node = {
-            key,
-            value,
-            prev: this._tail,
-            next: this._sentinel
-          };
+          this._tail.next = node;
+          node.prev = this._tail;
         }
+        this._tail = node;
+        this._sentinel.prev = node;
+        this._size++;
       }
-      if (this._size === 0) {
-        this._head = node;
-        this._sentinel.next = node;
+      return this._size;
+    }
+    has(key) {
+      if (isWeakKey(key)) {
+        const hash = this._objHashFn(key);
+        return this._objMap.has(hash);
       } else {
-        this._tail.next = node;
+        const hash = this._hashFn(key);
+        return hash in this._noObjMap;
       }
-      this._tail = node;
-      this._sentinel.prev = node;
-      this._size++;
-      return this._size;
+    }
+    setMany(entries) {
+      for (const entry of entries) {
+        const [key, value] = entry;
+        this.set(key, value);
+      }
+    }
+    keys() {
+      const keys = [];
+      for (const [key] of this)
+        keys.push(key);
+      return keys;
+    }
+    values() {
+      const values = [];
+      for (const [, value] of this)
+        values.push(value);
+      return values;
     }
     /**
      * Time Complexity: O(1)
@@ -751,14 +1071,22 @@ var dataStructureTyped = (() => {
       this._size = 0;
       this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
     }
+    clone() {
+      const cloned = new _LinkedHashMap([], { hashFn: this._hashFn, objHashFn: this._objHashFn });
+      for (const entry of this) {
+        const [key, value] = entry;
+        cloned.set(key, value);
+      }
+      return cloned;
+    }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
-     * The `forEach` function iterates over each element in a HashMap and executes a callback function on
+     * The `forEach` function iterates over each element in a LinkedHashMap and executes a callback function on
      * each element.
      * @param callback - The callback parameter is a function that will be called for each element in the
-     * HashMap. It takes three arguments:
+     * LinkedHashMap. It takes three arguments:
      */
     forEach(callback) {
       let index = 0;
@@ -769,15 +1097,15 @@ var dataStructureTyped = (() => {
       }
     }
     /**
-     * The `filter` function takes a predicate function and returns a new HashMap containing only the
+     * The `filter` function takes a predicate function and returns a new LinkedHashMap containing only the
      * key-value pairs that satisfy the predicate.
      * @param predicate - The `predicate` parameter is a function that takes two arguments: `element` and
      * `map`.
-     * @returns a new HashMap object that contains the key-value pairs from the original HashMap that
+     * @returns a new LinkedHashMap object that contains the key-value pairs from the original LinkedHashMap that
      * satisfy the given predicate function.
      */
     filter(predicate) {
-      const filteredMap = new _HashMap();
+      const filteredMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
         if (predicate([key, value], index, this)) {
@@ -788,14 +1116,14 @@ var dataStructureTyped = (() => {
       return filteredMap;
     }
     /**
-     * The `map` function takes a callback function and returns a new HashMap with the values transformed
+     * The `map` function takes a callback function and returns a new LinkedHashMap with the values transformed
      * by the callback.
      * @param callback - The `callback` parameter is a function that takes two arguments: `element` and
      * `map`.
-     * @returns a new HashMap object with the values mapped according to the provided callback function.
+     * @returns a new LinkedHashMap object with the values mapped according to the provided callback function.
      */
     map(callback) {
-      const mappedMap = new _HashMap();
+      const mappedMap = new _LinkedHashMap();
       let index = 0;
       for (const [key, value] of this) {
         const newValue = callback([key, value], index, this);
@@ -805,16 +1133,16 @@ var dataStructureTyped = (() => {
       return mappedMap;
     }
     /**
-     * The `reduce` function iterates over the elements of a HashMap and applies a callback function to
+     * The `reduce` function iterates over the elements of a LinkedHashMap and applies a callback function to
      * each element, accumulating a single value.
      * @param callback - The callback parameter is a function that takes three arguments: accumulator,
-     * element, and map. It is called for each element in the HashMap and is used to accumulate a single
+     * element, and map. It is called for each element in the LinkedHashMap and is used to accumulate a single
      * result.
      * @param {A} initialValue - The `initialValue` parameter is the initial value of the accumulator. It
      * is the value that will be passed as the first argument to the `callback` function when reducing
      * the elements of the map.
      * @returns The `reduce` function is returning the final value of the accumulator after iterating
-     * over all the elements in the HashMap and applying the callback function to each element.
+     * over all the elements in the LinkedHashMap and applying the callback function to each element.
      */
     reduce(callback, initialValue) {
       let accumulator = initialValue;
@@ -826,7 +1154,7 @@ var dataStructureTyped = (() => {
       return accumulator;
     }
     /**
-     * Time Complexity: O(n), where n is the number of elements in the HashMap.
+     * Time Complexity: O(n), where n is the number of elements in the LinkedHashMap.
      * Space Complexity: O(1)
      *
      * The above function is an iterator that yields key-value pairs from a linked list.
@@ -6981,6 +7309,45 @@ var dataStructureTyped = (() => {
     createTree(options) {
       return new _BinaryTree([], __spreadValues({ iterationType: this.iterationType }, options));
     }
+    /**
+     * The function "isNode" checks if an exemplar is an instance of the BinaryTreeNode class.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the class N.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof BinaryTreeNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar of a binary tree node into an actual node
+     * object.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing the exemplar parameter of the
+     * function. It can be any type.
+     * @returns a value of type `N` (which represents a node), or `null`, or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+      if (exemplar === void 0)
+        return;
+      let node;
+      if (exemplar === null) {
+        node = null;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0) {
+          return;
+        } else if (key === null) {
+          node = null;
+        } else {
+          node = this.createNode(key, value);
+        }
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * The function checks if a given value is an entry in a binary tree node.
      * @param kne - BTNodeExemplar<V, N> - A generic type representing a node in a binary tree. It has
@@ -7003,16 +7370,19 @@ var dataStructureTyped = (() => {
      * @returns The function `add` returns the inserted node (`N`), `null`, or `undefined`.
      */
     add(keyOrNodeOrEntry) {
-      let inserted, needInsert;
-      const _bfs = (root, newNode) => {
+      let inserted;
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
+        return;
+      const _bfs = (root, newNode2) => {
         const queue = new Queue([root]);
         while (queue.size > 0) {
           const cur = queue.shift();
-          if (newNode && cur.key === newNode.key) {
-            this._replaceNode(cur, newNode);
-            return newNode;
+          if (newNode2 && cur.key === newNode2.key) {
+            this._replaceNode(cur, newNode2);
+            return newNode2;
           }
-          const inserted2 = this._addTo(newNode, cur);
+          const inserted2 = this._addTo(newNode2, cur);
           if (inserted2 !== void 0)
             return inserted2;
           if (cur.left)
@@ -7021,29 +7391,11 @@ var dataStructureTyped = (() => {
             queue.push(cur.right);
         }
       };
-      if (keyOrNodeOrEntry === null) {
-        needInsert = null;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        needInsert = this.createNode(keyOrNodeOrEntry);
-      } else if (keyOrNodeOrEntry instanceof BinaryTreeNode) {
-        needInsert = keyOrNodeOrEntry;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0) {
-          return;
-        } else if (key === null) {
-          needInsert = null;
-        } else {
-          needInsert = this.createNode(key, value);
-        }
-      } else {
-        return;
-      }
       if (this.root) {
-        inserted = _bfs(this.root, needInsert);
+        inserted = _bfs(this.root, newNode);
       } else {
-        this._setRoot(needInsert);
-        if (needInsert) {
+        this._setRoot(newNode);
+        if (newNode) {
           this._size = 1;
         } else {
           this._size = 0;
@@ -8194,6 +8546,60 @@ var dataStructureTyped = (() => {
       }
       return ans;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "keys" returns an array of keys from a given object.
+     * @returns an array of BTNKey objects.
+     */
+    keys() {
+      const keys = [];
+      for (const entry of this) {
+        keys.push(entry[0]);
+      }
+      return keys;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The function "values" returns an array of values from a map-like object.
+     * @returns The `values()` method is returning an array of values (`V`) from the entries in the
+     * object.
+     */
+    values() {
+      const values = [];
+      for (const entry of this) {
+        values.push(entry[1]);
+      }
+      return values;
+    }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a new tree object and copies all the nodes from the original tree to
+     * the new tree.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add([node.key, node.value]));
+      return cloned;
+    }
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)
@@ -8549,6 +8955,40 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of BSTNode.
+     * @param exemplar - The `exemplar` parameter is a variable of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the BSTNode class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof BSTNode;
+    }
+    /**
+     * The function `exemplarToNode` takes an exemplar and returns a corresponding node if the exemplar
+     * is valid, otherwise it returns undefined.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a variable `node` which is of type `N` or `undefined`.
+     */
+    exemplarToNode(exemplar) {
+      let node;
+      if (exemplar === null || exemplar === void 0) {
+        return;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value);
+        }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * Time Complexity: O(log n) - Average case for a balanced tree. In the worst case (unbalanced tree), it can be O(n).
      * Space Complexity: O(1) - Constant space is used.
@@ -8564,24 +9004,9 @@ var dataStructureTyped = (() => {
      * (`keyOrNodeOrEntry`) is null, undefined, or does not match any of the expected types.
      */
     add(keyOrNodeOrEntry) {
-      if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
-        return void 0;
-      }
-      let newNode;
-      if (keyOrNodeOrEntry instanceof BSTNode) {
-        newNode = keyOrNodeOrEntry;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        newNode = this.createNode(keyOrNodeOrEntry);
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          newNode = this.createNode(key, value);
-        }
-      } else {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
         return;
-      }
       if (this.root === void 0) {
         this._setRoot(newNode);
         this._size++;
@@ -9545,6 +9970,14 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of AVLTreeNode.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the AVLTreeNode class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof AVLTreeNode;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (BST) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -9966,70 +10399,93 @@ var dataStructureTyped = (() => {
       }, options));
     }
     /**
-     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
-     * Space Complexity: O(1)
+     * The function checks if an exemplar is an instance of the RedBlackTreeNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the RedBlackTreeNode
+     * class.
      */
+    isNode(exemplar) {
+      return exemplar instanceof RedBlackTreeNode;
+    }
     /**
-     * The function adds a node to a Red-Black Tree data structure.
-     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
-     * @returns The method `add` returns either an instance of `N` (the node that was added) or
-     * `undefined`.
+     * The function `exemplarToNode` takes an exemplar and returns a node if the exemplar is valid,
+     * otherwise it returns undefined.
+     * @param exemplar - BTNodeExemplar<V, N> - A generic type representing an exemplar of a binary tree
+     * node. It can be either a node itself, an entry (key-value pair), a node key, or any other value
+     * that is not a valid exemplar.
+     * @returns a variable `node` which is of type `N | undefined`.
      */
-    add(keyOrNodeOrEntry) {
+    exemplarToNode(exemplar) {
       let node;
-      if (this.isNodeKey(keyOrNodeOrEntry)) {
-        node = this.createNode(keyOrNodeOrEntry, void 0, 1 /* RED */);
-      } else if (keyOrNodeOrEntry instanceof RedBlackTreeNode) {
-        node = keyOrNodeOrEntry;
-      } else if (keyOrNodeOrEntry === null || keyOrNodeOrEntry === void 0) {
+      if (exemplar === null || exemplar === void 0) {
         return;
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
         if (key === void 0 || key === null) {
           return;
         } else {
           node = this.createNode(key, value, 1 /* RED */);
         }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar, void 0, 1 /* RED */);
       } else {
         return;
       }
-      node.left = this.Sentinel;
-      node.right = this.Sentinel;
+      return node;
+    }
+    /**
+     * Time Complexity: O(log n) on average (where n is the number of nodes in the tree)
+     * Space Complexity: O(1)
+     */
+    /**
+     * The function adds a node to a Red-Black Tree data structure.
+     * @param keyOrNodeOrEntry - The `keyOrNodeOrEntry` parameter can be one of the following:
+     * @returns The method `add` returns either an instance of `N` (the node that was added) or
+     * `undefined`.
+     */
+    add(keyOrNodeOrEntry) {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry);
+      if (newNode === void 0)
+        return;
+      newNode.left = this.Sentinel;
+      newNode.right = this.Sentinel;
       let y = void 0;
       let x = this.root;
       while (x !== this.Sentinel) {
         y = x;
         if (x) {
-          if (node.key < x.key) {
+          if (newNode.key < x.key) {
             x = x.left;
-          } else if (node.key > x.key) {
+          } else if (newNode.key > x.key) {
             x = x == null ? void 0 : x.right;
           } else {
-            if (node !== x) {
-              this._replaceNode(x, node);
+            if (newNode !== x) {
+              this._replaceNode(x, newNode);
             }
             return;
           }
         }
       }
-      node.parent = y;
+      newNode.parent = y;
       if (y === void 0) {
-        this._setRoot(node);
-      } else if (node.key < y.key) {
-        y.left = node;
+        this._setRoot(newNode);
+      } else if (newNode.key < y.key) {
+        y.left = newNode;
       } else {
-        y.right = node;
+        y.right = newNode;
       }
-      if (node.parent === void 0) {
-        node.color = 0 /* BLACK */;
+      if (newNode.parent === void 0) {
+        newNode.color = 0 /* BLACK */;
         this._size++;
         return;
       }
-      if (node.parent.parent === void 0) {
+      if (newNode.parent.parent === void 0) {
         this._size++;
         return;
       }
-      this._fixInsert(node);
+      this._fixInsert(newNode);
       this._size++;
     }
     /**
@@ -10480,6 +10936,43 @@ var dataStructureTyped = (() => {
         comparator: this.comparator
       }, options));
     }
+    /**
+     * The function checks if an exemplar is an instance of the TreeMultimapNode class.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`.
+     * @returns a boolean value indicating whether the exemplar is an instance of the TreeMultimapNode
+     * class.
+     */
+    isNode(exemplar) {
+      return exemplar instanceof TreeMultimapNode;
+    }
+    /**
+     * The function `exemplarToNode` converts an exemplar object into a node object.
+     * @param exemplar - The `exemplar` parameter is of type `BTNodeExemplar<V, N>`, where `V` represents
+     * the value type and `N` represents the node type.
+     * @param [count=1] - The `count` parameter is an optional parameter that specifies the number of
+     * times the node should be created. If not provided, it defaults to 1.
+     * @returns a value of type `N` (the generic type parameter) or `undefined`.
+     */
+    exemplarToNode(exemplar, count = 1) {
+      let node;
+      if (exemplar === void 0 || exemplar === null) {
+        return;
+      } else if (this.isNode(exemplar)) {
+        node = exemplar;
+      } else if (this.isEntry(exemplar)) {
+        const [key, value] = exemplar;
+        if (key === void 0 || key === null) {
+          return;
+        } else {
+          node = this.createNode(key, value, count);
+        }
+      } else if (this.isNodeKey(exemplar)) {
+        node = this.createNode(exemplar, void 0, count);
+      } else {
+        return;
+      }
+      return node;
+    }
     /**
      * Time Complexity: O(log n) - logarithmic time, where "n" is the number of nodes in the tree. The add method of the superclass (AVLTree) has logarithmic time complexity.
      * Space Complexity: O(1) - constant space, as it doesn't use additional data structures that scale with input size.
@@ -10497,23 +10990,9 @@ var dataStructureTyped = (() => {
      * @returns either a node (`N`) or `undefined`.
      */
     add(keyOrNodeOrEntry, count = 1) {
-      let newNode;
-      if (keyOrNodeOrEntry === void 0 || keyOrNodeOrEntry === null) {
-        return;
-      } else if (keyOrNodeOrEntry instanceof TreeMultimapNode) {
-        newNode = keyOrNodeOrEntry;
-      } else if (this.isNodeKey(keyOrNodeOrEntry)) {
-        newNode = this.createNode(keyOrNodeOrEntry, void 0, count);
-      } else if (this.isEntry(keyOrNodeOrEntry)) {
-        const [key, value] = keyOrNodeOrEntry;
-        if (key === void 0 || key === null) {
-          return;
-        } else {
-          newNode = this.createNode(key, value, count);
-        }
-      } else {
+      const newNode = this.exemplarToNode(keyOrNodeOrEntry, count);
+      if (newNode === void 0)
         return;
-      }
       const orgNodeCount = (newNode == null ? void 0 : newNode.count) || 0;
       const inserted = super.add(newNode);
       if (inserted) {
@@ -10674,6 +11153,22 @@ var dataStructureTyped = (() => {
       super.clear();
       this._count = 0;
     }
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     */
+    /**
+     * Time complexity: O(n)
+     * Space complexity: O(n)
+     *
+     * The `clone` function creates a deep copy of a tree object.
+     * @returns The `clone()` method is returning a cloned instance of the `TREE` object.
+     */
+    clone() {
+      const cloned = this.createTree();
+      this.bfs((node) => cloned.add([node.key, node.value], node.count));
+      return cloned;
+    }
     /**
      * Time Complexity: O(1) - constant time, as it performs basic pointer assignments.
      * Space Complexity: O(1) - constant space, as it only uses a constant amount of memory.