data-structure-typed 1.49.5 → 1.49.7

package/dist/mjs/data-structures/linked-list/skip-linked-list.js

@@ -1,10 +1,3 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 export class SkipListNode {
     key;
     value;
@@ -16,32 +9,32 @@ export class SkipListNode {
     }
 }
 export class SkipList {
-    /**
-     * The constructor initializes a SkipList with a specified maximum level and probability.
-     * @param [maxLevel=16] - The `maxLevel` parameter represents the maximum level that a skip list can have. It determines
-     * the maximum number of levels that can be created in the skip list.
-     * @param [probability=0.5] - The probability parameter represents the probability of a node being promoted to a higher
-     * level in the skip list. It is used to determine the height of each node in the skip list.
-     */
-    constructor(maxLevel = 16, probability = 0.5) {
-        this._head = new SkipListNode(undefined, undefined, maxLevel);
-        this._level = 0;
-        this._maxLevel = maxLevel;
-        this._probability = probability;
+    constructor(elements = [], options) {
+        if (options) {
+            const { maxLevel, probability } = options;
+            if (typeof maxLevel === 'number')
+                this._maxLevel = maxLevel;
+            if (typeof probability === 'number')
+                this._probability = probability;
+        }
+        if (elements) {
+            for (const [key, value] of elements)
+                this.add(key, value);
+        }
     }
-    _head;
+    _head = new SkipListNode(undefined, undefined, this.maxLevel);
     get head() {
         return this._head;
     }
-    _level;
+    _level = 0;
     get level() {
         return this._level;
     }
-    _maxLevel;
+    _maxLevel = 16;
     get maxLevel() {
         return this._maxLevel;
     }
-    _probability;
+    _probability = 0.5;
     get probability() {
         return this._probability;
     }

package/dist/mjs/data-structures/matrix/matrix.d.ts

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { MatrixOptions } from '../../types';
 export declare class Matrix {
     /**
      * The constructor function initializes a matrix object with the provided data and options, or with
@@ -13,13 +14,7 @@ export declare class Matrix {
      * @param [options] - The `options` parameter is an optional object that can contain the following
      * properties:
      */
-    constructor(data: number[][], options?: {
-        rows?: number;
-        cols?: number;
-        addFn?: (a: number, b: number) => any;
-        subtractFn?: (a: number, b: number) => any;
-        multiplyFn?: (a: number, b: number) => any;
-    });
+    constructor(data: number[][], options?: MatrixOptions);
     protected _rows: number;
     get rows(): number;
     protected _cols: number;

package/dist/mjs/data-structures/matrix/matrix.js

@@ -1,10 +1,3 @@
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 export class Matrix {
     /**
      * The constructor function initializes a matrix object with the provided data and options, or with

package/dist/mjs/data-structures/priority-queue/max-priority-queue.js

@@ -1,6 +1,6 @@
 import { PriorityQueue } from './priority-queue';
 export class MaxPriorityQueue extends PriorityQueue {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

package/dist/mjs/data-structures/priority-queue/min-priority-queue.js

@@ -1,6 +1,6 @@
 import { PriorityQueue } from './priority-queue';
 export class MinPriorityQueue extends PriorityQueue {
-    constructor(elements, options = {
+    constructor(elements = [], options = {
         comparator: (a, b) => {
             if (!(typeof a === 'number' && typeof b === 'number')) {
                 throw new Error('The a, b params of compare function must be number');

package/dist/mjs/data-structures/priority-queue/priority-queue.js

@@ -8,7 +8,7 @@ import { Heap } from '../heap';
  * 6. Kth Largest Element in a Data Stream: Used to maintain a min-heap of size K for quickly finding the Kth largest element in stream data
  */
 export class PriorityQueue extends Heap {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
         super(elements, options);
     }
 }

package/dist/mjs/data-structures/queue/deque.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback, IterableWithSizeOrLength } from '../../types';
+import type { DequeOptions, ElementCallback, IterableWithSizeOrLength } from '../../types';
 import { IterableElementBase } from '../base';
 /**
  * 1. Operations at Both Ends: Supports adding and removing elements at both the front and back of the queue. This allows it to be used as a stack (last in, first out) and a queue (first in, first out).
@@ -21,16 +21,7 @@ export declare class Deque<E> extends IterableElementBase<E> {
     protected _lastInBucket: number;
     protected _bucketCount: number;
     protected readonly _bucketSize: number;
-    /**
-     * The constructor initializes a data structure with a specified bucket size and populates it with
-     * elements from an iterable.
-     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-     * contains the initial elements to be stored in the data structure. It can also be an object with a
-     * `length` property or a `size` property, which represents the number of elements in the iterable.
-     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-     * stored in each bucket. It determines the size of each bucket in the data structure.
-     */
-    constructor(elements?: IterableWithSizeOrLength<E>, bucketSize?: number);
+    constructor(elements?: IterableWithSizeOrLength<E>, options?: DequeOptions);
     protected _buckets: E[][];
     get buckets(): E[][];
     protected _size: number;

package/dist/mjs/data-structures/queue/deque.js

@@ -13,18 +13,14 @@ export class Deque extends IterableElementBase {
     _bucketLast = 0;
     _lastInBucket = 0;
     _bucketCount = 0;
-    _bucketSize;
-    /**
-     * The constructor initializes a data structure with a specified bucket size and populates it with
-     * elements from an iterable.
-     * @param elements - The `elements` parameter is an iterable object (such as an array or a Set) that
-     * contains the initial elements to be stored in the data structure. It can also be an object with a
-     * `length` property or a `size` property, which represents the number of elements in the iterable.
-     * @param bucketSize - The `bucketSize` parameter is the maximum number of elements that can be
-     * stored in each bucket. It determines the size of each bucket in the data structure.
-     */
-    constructor(elements = [], bucketSize = 1 << 12) {
+    _bucketSize = 1 << 12;
+    constructor(elements = [], options) {
         super();
+        if (options) {
+            const { bucketSize } = options;
+            if (typeof bucketSize === 'number')
+                this._bucketSize = bucketSize;
+        }
         let _size;
         if ('length' in elements) {
             if (elements.length instanceof Function)
@@ -38,7 +34,6 @@ export class Deque extends IterableElementBase {
             else
                 _size = elements.size;
         }
-        this._bucketSize = bucketSize;
         this._bucketCount = calcMinUnitsRequired(_size, this._bucketSize) || 1;
         for (let i = 0; i < this._bucketCount; ++i) {
             this._buckets.push(new Array(this._bucketSize));
@@ -610,7 +605,7 @@ export class Deque extends IterableElementBase {
      * satisfy the given predicate function.
      */
     filter(predicate, thisArg) {
-        const newDeque = new Deque([], this._bucketSize);
+        const newDeque = new Deque([], { bucketSize: this._bucketSize });
         let index = 0;
         for (const el of this) {
             if (predicate.call(thisArg, el, index, this)) {
@@ -638,7 +633,7 @@ export class Deque extends IterableElementBase {
      * @returns a new Deque object with the mapped values.
      */
     map(callback, thisArg) {
-        const newDeque = new Deque([], this._bucketSize);
+        const newDeque = new Deque([], { bucketSize: this._bucketSize });
         let index = 0;
         for (const el of this) {
             newDeque.push(callback.call(thisArg, el, index, this));

package/dist/mjs/data-structures/queue/queue.d.ts

@@ -12,19 +12,19 @@ import { SinglyLinkedList } from '../linked-list';
  * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
  * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
- * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
 export declare class Queue<E = any> extends IterableElementBase<E> {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
      * initialized as an empty array.
      */
-    constructor(elements?: E[]);
-    protected _nodes: E[];
-    get nodes(): E[];
+    constructor(elements?: Iterable<E>);
+    protected _elements: E[];
+    get elements(): E[];
     protected _offset: number;
     get offset(): number;
     /**
@@ -36,8 +36,8 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     get first(): E | undefined;
@@ -50,7 +50,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1) - no additional space is used.
      *
      * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
     get last(): E | undefined;
@@ -101,8 +101,8 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+     * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek(): E | undefined;
@@ -115,7 +115,7 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Space Complexity: O(1) - no additional space is used.
      *
      * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
     peekLast(): E | undefined;
@@ -174,12 +174,12 @@ export declare class Queue<E = any> extends IterableElementBase<E> {
      * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
      * Space Complexity: O(n) - where n is the number of elements in the queue.
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
      * @returns An array of type E is being returned.
      */
     toArray(): E[];
     /**
-     * The clear function resets the nodes array and offset to their initial values.
+     * The clear function resets the elements array and offset to their initial values.
      */
     clear(): void;
     /**

package/dist/mjs/data-structures/queue/queue.js

@@ -6,26 +6,28 @@ import { SinglyLinkedList } from '../linked-list';
  * 3. Uses: Queues are commonly used to manage a series of tasks or elements that need to be processed in order. For example, managing task queues in a multi-threaded environment, or in algorithms for data structures like trees and graphs for breadth-first search.
  * 4. Task Scheduling: Managing the order of task execution in operating systems or applications.
  * 5. Data Buffering: Acting as a buffer for data packets in network communication.
- * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store nodes that are to be visited.
+ * 6. Breadth-First Search (BFS): In traversal algorithms for graphs and trees, queues store elements that are to be visited.
  * 7. Real-time Queuing: Like queuing systems in banks or supermarkets.
  */
 export class Queue extends IterableElementBase {
     /**
      * The constructor initializes an instance of a class with an optional array of elements and sets the offset to 0.
      * @param {E[]} [elements] - The `elements` parameter is an optional array of elements of type `E`. If provided, it
-     * will be used to initialize the `_nodes` property of the class. If not provided, the `_nodes` property will be
+     * will be used to initialize the `_elements` property of the class. If not provided, the `_elements` property will be
      * initialized as an empty array.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
-        this._nodes = elements || [];
-        this._offset = 0;
+        if (elements) {
+            for (const el of elements)
+                this.push(el);
+        }
     }
-    _nodes;
-    get nodes() {
-        return this._nodes;
+    _elements = [];
+    get elements() {
+        return this._elements;
     }
-    _offset;
+    _offset = 0;
     get offset() {
         return this._offset;
     }
@@ -34,18 +36,18 @@ export class Queue extends IterableElementBase {
      * @returns {number} The size of the array, which is the difference between the length of the array and the offset.
      */
     get size() {
-        return this.nodes.length - this.offset;
+        return this.elements.length - this.offset;
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `first` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `get first()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `first` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+     * @returns The `get first()` method returns the first element of the data structure, represented by the `_elements` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     get first() {
-        return this.size > 0 ? this.nodes[this.offset] : undefined;
+        return this.size > 0 ? this.elements[this.offset] : undefined;
     }
     /**
      * Time Complexity: O(1) - constant time as it adds an element to the end of the array.
@@ -56,11 +58,11 @@ export class Queue extends IterableElementBase {
      * Space Complexity: O(1) - no additional space is used.
      *
      * The `last` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `get last()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * @returns The method `get last()` returns the last element of the `_elements` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
     get last() {
-        return this.size > 0 ? this.nodes[this.nodes.length - 1] : undefined;
+        return this.size > 0 ? this.elements[this.elements.length - 1] : undefined;
     }
     /**
      * Time Complexity: O(n) - where n is the number of elements in the queue. In the worst case, it may need to shift all elements to update the offset.
@@ -90,7 +92,7 @@ export class Queue extends IterableElementBase {
      * @returns The `add` method is returning a `Queue<E>` object.
      */
     push(element) {
-        this.nodes.push(element);
+        this.elements.push(element);
         return true;
     }
     /**
@@ -110,11 +112,11 @@ export class Queue extends IterableElementBase {
             return undefined;
         const first = this.first;
         this._offset += 1;
-        if (this.offset * 2 < this.nodes.length)
+        if (this.offset * 2 < this.elements.length)
             return first;
         // only delete dequeued elements when reaching half size
         // to decrease latency of shifting elements.
-        this._nodes = this.nodes.slice(this.offset);
+        this._elements = this.elements.slice(this.offset);
         this._offset = 0;
         return first;
     }
@@ -126,8 +128,8 @@ export class Queue extends IterableElementBase {
      * Time Complexity: O(1) - constant time as it retrieves the value at the current offset.
      * Space Complexity: O(1) - no additional space is used.
      *
-     * The `peek` function returns the first element of the array `_nodes` if it exists, otherwise it returns `undefined`.
-     * @returns The `peek()` method returns the first element of the data structure, represented by the `_nodes` array at
+     * The `peek` function returns the first element of the array `_elements` if it exists, otherwise it returns `undefined`.
+     * @returns The `peek()` method returns the first element of the data structure, represented by the `_elements` array at
      * the `_offset` index. If the data structure is empty (size is 0), it returns `undefined`.
      */
     peek() {
@@ -142,7 +144,7 @@ export class Queue extends IterableElementBase {
      * Space Complexity: O(1) - no additional space is used.
      *
      * The `peekLast` function returns the last element in an array-like data structure, or undefined if the structure is empty.
-     * @returns The method `peekLast()` returns the last element of the `_nodes` array if the array is not empty. If the
+     * @returns The method `peekLast()` returns the last element of the `_elements` array if the array is not empty. If the
      * array is empty, it returns `undefined`.
      */
     peekLast() {
@@ -187,7 +189,7 @@ export class Queue extends IterableElementBase {
      * @param index
      */
     getAt(index) {
-        return this.nodes[index];
+        return this.elements[index];
     }
     /**
      * Time Complexity: O(1) - constant time as it retrieves the value at the specified index.
@@ -211,17 +213,17 @@ export class Queue extends IterableElementBase {
      * Time Complexity: O(1) - constant time as it returns a shallow copy of the internal array.
      * Space Complexity: O(n) - where n is the number of elements in the queue.
      *
-     * The toArray() function returns an array of elements from the current offset to the end of the _nodes array.
+     * The toArray() function returns an array of elements from the current offset to the end of the _elements array.
      * @returns An array of type E is being returned.
      */
     toArray() {
-        return this.nodes.slice(this.offset);
+        return this.elements.slice(this.offset);
     }
     /**
-     * The clear function resets the nodes array and offset to their initial values.
+     * The clear function resets the elements array and offset to their initial values.
      */
     clear() {
-        this._nodes = [];
+        this._elements = [];
         this._offset = 0;
     }
     /**
@@ -236,7 +238,7 @@ export class Queue extends IterableElementBase {
      * @returns The `clone()` method is returning a new instance of the `Queue` class.
      */
     clone() {
-        return new Queue(this.nodes.slice(this.offset));
+        return new Queue(this.elements.slice(this.offset));
     }
     /**
      * Time Complexity: O(n)
@@ -301,7 +303,7 @@ export class Queue extends IterableElementBase {
      * Space Complexity: O(n)
      */
     *_getIterator() {
-        for (const item of this.nodes) {
+        for (const item of this.elements) {
             yield item;
         }
     }

package/dist/mjs/data-structures/stack/stack.js

@@ -14,16 +14,14 @@ export class Stack extends IterableElementBase {
      * of elements of type `E`. It is used to initialize the `_elements` property of the class. If the `elements` parameter
      * is provided and is an array, it is assigned to the `_elements
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
-        this._elements = [];
         if (elements) {
-            for (const el of elements) {
+            for (const el of elements)
                 this.push(el);
-            }
         }
     }
-    _elements;
+    _elements = [];
     get elements() {
         return this._elements;
     }

package/dist/mjs/data-structures/trie/trie.d.ts

@@ -5,7 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
-import type { ElementCallback } from '../../types';
+import type { ElementCallback, TrieOptions } from '../../types';
 import { IterableElementBase } from '../base';
 /**
  * TrieNode represents a node in the Trie data structure. It holds a character key, a map of children nodes,
@@ -31,7 +31,7 @@ export declare class TrieNode {
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export declare class Trie extends IterableElementBase<string> {
-    constructor(words?: string[], caseSensitive?: boolean);
+    constructor(words?: Iterable<string>, options?: TrieOptions);
     protected _size: number;
     get size(): number;
     protected _caseSensitive: boolean;

package/dist/mjs/data-structures/trie/trie.js

@@ -27,26 +27,27 @@ export class TrieNode {
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 export class Trie extends IterableElementBase {
-    constructor(words, caseSensitive = true) {
+    constructor(words = [], options) {
         super();
-        this._root = new TrieNode('');
-        this._caseSensitive = caseSensitive;
-        this._size = 0;
+        if (options) {
+            const { caseSensitive } = options;
+            if (caseSensitive !== undefined)
+                this._caseSensitive = caseSensitive;
+        }
         if (words) {
-            for (const word of words) {
+            for (const word of words)
                 this.add(word);
-            }
         }
     }
-    _size;
+    _size = 0;
     get size() {
         return this._size;
     }
-    _caseSensitive;
+    _caseSensitive = true;
     get caseSensitive() {
         return this._caseSensitive;
     }
-    _root;
+    _root = new TrieNode('');
     get root() {
         return this._root;
     }

package/dist/mjs/interfaces/binary-tree.d.ts

@@ -1,9 +1,9 @@
 import { BinaryTree, BinaryTreeNode } from '../data-structures';
-import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, BTNExemplar } from '../types';
+import { BinaryTreeDeleteResult, BinaryTreeNested, BinaryTreeNodeNested, BinaryTreeOptions, BTNCallback, KeyOrNodeOrEntry } from '../types';
 export interface IBinaryTree<K = number, V = any, N extends BinaryTreeNode<K, V, N> = BinaryTreeNodeNested<K, V>, TREE extends BinaryTree<K, V, N, TREE> = BinaryTreeNested<K, V, N>> {
     createNode(key: K, value?: N['value']): N;
     createTree(options?: Partial<BinaryTreeOptions<K>>): TREE;
-    add(keyOrNodeOrEntry: BTNExemplar<K, V, N>, value?: V, count?: number): N | null | undefined;
-    addMany(nodes: Iterable<BTNExemplar<K, V, N>>, values?: Iterable<V | undefined>): (N | null | undefined)[];
+    add(keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, N>, value?: V, count?: number): boolean;
+    addMany(nodes: Iterable<KeyOrNodeOrEntry<K, V, N>>, values?: Iterable<V | undefined>): boolean[];
     delete<C extends BTNCallback<N>>(identifier: ReturnType<C> | null, callback: C): BinaryTreeDeleteResult<N>[];
 }

package/dist/mjs/types/common.d.ts

@@ -1,6 +1,6 @@
 export declare enum BSTVariant {
-    MIN = "MIN",
-    MAX = "MAX"
+    STANDARD = "STANDARD",
+    INVERSE = "INVERSE"
 }
 export declare enum CP {
     lt = "lt",
@@ -44,7 +44,7 @@ export type BinaryTreePrintOptions = {
 };
 export type BTNEntry<K, V> = [K | null | undefined, V | undefined];
 export type BTNKeyOrNode<K, N> = K | null | undefined | N;
-export type BTNExemplar<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
+export type KeyOrNodeOrEntry<K, V, N> = BTNEntry<K, V> | BTNKeyOrNode<K, N>;
 export type BTNodePureKeyOrNode<K, N> = K | N;
 export type BTNodePureExemplar<K, V, N> = [K, V | undefined] | BTNodePureKeyOrNode<K, N>;
 export type BSTNKeyOrNode<K, N> = K | undefined | N;

package/dist/mjs/types/common.js

@@ -1,7 +1,7 @@
 export var BSTVariant;
 (function (BSTVariant) {
-    BSTVariant["MIN"] = "MIN";
-    BSTVariant["MAX"] = "MAX";
+    BSTVariant["STANDARD"] = "STANDARD";
+    BSTVariant["INVERSE"] = "INVERSE";
 })(BSTVariant || (BSTVariant = {}));
 export var CP;
 (function (CP) {

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

@@ -3,6 +3,6 @@ import { IterationType } from "../../common";
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeNested<K, V, N extends BinaryTreeNode<K, V, N>> = BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, BinaryTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeOptions<K> = {
-    iterationType: IterationType;
-    extractor: (key: K) => number;
+    iterationType?: IterationType;
+    extractor?: (key: K) => number;
 };

package/dist/mjs/types/data-structures/binary-tree/bst.d.ts

@@ -4,5 +4,5 @@ import { BSTVariant } from "../../common";
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTNested<K, V, N extends BSTNode<K, V, N>> = BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, BST<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions<K> = BinaryTreeOptions<K> & {
-    variant: BSTVariant;
+    variant?: BSTVariant;
 };

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

@@ -2,4 +2,4 @@ import { TreeMultimap, TreeMultimapNode } from '../../../data-structures';
 import type { AVLTreeOptions } from './avl-tree';
 export type TreeMultimapNodeNested<K, V> = TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, TreeMultimapNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type TreeMultimapNested<K, V, N extends TreeMultimapNode<K, V, N>> = TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, TreeMultimap<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type TreeMultimapOptions<K> = Omit<AVLTreeOptions<K>, 'isMergeDuplicatedNodeByKey'> & {};
+export type TreeMultimapOptions<K> = AVLTreeOptions<K> & {};

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

@@ -4,9 +4,12 @@ export type HashMapLinkedNode<K, V> = {
     next: HashMapLinkedNode<K, V>;
     prev: HashMapLinkedNode<K, V>;
 };
+export type LinkedHashMapOptions<K> = {
+    hashFn?: (key: K) => string;
+    objHashFn?: (key: K) => object;
+};
 export type HashMapOptions<K> = {
-    hashFn: (key: K) => string;
-    objHashFn: (key: K) => object;
+    hashFn?: (key: K) => string;
 };
 export type HashMapStoreItem<K, V> = {
     key: K;

package/dist/mjs/types/data-structures/hash/index.d.ts

@@ -1,3 +1,2 @@
 export * from './hash-map';
-export * from './hash-table';
 export type HashFunction<K> = (key: K) => number;

package/dist/mjs/types/data-structures/hash/index.js

@@ -1,2 +1 @@
 export * from './hash-map';
-export * from './hash-table';

package/dist/mjs/types/data-structures/heap/heap.d.ts

@@ -1,4 +1,4 @@
 import { Comparator } from '../../common';
 export type HeapOptions<T> = {
-    comparator: Comparator<T>;
+    comparator?: Comparator<T>;
 };