deque-typed 1.48.0 → 1.48.1

package/dist/data-structures/binary-tree/binary-tree.d.ts

@@ -460,6 +460,44 @@ export declare class BinaryTree<V = any, N extends BinaryTreeNode<V, N> = Binary
      * by the return type of the `callback` function.
      */
     morris<C extends BTNCallback<N>>(callback?: C, pattern?: DFSOrderPattern, beginRoot?: BTNodeKeyOrNode<N>): ReturnType<C>[];
+    /**
+     * 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(): BTNKey[];
+    /**
+     * 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(): (V | undefined)[];
+    /**
+     * 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(): TREE;
     /**
      * Time complexity: O(n)
      * Space complexity: O(1)

package/dist/data-structures/binary-tree/binary-tree.js

@@ -1404,6 +1404,60 @@ class BinaryTree {
         }
         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)

package/dist/data-structures/binary-tree/tree-multimap.d.ts

@@ -137,6 +137,18 @@ export declare class TreeMultimap<V = any, N extends TreeMultimapNode<V, N> = Tr
      * The clear() function clears the contents of a data structure and sets the count to zero.
      */
     clear(): void;
+    /**
+     * 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(): TREE;
     /**
      * 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.

package/dist/data-structures/binary-tree/tree-multimap.js

@@ -280,6 +280,22 @@ class TreeMultimap extends avl_tree_1.AVLTree {
         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.

package/dist/data-structures/hash/hash-map.d.ts

@@ -5,8 +5,160 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import { HashMapLinkedNode, HashMapOptions } from '../../types';
+import { HashMapLinkedNode, HashMapOptions, HashMapStoreItem } from '../../types';
 export declare class HashMap<K = any, V = any> {
+    protected _store: {
+        [key: string]: HashMapStoreItem<K, V>;
+    };
+    protected _objMap: Map<object, V>;
+    /**
+     * 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?: Iterable<[K, V]>, options?: {
+        hashFn: (key: K) => string;
+    });
+    protected _size: number;
+    get size(): number;
+    isEmpty(): boolean;
+    clear(): void;
+    /**
+     * 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: K, value: V): void;
+    /**
+     * 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: Iterable<[K, V]>): void;
+    /**
+     * 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: K): V | undefined;
+    /**
+     * 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: K): boolean;
+    /**
+     * 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: K): boolean;
+    /**
+     * The function returns an iterator that yields key-value pairs from both an object store and an
+     * object map.
+     */
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    /**
+     * The function returns an iterator that yields key-value pairs from the object.
+     */
+    entries(): IterableIterator<[K, V]>;
+    /**
+     * The function `keys()` returns an iterator that yields all the keys of the object.
+     */
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    /**
+     * 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: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean;
+    /**
+     * 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: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): boolean;
+    /**
+     * 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: (value: V, key: K, index: number, map: HashMap<K, V>) => void, thisArg?: any): void;
+    /**
+     * 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<U>(callbackfn: (value: V, key: K, index: number, map: HashMap<K, V>) => U, thisArg?: any): HashMap<K, U>;
+    /**
+     * 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: (value: V, key: K, index: number, map: HashMap<K, V>) => boolean, thisArg?: any): HashMap<K, V>;
+    /**
+     * 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<U>(callbackfn: (accumulator: U, currentValue: V, currentKey: K, index: number, map: HashMap<K, V>) => U, initialValue: U): U;
+    print(): void;
+    protected _hashFn: (key: K) => string;
+    protected _isObjKey(key: any): key is (object | ((...args: any[]) => any));
+    protected _getNoObjKey(key: K): string;
+}
+export declare class LinkedHashMap<K = any, V = any> {
     protected _noObjMap: Record<string, HashMapLinkedNode<K, V | undefined>>;
     protected _objMap: WeakMap<object, HashMapLinkedNode<K, V | undefined>>;
     protected _head: HashMapLinkedNode<K, V | undefined>;
@@ -57,6 +209,10 @@ export declare class HashMap<K = any, V = any> {
      * @returns the size of the data structure after the key-value pair has been set.
      */
     set(key: K, value?: V): number;
+    has(key: K): boolean;
+    setMany(entries: Iterable<[K, V]>): void;
+    keys(): K[];
+    values(): V[];
     /**
      * Time Complexity: O(1)
      * Space Complexity: O(1)
@@ -120,48 +276,49 @@ export declare class HashMap<K = any, V = any> {
      * The `clear` function clears all the elements in a data structure and resets its properties.
      */
     clear(): void;
+    clone(): LinkedHashMap<K, V>;
     /**
-     * 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: (element: [K, V], index: number, hashMap: HashMap<K, V>) => void): void;
+    forEach(callback: (element: [K, V], index: number, hashMap: LinkedHashMap<K, V>) => void): void;
     /**
-     * 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: (element: [K, V], index: number, map: HashMap<K, V>) => boolean): HashMap<K, V>;
+    filter(predicate: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => boolean): LinkedHashMap<K, V>;
     /**
-     * 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<NV>(callback: (element: [K, V], index: number, map: HashMap<K, V>) => NV): HashMap<K, NV>;
+    map<NV>(callback: (element: [K, V], index: number, map: LinkedHashMap<K, V>) => NV): LinkedHashMap<K, NV>;
     /**
-     * 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<A>(callback: (accumulator: A, element: [K, V], index: number, map: HashMap<K, V>) => A, initialValue: A): A;
+    reduce<A>(callback: (accumulator: A, element: [K, V], index: number, map: LinkedHashMap<K, V>) => A, initialValue: A): A;
     /**
-     * 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.