data-structure-typed 2.4.2 → 2.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.4.2",
+  "version": "2.4.4",
   "description": "Standard data structure",
   "browser": "dist/umd/data-structure-typed.min.js",
   "umd:main": "dist/umd/data-structure-typed.min.js",
@@ -105,7 +105,7 @@
     "benchmark": "^2.1.4",
     "binary-tree-typed": "^1.54.3",
     "bst-typed": "^1.54.3",
-    "data-structure-typed": "^2.4.1",
+    "data-structure-typed": "^2.4.3",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

package/src/data-structures/base/iterable-element-base.ts

@@ -35,7 +35,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
    * @remarks
    * Time O(1), Space O(1).
    */
-  protected _toElementFn?: (rawElement: R) => E;
+  protected readonly _toElementFn?: (rawElement: R) => E;
 
   /**
    * Exposes the current `toElementFn`, if configured.
@@ -229,7 +229,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       index = 1;
     }
 
-    for (const value of iter as unknown as Iterable<E>) {
+    for (const value of iter) {
       acc = callbackfn(acc, value, index++, this);
     }
     return acc;

package/src/data-structures/binary-tree/binary-tree.ts

@@ -377,7 +377,7 @@ export class BinaryTree<K = any, V = any, R = any>
     if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
-  protected _isMapMode = true;
+  protected readonly _isMapMode: boolean = true;
 
   /**
    * Gets whether the tree is in Map mode.
@@ -389,7 +389,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._isMapMode;
   }
 
-  protected _isDuplicate = false;
+  protected readonly _isDuplicate: boolean = false;
 
   /**
    * Gets whether the tree allows duplicate keys.
@@ -440,7 +440,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._size;
   }
 
-  protected _NIL: BinaryTreeNode<K, V> = new BinaryTreeNode<K, V>(NaN as K) as unknown as BinaryTreeNode<K, V>;
+  protected readonly _NIL = new BinaryTreeNode<K, V>(NaN as K);
 
   /**
    * Gets the sentinel NIL node (used in self-balancing trees like Red-Black Tree).
@@ -452,7 +452,7 @@ export class BinaryTree<K = any, V = any, R = any>
     return this._NIL;
   }
 
-  protected _toEntryFn?: ToEntryFn<K, V, R>;
+  protected readonly _toEntryFn?: ToEntryFn<K, V, R>;
 
   /**
    * Gets the function used to convert raw data objects (R) into [key, value] entries.
@@ -1014,7 +1014,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): BinaryTreeNode<K, V> | null | undefined {
     if (this._isMapMode && keyNodeEntryOrPredicate !== null && keyNodeEntryOrPredicate !== undefined) {
       if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        const key = this._extractKey(keyNodeEntryOrPredicate);
         if (key === null || key === undefined) return;
         return this._store.get(key);
       }
@@ -1078,7 +1078,7 @@ export class BinaryTree<K = any, V = any, R = any>
   ): boolean {
     if (this._isMapMode && keyNodeEntryOrPredicate !== undefined && keyNodeEntryOrPredicate !== null) {
       if (!this._isPredicate(keyNodeEntryOrPredicate)) {
-        const key = this._extractKey(keyNodeEntryOrPredicate as any);
+        const key = this._extractKey(keyNodeEntryOrPredicate);
         if (key === null || key === undefined) return false;
         return this._store.has(key);
       }
@@ -2136,7 +2136,8 @@ export class BinaryTree<K = any, V = any, R = any>
    * @param node - The node.
    * @returns The node's key or undefined.
    */
-  protected _DEFAULT_NODE_CALLBACK = (node: BinaryTreeNode<K, V> | null | undefined) => (node ? node.key : undefined);
+  protected readonly _DEFAULT_NODE_CALLBACK: NodeCallback<BinaryTreeNode<K, V> | null | undefined, K | undefined> =
+    (node): K | undefined => node?.key;
 
   /**
    * (Protected) Snapshots the current tree's configuration options.

package/src/data-structures/binary-tree/bst.ts

@@ -391,7 +391,7 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
 
    * @remarks Time O(1) Space O(1)
    */
