data-structure-typed 2.0.1 → 2.0.3

package/dist/individuals/hash/hash-map.mjs

@@ -1,1040 +0,0 @@
-// src/data-structures/base/iterable-entry-base.ts
-var IterableEntryBase = class {
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function is an implementation of the Symbol.iterator method that returns an iterable iterator.
-   * @param {any[]} args - The `args` parameter in the code snippet represents a rest parameter. It
-   * allows the function to accept any number of arguments as an array. In this case, the `args`
-   * parameter is used to pass any additional arguments to the `_getIterator` method.
-   */
-  *[Symbol.iterator](...args) {
-    yield* this._getIterator(...args);
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields key-value pairs from the object, where the value can
-   * be undefined.
-   */
-  *entries() {
-    for (const item of this) {
-      yield item;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields the keys of a data structure.
-   */
-  *keys() {
-    for (const item of this) {
-      yield item[0];
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The function returns an iterator that yields the values of a collection.
-   */
-  *values() {
-    for (const item of this) {
-      yield item[1];
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `every` function checks if every element in a collection satisfies a given condition.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
-   * met for the current element in the iteration.
-   * @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 first argument to the `predicate` function. If `thisArg` is not provided
-   * @returns The `every` method is returning a boolean value. It returns `true` if every element in
-   * the collection satisfies the provided predicate function, and `false` otherwise.
-   */
-  every(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (!predicate.call(thisArg, item[0], item[1], index++, this)) {
-        return false;
-      }
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The "some" function iterates over a collection and returns true if at least one element satisfies
-   * a given predicate.
-   * @param predicate - The `predicate` parameter is a callback function that takes three arguments:
-   * `value`, `key`, and `index`. It should return a boolean value indicating whether the condition is
-   * met for the current element in the iteration.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that specifies the value
-   * to be used as the `this` value when executing the `predicate` function. If `thisArg` is provided,
-   * it will be passed as the first argument to the `predicate` function. If `thisArg` is
-   * @returns a boolean value. It returns true if the predicate function returns true for any pair in
-   * the collection, and false otherwise.
-   */
-  some(predicate, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      if (predicate.call(thisArg, item[0], item[1], index++, this)) {
-        return true;
-      }
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `forEach` function iterates over each key-value pair in a collection and executes a callback
-   * function for each pair.
-   * @param callbackfn - The callback function that will be called for each element in the collection.
-   * It takes four parameters: the value of the current element, the key of the current element, the
-   * index of the current element, and the collection itself.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-   * specify the value of `this` within the callback function. If `thisArg` is provided, it will be
-   * used as the `this` value when calling the callback function. If `thisArg` is not provided, `
-   */
-  forEach(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      callbackfn.call(thisArg, key, value, index++, this);
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `find` function iterates over the entries of a collection and returns the first value for
-   * which the callback function returns true.
-   * @param callbackfn - The callback function that will be called for each entry in the collection. It
-   * takes three arguments: the value of the entry, the key of the entry, and the index of the entry in
-   * the collection. It should return a boolean value indicating whether the current entry matches the
-   * desired condition.
-   * @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 method `find` returns the value of the first element in the iterable that satisfies
-   * the provided callback function. If no element satisfies the callback function, `undefined` is
-   * returned.
-   */
-  find(callbackfn, thisArg) {
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      if (callbackfn.call(thisArg, key, value, index++, this)) return item;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given key exists in a collection.
-   * @param {K} key - The parameter "key" is of type K, which means it can be any type. It represents
-   * the key that we want to check for existence in the data structure.
-   * @returns a boolean value. It returns true if the key is found in the collection, and false
-   * otherwise.
-   */
-  has(key) {
-    for (const item of this) {
-      const [itemKey] = item;
-      if (itemKey === key) return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given value exists in a collection.
-   * @param {V} value - The parameter "value" is the value that we want to check if it exists in the
-   * collection.
-   * @returns a boolean value, either true or false.
-   */
-  hasValue(value) {
-    for (const [, elementValue] of this) {
-      if (elementValue === value) return true;
-    }
-    return false;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `get` function retrieves the value associated with a given key from a collection.
-   * @param {K} key - K (the type of the key) - This parameter represents the key that is being
-   * searched for in the collection.
-   * @returns The `get` method returns the value associated with the specified key if it exists in the
-   * collection, otherwise it returns `undefined`.
-   */
-  get(key) {
-    for (const item of this) {
-      const [itemKey, value] = item;
-      if (itemKey === key) return value;
-    }
-    return;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `reduce` function iterates over key-value pairs and applies a callback function to each pair,
-   * accumulating a single value.
-   * @param callbackfn - The callback function that will be called for each element in the collection.
-   * It takes four arguments: the current accumulator value, the current value of the element, the key
-   * of the element, and the index of the element in the collection. It should return the updated
-   * accumulator value.
-   * @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 to the `callbackfn` function when reducing
-   * the elements of the collection.
-   * @returns The `reduce` method is returning the final value of the accumulator after iterating over
-   * all the elements in the collection.
-   */
-  reduce(callbackfn, initialValue) {
-    let accumulator = initialValue;
-    let index = 0;
-    for (const item of this) {
-      const [key, value] = item;
-      accumulator = callbackfn(accumulator, value, key, index++, this);
-    }
-    return accumulator;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The print function logs the elements of an array to the console.
-   */
-  toVisual() {
-    return [...this];
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The print function logs the elements of an array to the console.
-   */
-  print() {
-    console.log(this.toVisual());
-  }
-};
-
-// src/utils/utils.ts
-var THUNK_SYMBOL = Symbol("thunk");
-var rangeCheck = (index, min, max, message = "Index out of bounds.") => {
-  if (index < min || index > max) throw new RangeError(message);
-};
-var isWeakKey = (input) => {
-  const inputType = typeof input;
-  return inputType === "object" && input !== null || inputType === "function";
-};
-
-// src/data-structures/hash/hash-map.ts
-var HashMap = class _HashMap extends IterableEntryBase {
-  /**
-   * The constructor function initializes a HashMap object with an optional initial collection and
-   * options.
-   * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
-   * `T`. It is an optional parameter and its default value is an empty array `[]`.
-   * @param [options] - The `options` parameter is an optional object that can contain two properties:
-   */
-  constructor(entryOrRawElements = [], options) {
-    super();
-    if (options) {
-      const { hashFn, toEntryFn } = options;
-      if (hashFn) this._hashFn = hashFn;
-      if (toEntryFn) this._toEntryFn = toEntryFn;
-    }
-    if (entryOrRawElements) {
-      this.setMany(entryOrRawElements);
-    }
-  }
-  _store = {};
-  /**
-   * The function returns the store object, which is a dictionary of HashMapStoreItem objects.
-   * @returns The store property is being returned. It is a dictionary-like object with string keys and
-   * values of type HashMapStoreItem<K, V>.
-   */
-  get store() {
-    return this._store;
-  }
-  _objMap = /* @__PURE__ */ new Map();
-  /**
-   * The function returns the object map.
-   * @returns The `objMap` property is being returned, which is a `Map` object with keys of type
-   * `object` and values of type `V`.
-   */
-  get objMap() {
-    return this._objMap;
-  }
-  _toEntryFn;
-  /**
-   * The function returns the value of the _toEntryFn property.
-   * @returns The function being returned is `this._toEntryFn`.
-   */
-  get toEntryFn() {
-    return this._toEntryFn;
-  }
-  _size = 0;
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object, which is a number.
-   */
-  get size() {
-    return this._size;
-  }
-  _hashFn = (key) => String(key);
-  /**
-   * The hasFn function is a function that takes in an item and returns a boolean
-   * indicating whether the item is contained within the hash table.
-   *
-   * @return The hash function
-   */
-  get hashFn() {
-    return this._hashFn;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given element is an array with exactly two elements.
-   * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
-   * data type.
-   * @returns a boolean value.
-   */
-  isEntry(rawElement) {
-    return Array.isArray(rawElement) && rawElement.length === 2;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if the size of an object is equal to zero and returns a boolean value.
-   * @returns A boolean value indicating whether the size of the object is 0 or not.
-   */
-  isEmpty() {
-    return this._size === 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The clear() function resets the state of an object by clearing its internal store, object map, and
-   * size.
-   */
-  clear() {
-    this._store = {};
-    this._objMap.clear();
-    this._size = 0;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * 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 };
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: O(k)
-   * Space Complexity: O(k)
-   *
-   * The function `setMany` takes an iterable collection of objects, maps each object to a key-value
-   * pair using a mapping function, and sets each key-value pair in the current object.
-   * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements of a type
-   * `T`.
-   * @returns The `setMany` function is returning an array of booleans.
-   */
-  setMany(entryOrRawElements) {
-    const results = [];
-    for (const rawEle of entryOrRawElements) {
-      let key, value;
-      if (this.isEntry(rawEle)) {
-        key = rawEle[0];
-        value = rawEle[1];
-      } else if (this._toEntryFn) {
-        const item = this._toEntryFn(rawEle);
-        key = item[0];
-        value = item[1];
-      }
-      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
-    }
-    return results;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * 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) {
-    if (this._isObjKey(key)) {
-      return this.objMap.get(key);
-    } else {
-      const strKey = this._getNoObjKey(key);
-      return this._store[strKey]?.value;
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * 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;
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * 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;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The clone function creates a new HashMap with the same key-value pairs as
-   * this one. The clone function is useful for creating a copy of an existing
-   * HashMap, and then modifying that copy without affecting the original.
-   *
-   * @return A new hashmap with the same values as this one
-   */
-  clone() {
-    return new _HashMap(this, { hashFn: this._hashFn, toEntryFn: this._toEntryFn });
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * 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, key, value, index++, this));
-    }
-    return resultMap;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * 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, key, value, index++, this)) {
-        filteredMap.set(key, value);
-      }
-    }
-    return filteredMap;
-  }
-  /**
-   * The function returns an iterator that yields key-value pairs from both an object store and an
-   * object map.
-   */
-  *_getIterator() {
-    for (const node of Object.values(this.store)) {
-      yield [node.key, node.value];
-    }
-    for (const node of this.objMap) {
-      yield node;
-    }
-  }
-  /**
-   * The function checks if a given key is an object or a function.
-   * @param {any} key - The parameter "key" can be of any type.
-   * @returns a boolean value.
-   */
-  _isObjKey(key) {
-    const keyType = typeof key;
-    return (keyType === "object" || keyType === "function") && key !== null;
-  }
-  /**
-   * The function `_getNoObjKey` takes a key and returns a string representation of the key, handling
-   * different types of keys.
-   * @param {K} key - The `key` parameter is of type `K`, which represents the type of the key being
-   * passed to the `_getNoObjKey` function.
-   * @returns a string value.
-   */
-  _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 extends IterableEntryBase {
-  _sentinel;
-  /**
-   * The constructor initializes a LinkedHashMap object with an optional raw collection and options.
-   * @param entryOrRawElements - The `entryOrRawElements` parameter is an iterable collection of elements. It is
-   * used to initialize the HashMapLinked instance with key-value pairs. Each element in the
-   * `entryOrRawElements` is converted to a key-value pair using the `toEntryFn` function (if provided) and
-   * then added to the HashMap
-   * @param [options] - The `options` parameter is an optional object that can contain the following
-   * properties:
-   */
-  constructor(entryOrRawElements = [], options) {
-    super();
-    this._sentinel = {};
-    this._sentinel.prev = this._sentinel.next = this._head = this._tail = this._sentinel;
-    if (options) {
-      const { hashFn, objHashFn, toEntryFn } = options;
-      if (hashFn) this._hashFn = hashFn;
-      if (objHashFn) this._objHashFn = objHashFn;
-      if (toEntryFn) {
-        this._toEntryFn = toEntryFn;
-      }
-    }
-    if (entryOrRawElements) {
-      this.setMany(entryOrRawElements);
-    }
-  }
-  _hashFn = (key) => String(key);
-  /**
-   * The function returns the hash function used for generating a hash value for a given key.
-   * @returns The hash function that takes a key of type K and returns a string.
-   */
-  get hashFn() {
-    return this._hashFn;
-  }
-  _objHashFn = (key) => key;
-  /**
-   * The function returns the object hash function.
-   * @returns The function `objHashFn` is being returned.
-   */
-  get objHashFn() {
-    return this._objHashFn;
-  }
-  _noObjMap = {};
-  /**
-   * The function returns a record of HashMapLinkedNode objects with string keys.
-   * @returns The method is returning a Record object, which is a TypeScript type that represents an
-   * object with string keys and values that are HashMapLinkedNode objects with keys of type K and
-   * values of type V or undefined.
-   */
-  get noObjMap() {
-    return this._noObjMap;
-  }
-  _objMap = /* @__PURE__ */ new WeakMap();
-  /**
-   * The function returns the WeakMap object used to map objects to HashMapLinkedNode instances.
-   * @returns The `objMap` property is being returned.
-   */
-  get objMap() {
-    return this._objMap;
-  }
-  _head;
-  /**
-   * The function returns the head node of a HashMapLinkedNode.
-   * @returns The method `getHead()` is returning a `HashMapLinkedNode` object with key type `K` and
-   * a value type `V | undefined`.
-   */
-  get head() {
-    return this._head;
-  }
-  _tail;
-  /**
-   * The function returns the tail node of a HashMapLinkedNode.
-   * @returns The `_tail` property of type `HashMapLinkedNode<K, V | undefined>` is being returned.
-   */
-  get tail() {
-    return this._tail;
-  }
-  _toEntryFn = (rawElement) => {
-    if (this.isEntry(rawElement)) {
-      return rawElement;
-    } else {
-      throw new Error(
-        "If the provided entryOrRawElements does not adhere to the [key, value] type format, the toEntryFn in the constructor's options parameter needs to specified."
-      );
-    }
-  };
-  /**
-   * The function returns the value of the _toEntryFn property.
-   * @returns The function being returned is `this._toEntryFn`.
-   */
-  get toEntryFn() {
-    return this._toEntryFn;
-  }
-  _size = 0;
-  /**
-   * The function returns the size of an object.
-   * @returns The size of the object.
-   */
-  get size() {
-    return this._size;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the front of a data structure.
-   * @returns The front element of the data structure, represented as a tuple with a key (K) and a
-   * value (V).
-   */
-  get first() {
-    if (this._size === 0) return;
-    return [this.head.key, this.head.value];
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function returns the key-value pair at the end of a data structure.
-   * @returns The method is returning an array containing the key-value pair of the tail element in the
-   * data structure.
-   */
-  get last() {
-    if (this._size === 0) return;
-    return [this.tail.key, this.tail.value];
-  }
-  /**
-   * The `begin()` function in TypeScript iterates over a linked list and yields key-value pairs.
-   */
-  *begin() {
-    let node = this.head;
-    while (node !== this._sentinel) {
-      yield [node.key, node.value];
-      node = node.next;
-    }
-  }
-  /**
-   * The function `reverseBegin()` iterates over a linked list in reverse order, yielding each node's
-   * key and value.
-   */
-  *reverseBegin() {
-    let node = this.tail;
-    while (node !== this._sentinel) {
-      yield [node.key, node.value];
-      node = node.prev;
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `set` function adds a new key-value pair to a data structure, either using an object key or a
-   * string key.
-   * @param {K} key - The `key` parameter is the key to be set in the data structure. It can be of any
-   * type, but typically it is a string or symbol.
-   * @param {V} [value] - The `value` parameter is an optional parameter of type `V`. It represents the
-   * value associated with the key being set in the data structure.
-   * @returns the size of the data structure after the key-value pair has been set.
-   */
-  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 && 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 && 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.tail.next = node;
-        node.prev = this.tail;
-      }
-      this._tail = node;
-      this._sentinel.prev = node;
-      this._size++;
-    }
-    return true;
-  }
-  /**
-   * Time Complexity: O(k)
-   * Space Complexity: O(k)
-   *
-   * The function `setMany` takes an iterable collection, converts each element into a key-value pair
-   * using a provided function, and sets each key-value pair in the current object, returning an array
-   * of booleans indicating the success of each set operation.
-   * @param entryOrRawElements - The entryOrRawElements parameter is an iterable collection of elements of type
-   * R.
-   * @returns The `setMany` function returns an array of booleans.
-   */
-  setMany(entryOrRawElements) {
-    const results = [];
-    for (const rawEle of entryOrRawElements) {
-      let key, value;
-      if (this.isEntry(rawEle)) {
-        key = rawEle[0];
-        value = rawEle[1];
-      } else if (this._toEntryFn) {
-        const item = this._toEntryFn(rawEle);
-        key = item[0];
-        value = item[1];
-      }
-      if (key !== void 0 && value !== void 0) results.push(this.set(key, value));
-    }
-    return results;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a given key exists in a map, using different logic depending on whether the
-   * key is a weak key or not.
-   * @param {K} key - The `key` parameter is the key that is being checked for existence in the map.
-   * @returns The method `has` is returning a boolean value.
-   */
-  has(key) {
-    if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      return this.objMap.has(hash);
-    } else {
-      const hash = this._hashFn(key);
-      return hash in this.noObjMap;
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function `get` retrieves the value associated with a given key from a map, either by using the
-   * key directly or by using an index stored in the key object.
-   * @param {K} key - The `key` parameter is the key used to retrieve a value from the map. It can be
-   * of any type, but typically it is a string or symbol.
-   * @returns The value associated with the given key is being returned. If the key is an object key,
-   * the value is retrieved from the `_nodes` array using the index stored in the `OBJ_KEY_INDEX`
-   * property of the key. If the key is a string key, the value is retrieved from the `_noObjMap` object
-   * using the key itself. If the key is not found, `undefined` is
-   */
-  get(key) {
-    if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      const node = this.objMap.get(hash);
-      return node ? node.value : void 0;
-    } else {
-      const hash = this._hashFn(key);
-      const node = this.noObjMap[hash];
-      return node ? node.value : void 0;
-    }
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The function `at` retrieves the key-value pair at a specified index in a linked list.
-   * @param {number} index - The index parameter is a number that represents the position of the
-   * element we want to retrieve from the data structure.
-   * @returns The method `at(index: number)` is returning an array containing the key-value pair at
-   * the specified index in the data structure. The key-value pair is represented as a tuple `[K, V]`,
-   * where `K` is the key and `V` is the value.
-   */
-  at(index) {
-    rangeCheck(index, 0, this._size - 1);
-    let node = this.head;
-    while (index--) {
-      node = node.next;
-    }
-    return node.value;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `delete` function removes a key-value pair from a map-like data structure.
-   * @param {K} key - The `key` parameter is the key that you want to delete from the data structure.
-   * It can be of any type, but typically it is a string or an object.
-   * @returns a boolean value. It returns `true` if the deletion was successful, and `false` if the key
-   * was not found.
-   */
-  delete(key) {
-    let node;
-    if (isWeakKey(key)) {
-      const hash = this._objHashFn(key);
-      node = this.objMap.get(hash);
-      if (!node) {
-        return false;
-      }
-      this.objMap.delete(hash);
-    } else {
-      const hash = this._hashFn(key);
-      node = this.noObjMap[hash];
-      if (!node) {
-        return false;
-      }
-      delete this.noObjMap[hash];
-    }
-    this._deleteNode(node);
-    return true;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   *
-   * The `deleteAt` function deletes a node at a specified index in a linked list.
-   * @param {number} index - The index parameter represents the position at which the node should be
-   * deleted in the linked list.
-   * @returns The size of the list after deleting the element at the specified index.
-   */
-  deleteAt(index) {
-    rangeCheck(index, 0, this._size - 1);
-    let node = this.head;
-    while (index--) {
-      node = node.next;
-    }
-    return this._deleteNode(node);
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The function checks if a data structure is empty by comparing its size to zero.
-   * @returns The method is returning a boolean value indicating whether the size of the object is 0 or
-   * not.
-   */
-  isEmpty() {
-    return this._size === 0;
-  }
-  /**
-   * The function checks if a given element is an array with exactly two elements.
-   * @param {any} rawElement - The `rawElement` parameter is of type `any`, which means it can be any
-   * data type.
-   * @returns a boolean value.
-   */
-  isEntry(rawElement) {
-    return Array.isArray(rawElement) && rawElement.length === 2;
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `clear` function clears all the entries in a data structure and resets its properties.
-   */
-  clear() {
-    this._noObjMap = {};
-    this._size = 0;
-    this._head = this._tail = this._sentinel.prev = this._sentinel.next = this._sentinel;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `clone` function creates a new instance of a `LinkedHashMap` with the same key-value pairs as
-   * the original.
-   * @returns The `clone()` method is returning a new instance of `LinkedHashMap<K, V>` that is a clone
-   * of the original `LinkedHashMap` object.
-   */
-  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)
-   * Space Complexity: O(n)
-   *
-   * The `filter` function creates a new `LinkedHashMap` containing key-value pairs from the original
-   * map that satisfy a given predicate function.
-   * @param predicate - The `predicate` parameter is a callback function that takes four arguments:
-   * `value`, `key`, `index`, and `this`. It should return a boolean value indicating whether the
-   * current element should be included in the filtered map or not.
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-   * specify the value of `this` within the `predicate` function. It is used when you want to bind a
-   * specific object as the context for the `predicate` function. If `thisArg` is not provided, `this
-   * @returns a new `LinkedHashMap` object that contains the key-value pairs from the original
-   * `LinkedHashMap` object that satisfy the given predicate function.
-   */
-  filter(predicate, thisArg) {
-    const filteredMap = new _LinkedHashMap();
-    let index = 0;
-    for (const [key, value] of this) {
-      if (predicate.call(thisArg, key, value, index, this)) {
-        filteredMap.set(key, value);
-      }
-      index++;
-    }
-    return filteredMap;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(n)
-   *
-   * The `map` function in TypeScript creates a new `LinkedHashMap` by applying a callback function to
-   * each key-value pair in the original map.
-   * @param callback - The callback parameter is a function that will be called for each key-value pair
-   * in the map. It takes four arguments: the value of the current key-value pair, the key of the
-   * current key-value pair, the index of the current key-value pair, and the map itself. The callback
-   * function should
-   * @param {any} [thisArg] - The `thisArg` parameter is an optional argument that allows you to
-   * specify the value of `this` within the callback function. If provided, the callback function will
-   * be called with `thisArg` as its `this` value. If not provided, `this` will refer to the current
-   * map
-   * @returns a new `LinkedHashMap` object with the values mapped according to the provided callback
-   * function.
-   */
-  map(callback, thisArg) {
-    const mappedMap = new _LinkedHashMap();
-    let index = 0;
-    for (const [key, value] of this) {
-      const [newKey, newValue] = callback.call(thisArg, key, value, index, this);
-      mappedMap.set(newKey, newValue);
-      index++;
-    }
-    return mappedMap;
-  }
-  /**
-   * Time Complexity: O(n)
-   * Space Complexity: O(1)
-   * where n is the number of entries in the LinkedHashMap.
-   *
-   * The above function is an iterator that yields key-value pairs from a linked list.
-   */
-  *_getIterator() {
-    let node = this.head;
-    while (node !== this._sentinel) {
-      yield [node.key, node.value];
-      node = node.next;
-    }
-  }
-  /**
-   * Time Complexity: O(1)
-   * Space Complexity: O(1)
-   *
-   * The `_deleteNode` function removes a node from a doubly linked list and updates the head and tail
-   * pointers if necessary.
-   * @param node - The `node` parameter is an instance of the `HashMapLinkedNode` class, which
-   * represents a node in a linked list. It contains a key-value pair and references to the previous
-   * and next nodes in the list.
-   */
-  _deleteNode(node) {
-    const { prev, next } = node;
-    prev.next = next;
-    next.prev = prev;
-    if (node === this.head) {
-      this._head = next;
-    }
-    if (node === this.tail) {
-      this._tail = prev;
-    }
-    this._size -= 1;
-    return true;
-  }
-};
-export {
-  HashMap,
-  LinkedHashMap
-};
-/**
- * data-structure-typed
- *
- * @author Pablo Zeng
- * @copyright Copyright (c) 2022 Pablo Zeng <zrwusa@gmail.com>
- * @license MIT License
- */