data-structure-typed 2.4.3 → 2.4.5

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

@@ -9,6 +9,7 @@
  */
 
 import type { Comparator, TreeMultiSetOptions } from '../../types';
+import { ERR } from '../../common';
 import { RedBlackTree } from './red-black-tree';
 import { TreeSet } from './tree-set';
 
@@ -50,18 +51,18 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
     if (!this.#isDefaultComparator) return;
 
     if (typeof key === 'number') {
-      if (Number.isNaN(key)) throw new TypeError('TreeMultiSet: NaN is not a valid key');
+      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN('TreeMultiSet'));
       return;
     }
 
     if (typeof key === 'string') return;
 
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError('TreeMultiSet: invalid Date key');
+      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate('TreeMultiSet'));
       return;
     }
 
-    throw new TypeError('TreeMultiSet: comparator is required for non-number/non-string/non-Date keys');
+    throw new TypeError(ERR.comparatorRequired('TreeMultiSet'));
   }
 
   /**
@@ -69,7 +70,7 @@ export class TreeMultiSet<K = any, R = K> implements Iterable<K> {
    * @remarks Time O(1), Space O(1)
    */
   private _validateCount(n: number): void {
-    if (!Number.isSafeInteger(n) || n < 0) throw new RangeError('TreeMultiSet: count must be a safe integer >= 0');
+    if (!Number.isSafeInteger(n) || n < 0) throw new RangeError(ERR.invalidArgument('count must be a safe integer >= 0.', 'TreeMultiSet'));
   }
 
   /**
@@ -247,7 +248,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 +399,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 +444,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 +465,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 +487,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

@@ -9,6 +9,7 @@
 
 import type { Comparator } from '../../types';
 import type { TreeSetElementCallback, TreeSetOptions, TreeSetRangeOptions, TreeSetReduceCallback } from '../../types';
+import { ERR } from '../../common';
 import { RedBlackTree } from './red-black-tree';
 
 /**
@@ -66,7 +67,7 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
     return (a: K, b: K): number => {
       // numbers
       if (typeof a === 'number' && typeof b === 'number') {
-        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError('TreeSet: NaN is not a valid key');
+        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN('TreeSet'));
         // treat -0 and 0 as equal
         const aa = Object.is(a, -0) ? 0 : a;
         const bb = Object.is(b, -0) ? 0 : b;
@@ -82,11 +83,11 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
       if (a instanceof Date && b instanceof Date) {
         const ta = a.getTime();
         const tb = b.getTime();
-        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError('TreeSet: invalid Date key');
+        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate('TreeSet'));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
 
-      throw new TypeError('TreeSet: comparator is required for non-number/non-string/non-Date keys');
+      throw new TypeError(ERR.comparatorRequired('TreeSet'));
     };
   }
 
@@ -108,19 +109,19 @@ export class TreeSet<K = any, R = K> implements Iterable<K> {
     if (!this.#isDefaultComparator) return;
 
     if (typeof key === 'number') {
-      if (Number.isNaN(key)) throw new TypeError('TreeSet: NaN is not a valid key');
+      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN('TreeSet'));
       return;
     }
 
     if (typeof key === 'string') return;
 
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError('TreeSet: invalid Date key');
+      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate('TreeSet'));
       return;
     }
 
     // Other key types should have provided a comparator, so reaching here means misuse.
-    throw new TypeError('TreeSet: comparator is required for non-number/non-string/non-Date keys');
+    throw new TypeError(ERR.comparatorRequired('TreeSet'));
   }
 
   /**

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

@@ -8,6 +8,7 @@
 
 import type { DijkstraResult, EntryCallback, GraphOptions, VertexKey } from '../../types';
 import { uuidV4 } from '../../utils';
+import { ERR } from '../../common';
 import { IterableEntryBase } from '../base';
 import { IGraph } from '../../interfaces';
 import { Heap } from '../heap';
@@ -65,7 +66,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 ?? {}) };
   }
 
@@ -274,7 +275,7 @@ export abstract class AbstractGraph<
         const newEdge = this.createEdge(srcOrEdge, dest, weight, value);
         return this._addEdge(newEdge);
       } else {
-        throw new Error('dest must be a Vertex or vertex key while srcOrEdge is an Edge');
+        throw new TypeError(ERR.invalidArgument('dest must be a Vertex or vertex key when srcOrEdge is an Edge.', 'Graph'));
       }
     }
   }
@@ -984,11 +985,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 +1011,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;
@@ -1078,4 +1079,108 @@ export abstract class AbstractGraph<
   protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey {
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
+
+  /**
+   * The edge connector string used in visual output.
+   * Override in subclasses (e.g., '--' for undirected, '->' for directed).
+   */
+  protected get _edgeConnector(): string {
+    return '--';
+  }
+
+  /**
+   * Generate a text-based visual representation of the graph.
+   *
+   * **Adjacency list format:**
+   * ```
+   * Graph (5 vertices, 6 edges):
+   * A -> B (1), C (2)
+   * B -> D (3)
+   * C -> (no outgoing edges)
+   * D -> A (1)
+   * E (isolated)
+   * ```
+   *
+   * @param options - Optional display settings.
+   * @param options.showWeight - Whether to show edge weights (default: true).
+   * @returns The visual string.
+   */
+  override toVisual(options?: { showWeight?: boolean }): string {
+    const showWeight = options?.showWeight ?? true;
+    const vertices = [...this._vertexMap.values()];
+    const vertexCount = vertices.length;
+    const edgeCount = this.edgeSet().length;
+
+    const lines: string[] = [`Graph (${vertexCount} vertices, ${edgeCount} edges):`];
+
+    for (const vertex of vertices) {
+      const neighbors = this.getNeighbors(vertex);
+      if (neighbors.length === 0) {
+        lines.push(`  ${vertex.key} (isolated)`);
+      } else {
+        const edgeStrs = neighbors.map(neighbor => {
+          const edge = this.getEdge(vertex, neighbor);
+          if (edge && showWeight && edge.weight !== undefined && edge.weight !== 1) {
+            return `${neighbor.key} (${edge.weight})`;
+          }
+          return `${neighbor.key}`;
+        });
+        lines.push(`  ${vertex.key} ${this._edgeConnector} ${edgeStrs.join(', ')}`);
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Generate DOT language representation for Graphviz.
+   *
+   * @param options - Optional display settings.
+   * @param options.name - Graph name (default: 'G').
+   * @param options.showWeight - Whether to label edges with weight (default: true).
+   * @returns DOT format string.
+   */
+  toDot(options?: { name?: string; showWeight?: boolean }): string {
+    const name = options?.name ?? 'G';
+    const showWeight = options?.showWeight ?? true;
+    const isDirected = this._edgeConnector === '->';
+    const graphType = isDirected ? 'digraph' : 'graph';
+    const edgeOp = isDirected ? '->' : '--';
+
+    const lines: string[] = [`${graphType} ${name} {`];
+
+    // Add all vertices (ensures isolated vertices appear)
+    for (const vertex of this._vertexMap.values()) {
+      lines.push(`  "${vertex.key}";`);
+    }
+
+    // Add edges
+    const visited = new Set<string>();
+    for (const vertex of this._vertexMap.values()) {
+      for (const neighbor of this.getNeighbors(vertex)) {
+        const edgeId = isDirected
+          ? `${vertex.key}->${neighbor.key}`
+          : [vertex.key, neighbor.key].sort().join('--');
+        if (visited.has(edgeId)) continue;
+        visited.add(edgeId);
+
+        const edge = this.getEdge(vertex, neighbor);
+        const label = edge && showWeight && edge.weight !== undefined && edge.weight !== 1
+          ? ` [label="${edge.weight}"]`
+          : '';
+        lines.push(`  "${vertex.key}" ${edgeOp} "${neighbor.key}"${label};`);
+      }
+    }
+
+    lines.push('}');
+    return lines.join('\n');
+  }
+
+  /**
+   * Print the graph to console.
+   * @param options - Display settings passed to `toVisual`.
+   */
+  override print(options?: { showWeight?: boolean }): void {
+    console.log(this.toVisual(options));
+  }
 }

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

@@ -180,6 +180,10 @@ export class DirectedGraph<
     super(options);
   }
 
+  protected override get _edgeConnector(): string {
+    return '->';
+  }
+
   protected _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get outEdgeMap(): Map<VO, EO[]> {
@@ -207,8 +211,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 +228,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;
   }
@@ -566,6 +566,101 @@ export class UndirectedGraph<
     };
   }
 