-  protected _comparator: Comparator<K>;
+  protected readonly _comparator: Comparator<K>;
 
   /**
    * Gets the comparator function used by the tree.

package/src/data-structures/binary-tree/tree-map.ts

@@ -436,4 +436,20 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
 
     return out;
   }
+
+  /**
+   * Creates a shallow clone of this map.
+   * @remarks Time O(n log n), Space O(n)
+   * @example
+   * const original = new TreeMap([['a', 1], ['b', 2]]);
+   * const copy = original.clone();
+   * copy.set('c', 3);
+   * original.has('c'); // false (original unchanged)
+   */
+  clone(): TreeMap<K, V> {
+    return new TreeMap<K, V>(this, {
+      comparator: this.#isDefaultComparator ? undefined : this.#userComparator,
+      isMapMode: this.#core.isMapMode
+    });
+  }
 }

package/src/data-structures/binary-tree/tree-multi-set.ts

@@ -247,7 +247,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
    * @remarks Time O(1), Space O(1)
    */
   get comparator(): Comparator<K> {
-    return (this.#core as any)._comparator;
+    return this.#core.comparator;
   }
 
   // ━━━ clear ━━━
@@ -398,7 +398,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   filter(predicate: (key: K, count: number) => boolean): TreeMultiSet<K> {
     const result = new TreeMultiSet<K>([], {
       comparator: this.#isDefaultComparator ? undefined : this.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       if (predicate(k, c)) {
@@ -443,7 +443,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   ): TreeMultiSet<K2> {
     const result = new TreeMultiSet<K2>([], {
       comparator: options?.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       const [newKey, newCount] = mapper(k, c);
@@ -464,7 +464,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
   clone(): TreeMultiSet<K> {
     const result = new TreeMultiSet<K>([], {
       comparator: this.#isDefaultComparator ? undefined : this.comparator,
-      isMapMode: (this.#core as any)._isMapMode
+      isMapMode: this.#core.isMapMode
     });
     for (const [k, c] of this.entries()) {
       result.add(k, c);
@@ -486,7 +486,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
     callback?: C
   ): (C extends undefined ? K : ReturnType<C>)[] {
     const cb = callback ?? ((k: K) => k);
-    return this.#core.rangeSearch(range, node => cb(node.key)) as any;
+    return this.#core.rangeSearch(range, node => cb(node.key));
   }
 
   /**

package/src/data-structures/binary-tree/tree-set.ts

@@ -404,4 +404,20 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
 
     return out;
   }
+
+  /**
+   * Creates a shallow clone of this set.
+   * @remarks Time O(n log n), Space O(n)
+   * @example
+   * const original = new TreeSet([1, 2, 3]);
+   * const copy = original.clone();
+   * copy.add(4);
+   * original.has(4); // false (original unchanged)
+   */
+  clone(): TreeSet<K> {
+    return new TreeSet<K>(this, {
+      comparator: this.#isDefaultComparator ? undefined : this.#userComparator,
+      isMapMode: this.#core.isMapMode
+    });
+  }
 }

package/src/data-structures/graph/abstract-graph.ts

@@ -65,7 +65,7 @@ export abstract class AbstractGraph<
    */
   constructor(options?: Partial<Record<string, unknown>>) {
     super();
-    const graph = (options as any)?.graph as GraphOptions<V> | undefined;
+    const graph = (options as { graph?: GraphOptions<V> })?.graph;
     this._options = { defaultEdgeWeight: 1, ...(graph ?? {}) };
   }
 
@@ -984,11 +984,12 @@ export abstract class AbstractGraph<
    * @remarks Time O(1), Space O(1)
    */
   protected _createInstance(_options?: Partial<Record<string, unknown>>): this {
-    const Ctor: any = (this as any).constructor;
-    const instance: this = new Ctor();
-    const graph = (_options as any)?.graph as GraphOptions<V> | undefined;
-    if (graph) (instance as any)._options = { ...(instance as any)._options, ...graph };
-    else (instance as any)._options = { ...(instance as any)._options, ...(this as any)._options };
+    const Ctor = this.constructor as new () => this;
+    const instance = new Ctor();
+    const graph = (_options as { graph?: GraphOptions<V> })?.graph;
+    // Use bracket notation for protected field access on dynamically created instance
+    if (graph) instance['_options'] = { ...instance['_options'], ...graph };
+    else instance['_options'] = { ...instance['_options'], ...this._options };
     return instance;
   }
 
@@ -1009,28 +1010,27 @@ export abstract class AbstractGraph<
     // 1) Add vertices
     if (iter) {
       for (const [k, v] of iter) {
-        (g as any).addVertex(k as VertexKey, v as V | undefined);
+        g.addVertex(k as VertexKey, v as V | undefined);
       }
     } else {
       for (const [k, v] of this) {
-        (g as any).addVertex(k as VertexKey, v as V | undefined);
+        g.addVertex(k as VertexKey, v as V | undefined);
       }
     }
     // 2) Add edges whose endpoints exist in the new graph
     const edges = this.edgeSet();
-    for (const e of edges as any[]) {
-      const ends = this.getEndsOfEdge(e as any) as unknown as [any, any] | undefined;
+    for (const e of edges) {
+      const ends = this.getEndsOfEdge(e);
       if (!ends) continue;
       const [va, vb] = ends;
-      const ka = (va as any).key as VertexKey;
-      const kb = (vb as any).key as VertexKey;
-      const hasA = (g as any).hasVertex ? (g as any).hasVertex(ka) : false;
-      const hasB = (g as any).hasVertex ? (g as any).hasVertex(kb) : false;
+      const ka = va.key;
+      const kb = vb.key;
+      // Defensive check for edge cases where hasVertex may be overridden/undefined
+      const hasA = typeof g.hasVertex === 'function' ? g.hasVertex(ka) : false;
+      const hasB = typeof g.hasVertex === 'function' ? g.hasVertex(kb) : false;
       if (hasA && hasB) {
-        const w = (e as any).weight;
-        const val = (e as any).value;
-        const newEdge = (g as any).createEdge(ka, kb, w, val);
-        (g as any)._addEdge(newEdge);
+        const newEdge = g.createEdge(ka, kb, e.weight, e.value);
+        (g as this & { _addEdge(edge: EO): boolean })._addEdge(newEdge);
       }
     }
     return g;

package/src/data-structures/graph/directed-graph.ts

@@ -207,8 +207,8 @@ export class DirectedGraph<
    * @returns DirectedGraph with all keys added.
    * @remarks Time O(V), Space O(V)
    */
-  static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, any, DirectedVertex<K>, DirectedEdge<any>> {
-    const g: DirectedGraph<K, any, DirectedVertex<K>, DirectedEdge<any>> = new DirectedGraph<K, any>({
+  static fromKeys<K extends VertexKey>(keys: Iterable<K>): DirectedGraph<K, undefined, DirectedVertex<K>, DirectedEdge<undefined>> {
+    const g: DirectedGraph<K, undefined, DirectedVertex<K>, DirectedEdge<undefined>> = new DirectedGraph<K, undefined>({
       vertexValueInitializer: (k: VertexKey) => k as K
     });
     for (const k of keys) g.addVertex(k);
@@ -224,8 +224,8 @@ export class DirectedGraph<
    */
   static fromEntries<V>(
     entries: Iterable<[VertexKey, V]>
-  ): DirectedGraph<V, any, DirectedVertex<V>, DirectedEdge<any>> {
-    const g: DirectedGraph<V, any, DirectedVertex<V>, DirectedEdge<any>> = new DirectedGraph<V, any>();
+  ): DirectedGraph<V, undefined, DirectedVertex<V>, DirectedEdge<undefined>> {
+    const g: DirectedGraph<V, undefined, DirectedVertex<V>, DirectedEdge<undefined>> = new DirectedGraph<V, undefined>();
     for (const [k, v] of entries) g.addVertex(k, v);
     return g;
   }

package/src/data-structures/graph/map-graph.ts

@@ -111,7 +111,7 @@ export class MapGraph<
    * @remarks Time O(1), Space O(1)
    */
   protected override _snapshotOptions(): Record<string, unknown> {
-    return { ...(super._snapshotOptions() as any), originCoord: this.originCoord, bottomRight: this.bottomRight };
+    return { ...super._snapshotOptions(), originCoord: this.originCoord, bottomRight: this.bottomRight };
   }
 
   /**

package/src/data-structures/graph/undirected-graph.ts

@@ -232,8 +232,8 @@ export class UndirectedGraph<
    */
   static fromKeys<K extends VertexKey>(
     keys: Iterable<K>
-  ): UndirectedGraph<K, any, UndirectedVertex<K>, UndirectedEdge<any>> {
-    const g: UndirectedGraph<K, any, UndirectedVertex<K>, UndirectedEdge<any>> = new UndirectedGraph<K, any>({
+  ): UndirectedGraph<K, undefined, UndirectedVertex<K>, UndirectedEdge<undefined>> {
+    const g: UndirectedGraph<K, undefined, UndirectedVertex<K>, UndirectedEdge<undefined>> = new UndirectedGraph<K, undefined>({
       vertexValueInitializer: (k: VertexKey) => k as K
     });
     for (const k of keys) g.addVertex(k);
@@ -249,8 +249,8 @@ export class UndirectedGraph<
    */
   static fromEntries<V>(
     entries: Iterable<[VertexKey, V]>
-  ): UndirectedGraph<V, any, UndirectedVertex<V>, UndirectedEdge<any>> {
-    const g: UndirectedGraph<V, any, UndirectedVertex<V>, UndirectedEdge<any>> = new UndirectedGraph<V, any>();
+  ): UndirectedGraph<V, undefined, UndirectedVertex<V>, UndirectedEdge<undefined>> {
+    const g: UndirectedGraph<V, undefined, UndirectedVertex<V>, UndirectedEdge<undefined>> = new UndirectedGraph<V, undefined>();
     for (const [k, v] of entries) g.addVertex(k, v);
     return g;
   }

package/src/data-structures/hash/hash-map.ts

@@ -197,7 +197,7 @@ export class HashMap<K = any, V = any, R = [K, V]> extends IterableEntryBase<K,
     return this._objMap;
   }
 
-  protected _toEntryFn?: (rawElement: R) => [K, V];
+  protected readonly _toEntryFn?: (rawElement: R) => [K, V];
 
   /**
    * Get the raw→entry converter function if present.
@@ -530,7 +530,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
     return this._tail;
   }
 
-  protected _toEntryFn?: (rawElement: R) => [K, V] = (rawElement: R) => {
+  protected readonly _toEntryFn?: (rawElement: R) => [K, V] = (rawElement: R) => {
     if (this.isEntry(rawElement)) {
       return rawElement;
     }
@@ -538,6 +538,7 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
       'If `entryOrRawElements` does not adhere to [key,value], provide `options.toEntryFn` to transform raw records.'
     );
   };
+
   get toEntryFn() {
     return this._toEntryFn;
   }
@@ -712,8 +713,9 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
       const cur = node;
       node = node.next;
       if (predicate(cur.key as K, cur.value as V | undefined, i++, this)) {
-        if (isWeakKey(cur.key as unknown as object)) {
-          this._objMap.delete(cur.key as unknown as object);
+        const keyToCheck: unknown = cur.key;
+        if (isWeakKey(keyToCheck)) {
+          this._objMap.delete(keyToCheck);
         } else {
           const hash = this._hashFn(cur.key as K);
           delete this._noObjMap[hash];

package/src/data-structures/heap/heap.ts

@@ -639,20 +639,17 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     return out;
   }
 
-  protected _DEFAULT_COMPARATOR = (a: E, b: E): number => {
+  protected readonly _DEFAULT_COMPARATOR: Comparator<E> = (a: E, b: E): number => {
     if (typeof a === 'object' || typeof b === 'object') {
       throw TypeError('When comparing object types, define a custom comparator in options.');
     }
-    if ((a as unknown as number) > (b as unknown as number)) return 1;
-    if ((a as unknown as number) < (b as unknown as number)) return -1;
+    if (a > b) return 1;
+    if (a < b) return -1;
     return 0;
   };
 
-  protected _comparator: Comparator<E> = this._DEFAULT_COMPARATOR; /**
-   * Get the comparator used to order elements.
-   * @remarks Time O(1), Space O(1)
-   * @returns Comparator function.
-   */
+  protected readonly _comparator: Comparator<E> = this._DEFAULT_COMPARATOR;
+
   /**
    * Get the comparator used to order elements.
    * @remarks Time O(1), Space O(1)
@@ -706,9 +703,11 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
    */
 
   protected _createInstance(options?: HeapOptions<E, R>): this {
-    const Ctor: any = this.constructor;
-    const next: any = new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
-    return next as this;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<E> | Iterable<R>,
+      options?: HeapOptions<E, R>
+    ) => this;
+    return new Ctor([], { comparator: this.comparator, toElementFn: this.toElementFn, ...(options ?? {}) });
   }
 
   /**
@@ -725,8 +724,11 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     elements: Iterable<EM> | Iterable<RM> = [],
     options?: HeapOptions<EM, RM>
   ): Heap<EM, RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as Heap<EM, RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<EM> | Iterable<RM>,
+      options?: HeapOptions<EM, RM>
+    ) => Heap<EM, RM>;
+    return new Ctor(elements, options);
   }
 
   /**
@@ -813,7 +815,8 @@ export class FibonacciHeap<E> {
     return this._min;
   }
 
-  protected _comparator: Comparator<E>;
+  protected readonly _comparator: Comparator<E>;
+
   get comparator(): Comparator<E> {
     return this._comparator;
   }

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -182,7 +182,7 @@ export class DoublyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     console.log(foundEntry?.value); // 'Bob';
  */
 export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, DoublyLinkedListNode<E>> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a DoublyLinkedList and optionally bulk-insert elements.
@@ -423,8 +423,8 @@ export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, D
   at(index: number): E | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
-    return current!.value;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
   }
 
   /**
@@ -437,7 +437,7 @@ export class DoublyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, D
   getNodeAt(index: number): DoublyLinkedListNode<E> | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
+    for (let i = 0; i < index && current; i++) current = current.next;
     return current;
   }
 

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -246,7 +246,7 @@ export class SinglyLinkedListNode<E = any> extends LinkedListNode<E> {
  *     console.log(editor.getText()); // 'Haello';
  */
 export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, SinglyLinkedListNode<E>> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a SinglyLinkedList and optionally bulk-insert elements.
@@ -381,8 +381,8 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
       return value;
     }
     let current = this.head;
-    while (current.next !== this.tail) current = current.next!;
-    const value = this.tail!.value;
+    while (current.next && current.next !== this.tail) current = current.next;
+    const value = this.tail?.value;
     current.next = undefined;
     this._tail = current;
     this._length--;
@@ -484,8 +484,8 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
   at(index: number): E | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
-    return current!.value;
+    for (let i = 0; i < index && current; i++) current = current.next;
+    return current?.value;
   }
 
   /**
@@ -511,7 +511,7 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
   getNodeAt(index: number): SinglyLinkedListNode<E> | undefined {
     if (index < 0 || index >= this._length) return undefined;
     let current = this.head;
-    for (let i = 0; i < index; i++) current = current!.next;
+    for (let i = 0; i < index && current; i++) current = current.next;
     return current;
   }
 
@@ -1003,7 +1003,10 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
    */
 
   protected _createInstance(options?: SinglyLinkedListOptions<E, R>): this {
-    const Ctor: any = this.constructor;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<E> | Iterable<R> | Iterable<SinglyLinkedListNode<E>>,
+      options?: SinglyLinkedListOptions<E, R>
+    ) => this;
     return new Ctor([], options);
   }
 
@@ -1021,8 +1024,11 @@ export class SinglyLinkedList<E = any, R = any> extends LinearLinkedBase<E, R, S
     elements: Iterable<EM> | Iterable<RM> | Iterable<SinglyLinkedListNode<EM>> = [],
     options?: SinglyLinkedListOptions<EM, RM>
   ): SinglyLinkedList<EM, RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as SinglyLinkedList<EM, RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<EM> | Iterable<RM> | Iterable<SinglyLinkedListNode<EM>>,
+      options?: SinglyLinkedListOptions<EM, RM>
+    ) => SinglyLinkedList<EM, RM>;
+    return new Ctor(elements, options);
   }
 
   /**

package/src/data-structures/queue/deque.ts

@@ -144,7 +144,7 @@ import { LinearBase } from '../base/linear-base';
  *     console.log(dataWindow.length); // 3;
  */
 export class Deque<E = any, R = any> extends LinearBase<E, R> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a Deque and optionally bulk-insert elements.

package/src/data-structures/stack/stack.ts

@@ -161,7 +161,7 @@ import { IterableElementBase } from '../base';
  *     console.log(stack.elements.join('/')); // 'c';
  */
 export class Stack<E = any, R = any> extends IterableElementBase<E, R> {
-  protected _equals: (a: E, b: E) => boolean = Object.is as unknown as (a: E, b: E) => boolean;
+  protected _equals: (a: E, b: E) => boolean = (a, b) => Object.is(a, b);
 
   /**
    * Create a Stack and optionally bulk-push elements.

package/src/data-structures/trie/trie.ts

@@ -684,13 +684,15 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    */
 
   protected _createInstance(options?: TrieOptions<R>): this {
-    const Ctor: any = this.constructor;
-    const next: any = new Ctor([], {
+    const Ctor = this.constructor as new (
+      elements?: Iterable<string> | Iterable<R>,
+      options?: TrieOptions<R>
+    ) => this;
+    return new Ctor([], {
       toElementFn: this.toElementFn,
       caseSensitive: this.caseSensitive,
       ...(options ?? {})
     });
-    return next as this;
   }
 
   /**
@@ -703,8 +705,11 @@ export class Trie<R = any> extends IterableElementBase<string, R> {
    */
 
   protected _createLike<RM>(elements: Iterable<string> | Iterable<RM> = [], options?: TrieOptions<RM>): Trie<RM> {
-    const Ctor: any = this.constructor;
-    return new Ctor(elements, options) as Trie<RM>;
+    const Ctor = this.constructor as new (
+      elements?: Iterable<string> | Iterable<RM>,
+      options?: TrieOptions<RM>
+    ) => Trie<RM>;
+    return new Ctor(elements, options);
   }
 
   /**

package/src/types/data-structures/binary-tree/avl-tree.ts

@@ -1,3 +1,3 @@
 import { BSTOptions } from './bst';
 
-export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type AVLTreeOptions<K, V, R> = BSTOptions<K, V, R>;

package/src/types/data-structures/binary-tree/red-black-tree.ts

@@ -2,4 +2,4 @@ import type { BSTOptions } from './bst';
 
 export type RBTNColor = 'RED' | 'BLACK';
 
-export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RedBlackTreeOptions<K, V, R> = BSTOptions<K, V, R>;

package/src/types/data-structures/linked-list/doubly-linked-list.ts

@@ -1,3 +1,3 @@
 import { LinearBaseOptions } from '../base';
 
-export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type DoublyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/src/types/data-structures/linked-list/singly-linked-list.ts

@@ -1,3 +1,3 @@
 import { LinearBaseOptions } from '../base';
 
-export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R> & {};
+export type SinglyLinkedListOptions<E, R> = LinearBaseOptions<E, R>;

package/src/types/data-structures/priority-queue/priority-queue.ts

@@ -1,3 +1,3 @@
 import { HeapOptions } from '../heap';
 
-export type PriorityQueueOptions<E, R> = HeapOptions<E, R> & {};
+export type PriorityQueueOptions<E, R> = HeapOptions<E, R>;

package/src/types/data-structures/stack/stack.ts

@@ -1,3 +1,3 @@
 import { IterableElementBaseOptions } from '../base';
 
-export type StackOptions<E, R> = IterableElementBaseOptions<E, R> & {};
+export type StackOptions<E, R> = IterableElementBaseOptions<E, R>;