min-heap-typed 1.49.6 → 1.49.8

package/dist/data-structures/heap/max-heap.js

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class MaxHeap extends heap_1.Heap {
-    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/data-structures/heap/min-heap.js

@@ -13,7 +13,7 @@ const heap_1 = require("./heap");
  * 8. Graph Algorithms: Such as Dijkstra's shortest path algorithm and Prim's minimum spanning tree algorithm, which use heaps to improve performance.
  */
 class MinHeap extends heap_1.Heap {
-    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/data-structures/linked-list/doubly-linked-list.js

@@ -25,7 +25,7 @@ class DoublyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and size.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
         this._head = undefined;
         this._tail = undefined;

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -18,10 +18,8 @@ class SinglyLinkedList extends base_1.IterableElementBase {
     /**
      * The constructor initializes the linked list with an empty head, tail, and length.
      */
-    constructor(elements) {
+    constructor(elements = []) {
         super();
-        this._head = undefined;
-        this._tail = undefined;
         this._size = 0;
         if (elements) {
             for (const el of elements)

package/dist/data-structures/linked-list/skip-linked-list.d.ts

@@ -5,6 +5,7 @@
  * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT License
  */
+import type { SkipLinkedListOptions } from '../../types';
 export declare class SkipListNode<K, V> {
     key: K;
     value: V;
@@ -12,14 +13,7 @@ export declare class SkipListNode<K, V> {
     constructor(key: K, value: V, level: number);
 }
 export declare class SkipList<K, V> {
-    /**
-     * 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?: number, probability?: number);
+    constructor(elements?: Iterable<[K, V]>, options?: SkipLinkedListOptions);
     protected _head: SkipListNode<K, V>;
     get head(): SkipListNode<K, V>;
     protected _level: number;

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

@@ -1,11 +1,4 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SkipList = exports.SkipListNode = void 0;
 class SkipListNode {
@@ -17,18 +10,22 @@ class SkipListNode {
 }
 exports.SkipListNode = SkipListNode;
 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);
+    constructor(elements = [], options) {
+        this._head = new SkipListNode(undefined, undefined, this.maxLevel);
         this._level = 0;
-        this._maxLevel = maxLevel;
-        this._probability = probability;
+        this._maxLevel = 16;
+        this._probability = 0.5;
+        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);
+        }
     }
     get head() {
         return this._head;

package/dist/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/data-structures/matrix/matrix.js

@@ -1,11 +1,4 @@
 "use strict";
-/**
- * data-structure-typed
- *
- * @author Tyler Zeng
- * @copyright Copyright (c) 2022 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT License
- */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Matrix = void 0;
 class Matrix {

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MaxPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
 class MaxPriorityQueue extends priority_queue_1.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/data-structures/priority-queue/min-priority-queue.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MinPriorityQueue = void 0;
 const priority_queue_1 = require("./priority-queue");
 class MinPriorityQueue extends priority_queue_1.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/data-structures/priority-queue/priority-queue.js

@@ -11,7 +11,7 @@ const heap_1 = require("../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
  */
 class PriorityQueue extends heap_1.Heap {
-    constructor(elements, options) {
+    constructor(elements = [], options) {
         super(elements, options);
     }
 }

package/dist/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/data-structures/queue/deque.js

@@ -11,24 +11,21 @@ const utils_1 = require("../../utils");
  * 5. Performance jitter: Deque may experience performance jitter, but DoublyLinkedList will not
  */
 class Deque extends base_1.IterableElementBase {
-    /**
-     * 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) {
+    constructor(elements = [], options) {
         super();
         this._bucketFirst = 0;
         this._firstInBucket = 0;
         this._bucketLast = 0;
         this._lastInBucket = 0;
         this._bucketCount = 0;
+        this._bucketSize = 1 << 12;
         this._buckets = [];
         this._size = 0;
+        if (options) {
+            const { bucketSize } = options;
+            if (typeof bucketSize === 'number')
+                this._bucketSize = bucketSize;
+        }
         let _size;
         if ('length' in elements) {
             if (elements.length instanceof Function)
@@ -42,7 +39,6 @@ class Deque extends base_1.IterableElementBase {
             else
                 _size = elements.size;
         }
-        this._bucketSize = bucketSize;
         this._bucketCount = (0, utils_1.calcMinUnitsRequired)(_size, this._bucketSize) || 1;
         for (let i = 0; i < this._bucketCount; ++i) {
             this._buckets.push(new Array(this._bucketSize));
@@ -612,7 +608,7 @@ class Deque extends base_1.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)) {
@@ -640,7 +636,7 @@ class Deque extends base_1.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/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/data-structures/queue/queue.js

@@ -9,23 +9,27 @@ const linked_list_1 = require("../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.
  */
 class Queue extends base_1.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._elements = [];
         this._offset = 0;
+        if (elements) {
+            for (const el of elements)
+                this.push(el);
+        }
     }
-    get nodes() {
-        return this._nodes;
+    get elements() {
+        return this._elements;
     }
     get offset() {
         return this._offset;
@@ -35,18 +39,18 @@ class Queue extends base_1.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.
@@ -57,11 +61,11 @@ class Queue extends base_1.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.
@@ -91,7 +95,7 @@ class Queue extends base_1.IterableElementBase {
      * @returns The `add` method is returning a `Queue<E>` object.
      */
     push(element) {
-        this.nodes.push(element);
+        this.elements.push(element);
         return true;
     }
     /**
@@ -111,11 +115,11 @@ class Queue extends base_1.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;
     }
@@ -127,8 +131,8 @@ class Queue extends base_1.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() {
@@ -143,7 +147,7 @@ class Queue extends base_1.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() {
@@ -188,7 +192,7 @@ class Queue extends base_1.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.
@@ -212,17 +216,17 @@ class Queue extends base_1.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;
     }
     /**
@@ -237,7 +241,7 @@ class Queue extends base_1.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)
@@ -302,7 +306,7 @@ class Queue extends base_1.IterableElementBase {
      * Space Complexity: O(n)
      */
     *_getIterator() {
-        for (const item of this.nodes) {
+        for (const item of this.elements) {
             yield item;
         }
     }

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

@@ -17,13 +17,12 @@ class Stack extends base_1.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);
-            }
         }
     }
     get elements() {

package/dist/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/data-structures/trie/trie.js

@@ -28,15 +28,19 @@ exports.TrieNode = TrieNode;
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data."
  */
 class Trie extends base_1.IterableElementBase {
-    constructor(words, caseSensitive = true) {
+    constructor(words = [], options) {
         super();
-        this._root = new TrieNode('');
-        this._caseSensitive = caseSensitive;
         this._size = 0;
+        this._caseSensitive = true;
+        this._root = new TrieNode('');
+        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);
-            }
         }
     }
     get size() {

package/dist/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/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/types/data-structures/binary-tree/rb-tree.d.ts

@@ -6,4 +6,4 @@ export declare enum RBTNColor {
 }
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions<K> = BSTOptions<K> & {};
+export type RBTreeOptions<K> = Omit<BSTOptions<K>, 'variant'> & {};

package/dist/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/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;