+  /**
+   * Find biconnected components using edge-stack Tarjan variant.
+   * A biconnected component is a maximal biconnected subgraph.
+   * @returns Array of edge arrays, each representing a biconnected component.
+   * @remarks Time O(V + E), Space O(V + E)
+   */
+  getBiconnectedComponents(): EO[][] {
+    const dfn = new Map<VO, number>();
+    const low = new Map<VO, number>();
+    const edgeStack: EO[] = [];
+    const components: EO[][] = [];
+    let time = 0;
+
+    const dfs = (vertex: VO, parent: VO | undefined) => {
+      dfn.set(vertex, time);
+      low.set(vertex, time);
+      time++;
+
+      const neighbors = this.getNeighbors(vertex);
+      let childCount = 0;
+
+      for (const neighbor of neighbors) {
+        const edge = this.getEdge(vertex, neighbor);
+        if (!edge) continue;
+
+        if (!dfn.has(neighbor)) {
+          childCount++;
+          edgeStack.push(edge);
+          dfs(neighbor, vertex);
+          low.set(vertex, Math.min(low.get(vertex)!, low.get(neighbor)!));
+
+          // Articulation point found — pop edges to form a component
+          if (
+            (parent === undefined && childCount > 1) ||
+            (parent !== undefined && low.get(neighbor)! >= dfn.get(vertex)!)
+          ) {
+            const component: EO[] = [];
+            let e: EO | undefined;
+            do {
+              e = edgeStack.pop();
+              if (e) component.push(e);
+            } while (e && e !== edge);
+            if (component.length > 0) components.push(component);
+          }
+        } else if (neighbor !== parent && dfn.get(neighbor)! < dfn.get(vertex)!) {
+          // Back edge (only push once per undirected edge)
+          edgeStack.push(edge);
+          low.set(vertex, Math.min(low.get(vertex)!, dfn.get(neighbor)!));
+        }
+      }
+    };
+
+    for (const vertex of this.vertexMap.values()) {
+      if (!dfn.has(vertex)) {
+        dfs(vertex, undefined);
+        // Remaining edges form a component
+        if (edgeStack.length > 0) {
+          components.push([...edgeStack]);
+          edgeStack.length = 0;
+        }
+      }
+    }
+
+    return components;
+  }
+
+  /**
+   * Detect whether the graph contains a cycle.
+   * Uses DFS with parent tracking.
+   * @returns `true` if a cycle exists, `false` otherwise.
+   * @remarks Time O(V + E), Space O(V)
+   */
+  hasCycle(): boolean {
+    const visited = new Set<VO>();
+
+    const dfs = (vertex: VO, parent: VO | undefined): boolean => {
+      visited.add(vertex);
+      for (const neighbor of this.getNeighbors(vertex)) {
+        if (!visited.has(neighbor)) {
+          if (dfs(neighbor, vertex)) return true;
+        } else if (neighbor !== parent) {
+          return true; // back edge = cycle
+        }
+      }
+      return false;
+    };
+
+    for (const vertex of this.vertexMap.values()) {
+      if (!visited.has(vertex)) {
+        if (dfs(vertex, undefined)) return true;
+      }
+    }
+    return false;
+  }
+
   /**
    * Get bridges discovered by `tarjan()`.
    * @returns Array of edges that are bridges.

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

@@ -15,6 +15,7 @@ import type {
 } from '../../types';
 import { IterableEntryBase } from '../base';
 import { isWeakKey, rangeCheck } from '../../utils';
+import { ERR } from '../../common';
 
 /**
  * Hash-based map. Supports object keys and custom hashing; offers O(1) average set/get/has.
@@ -197,7 +198,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,14 +531,15 @@ 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;
     }
-    throw new Error(
-      'If `entryOrRawElements` does not adhere to [key,value], provide `options.toEntryFn` to transform raw records.'
+    throw new TypeError(
+      ERR.invalidArgument('If elements do not adhere to [key, value], provide options.toEntryFn to transform raw records.', 'HashMap')
     );
   };
+
   get toEntryFn() {
     return this._toEntryFn;
   }
@@ -712,8 +714,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];
@@ -795,6 +798,16 @@ export class LinkedHashMap<K = any, V = any, R = [K, V]> extends IterableEntryBa
   }
 
   protected _deleteNode(node: HashMapLinkedNode<K, V | undefined>): boolean {
+    // Remove from hash table
+    const key: unknown = node.key;
+    if (isWeakKey(key)) {
+      this._objMap.delete(key);
+    } else {
+      const hash = this._hashFn(key as K);
+      delete this._noObjMap[hash];
+    }
+
+    // Remove from linked list
     const { prev, next } = node;
     prev.next = next;
     next.prev = prev;

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

@@ -8,6 +8,7 @@
 
 import type { Comparator, DFSOrderPattern, ElementCallback, HeapOptions } from '../../types';
 import { IterableElementBase } from '../base';
+import { ERR } from '../../common';
 
 /**
  * Binary heap with pluggable comparator; supports fast insertion and removal of the top element.
@@ -611,7 +612,7 @@ export class Heap<E = any, R = any> extends IterableElementBase<E, R> {
     thisArg?: unknown
   ): Heap<EM, RM> {
     const { comparator, toElementFn, ...rest } = options ?? {};
-    if (!comparator) throw new TypeError('Heap.map requires options.comparator for EM');
+    if (!comparator) throw new TypeError(ERR.comparatorRequired('Heap.map'));
     const out = this._createLike<EM, RM>([], { ...rest, comparator, toElementFn });
     let i = 0;
     for (const x of this) {
@@ -639,20 +640,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.');
+      throw new TypeError(ERR.comparatorRequired('Heap'));
     }
-    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 +704,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 +725,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);
   }
 
   /**
@@ -781,7 +784,7 @@ export class FibonacciHeap<E> {
   constructor(comparator?: Comparator<E>) {
     this.clear();
     this._comparator = comparator || this._defaultComparator;
-    if (typeof this.comparator !== 'function') throw new Error('FibonacciHeap: comparator must be a function.');
+    if (typeof this.comparator !== 'function') throw new TypeError(ERR.notAFunction('comparator', 'FibonacciHeap'));
   }
 
   protected _root?: FibonacciHeapNode<E>;
@@ -813,7 +816,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/heap/max-heap.ts

@@ -6,6 +6,7 @@
  */
 import type { HeapOptions } from '../../types';
 import { Heap } from './heap';
+import { ERR } from '../../common';
 
 /**
  * @template E
@@ -33,9 +34,7 @@ export class MaxHeap<E = any, R = any> extends Heap<E, R> {
     super(elements, {
       comparator: (a: E, b: E): number => {
         if (typeof a === 'object' || typeof b === 'object') {
-          throw TypeError(
-            `When comparing object types, a custom comparator must be defined in the constructor's options parameter.`
-          );
+          throw new TypeError(ERR.comparatorRequired('MaxHeap'));
         }
         if (a < b) return 1;
         if (a > b) return -1;