data-structure-typed 2.4.3 → 2.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "data-structure-typed",
-  "version": "2.4.3",
+  "version": "2.4.5",
   "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.2",
+    "data-structure-typed": "^2.4.4",
     "dependency-cruiser": "^16.5.0",
     "doctoc": "^2.2.1",
     "eslint": "^9.13.0",

package/src/common/error.ts

@@ -0,0 +1,60 @@
+/**
+ * Centralized error message templates.
+ * Keep using native Error/TypeError/RangeError — this only standardizes messages.
+ */
+export const ERR = {
+  // Range / index
+  indexOutOfRange: (index: number, min: number, max: number, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Index ${index} is out of range [${min}, ${max}].`,
+
+  invalidIndex: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Index must be an integer.`,
+
+  // Type / argument
+  invalidArgument: (reason: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${reason}`,
+
+  comparatorRequired: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Comparator is required for non-number/non-string/non-Date keys.`,
+
+  invalidKey: (reason: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${reason}`,
+
+  notAFunction: (name: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${name} must be a function.`,
+
+  invalidEntry: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Each entry must be a [key, value] tuple.`,
+
+  invalidNaN: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}NaN is not a valid key.`,
+
+  invalidDate: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Invalid Date key.`,
+
+  reduceEmpty: (ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Reduce of empty structure with no initial value.`,
+
+  callbackReturnType: (expected: string, got: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}Callback must return ${expected}; got ${got}.`,
+
+  // State / operation
+  invalidOperation: (reason: string, ctx?: string) =>
+    `${ctx ? ctx + ': ' : ''}${reason}`,
+
+  // Matrix
+  matrixDimensionMismatch: (op: string) =>
+    `Matrix: Dimensions must be compatible for ${op}.`,
+
+  matrixSingular: () =>
+    'Matrix: Singular matrix, inverse does not exist.',
+
+  matrixNotSquare: () =>
+    'Matrix: Must be square for inversion.',
+
+  matrixNotRectangular: () =>
+    'Matrix: Must be rectangular for transposition.',
+
+  matrixRowMismatch: (expected: number, got: number) =>
+    `Matrix: Expected row length ${expected}, but got ${got}.`
+} as const;

package/src/common/index.ts

@@ -1,3 +1,5 @@
+export { ERR } from './error';
+
 export enum DFSOperation {
   VISIT = 0,
   PROCESS = 1

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

@@ -1,4 +1,5 @@
 import type { ElementCallback, IterableElementBaseOptions, ReduceElementCallback } from '../../types';
+import { ERR } from '../../common';
 
 /**
  * Base class that makes a data structure iterable and provides common
@@ -25,7 +26,7 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
     if (options) {
       const { toElementFn } = options;
       if (typeof toElementFn === 'function') this._toElementFn = toElementFn;
-      else if (toElementFn) throw new TypeError('toElementFn must be a function type');
+      else if (toElementFn) throw new TypeError(ERR.notAFunction('toElementFn'));
     }
   }
 
@@ -35,7 +36,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.
@@ -224,12 +225,12 @@ export abstract class IterableElementBase<E, R> implements Iterable<E> {
       acc = initialValue as U;
     } else {
       const first = iter.next();
-      if (first.done) throw new TypeError('Reduce of empty structure with no initial value');
+      if (first.done) throw new TypeError(ERR.reduceEmpty());
       acc = first.value as unknown as U;
       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-indexed-tree.ts

@@ -6,6 +6,7 @@
  * @license MIT License
  */
 import { getMSB } from '../../utils';
+import { ERR } from '../../common';
 
 /**
  *
@@ -124,7 +125,7 @@ export class BinaryIndexedTree {
    */
   read(count: number): number {
     if (!Number.isInteger(count)) {
-      throw new Error('Invalid count');
+      throw new Error(ERR.invalidArgument('count must be an integer', 'BinaryIndexedTree'));
     }
     return this._read(Math.max(Math.min(count, this.max), 0));
   }
@@ -137,7 +138,7 @@ export class BinaryIndexedTree {
    */
   lowerBound(sum: number): number {
     if (this.negativeCount > 0) {
-      throw new Error('Sequence is not non-descending');
+      throw new Error(ERR.invalidOperation('Sequence is not non-descending.', 'BinaryIndexedTree'));
     }
     return this._binarySearch(sum, (x, y) => x < y);
   }
@@ -151,7 +152,7 @@ export class BinaryIndexedTree {
    */
   upperBound(sum: number): number {
     if (this.negativeCount > 0) {
-      throw new Error('Must not be descending');
+      throw new Error(ERR.invalidOperation('Sequence must not be descending.', 'BinaryIndexedTree'));
     }
     return this._binarySearch(sum, (x, y) => x <= y);
   }
@@ -209,10 +210,10 @@ export class BinaryIndexedTree {
    */
   protected _checkIndex(index: number): void {
     if (!Number.isInteger(index)) {
-      throw new Error('Invalid index: Index must be an integer.');
+      throw new TypeError(ERR.invalidIndex('BinaryIndexedTree'));
     }
     if (index < 0 || index >= this.max) {
-      throw new Error('Index out of range: Index must be within the range [0, this.max).');
+      throw new RangeError(ERR.indexOutOfRange(index, 0, this.max - 1, 'BinaryIndexedTree'));
     }
   }
 

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

@@ -28,7 +28,7 @@ import { IBinaryTree } from '../../interfaces';
 import { isComparable, makeTrampoline, makeTrampolineThunk } from '../../utils';
 import { Queue } from '../queue';
 import { IterableEntryBase } from '../base';
-import { DFSOperation, Range } from '../../common';
+import { DFSOperation, ERR, Range } from '../../common';
 
 /**
  * @template K - The type of the key.
@@ -371,13 +371,13 @@ export class BinaryTree<K = any, V = any, R = any>
       if (isMapMode !== undefined) this._isMapMode = isMapMode;
       if (isDuplicate !== undefined) this._isDuplicate = isDuplicate;
       if (typeof toEntryFn === 'function') this._toEntryFn = toEntryFn;
-      else if (toEntryFn) throw TypeError('toEntryFn must be a function type');
+      else if (toEntryFn) throw new TypeError(ERR.notAFunction('toEntryFn', 'BinaryTree'));
     }
 
     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.
@@ -670,7 +670,7 @@ export class BinaryTree<K = any, V = any, R = any>
     if (!this._root) {
       this._setRoot(newNode);
       if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
-      this._size = 1;
+      if (newNode !== null) this._size = 1;
       return true;
     }
 
@@ -708,7 +708,7 @@ export class BinaryTree<K = any, V = any, R = any>
         potentialParent.right = newNode;
       }
       if (this._isMapMode && newNode !== null && newNode !== undefined) this._store.set(newNode.key, newNode);
-      this._size++;
+      if (newNode !== null) this._size++;
       return true;
     }
 
@@ -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);
       }
@@ -1605,7 +1605,7 @@ export class BinaryTree<K = any, V = any, R = any>
 
   /**
    * Finds all leaf nodes in the tree.
-   * @remarks Time O(N), visits every node. Space O(H) for recursive stack or O(N) for iterative queue.
+   * @remarks Time O(N), visits every node. Space O(H) for recursive or iterative stack.
    *
    * @template C - The type of the callback function.
    * @param [callback=this._DEFAULT_NODE_CALLBACK] - Function to call on each leaf node.
@@ -1636,17 +1636,18 @@ export class BinaryTree<K = any, V = any, R = any>
 
       dfs(startNode);
     } else {
-      // BFS-based
-      const queue = new Queue([startNode]);
+      // DFS-based (stack) to match recursive order
+      const stack = [startNode];
 
-      while (queue.length > 0) {
-        const cur = queue.shift();
+      while (stack.length > 0) {
+        const cur = stack.pop()!;
         if (this.isRealNode(cur)) {
           if (this.isLeaf(cur)) {
             leaves.push(callback(cur));
           }
-          if (this.isRealNode(cur.left)) queue.push(cur.left);
-          if (this.isRealNode(cur.right)) queue.push(cur.right);
+          // Push right first so left is processed first (LIFO)
+          if (this.isRealNode(cur.right)) stack.push(cur.right);
+          if (this.isRealNode(cur.left)) stack.push(cur.left);
         }
       }
     }
@@ -2136,7 +2137,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.
@@ -2257,40 +2259,60 @@ export class BinaryTree<K = any, V = any, R = any>
     options: BinaryTreePrintOptions
   ): NodeDisplayLayout {
     const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
-    const emptyDisplayLayout = <NodeDisplayLayout>[['─'], 1, 0, 0]; // Represents an empty spot
-
-    if (node === null && !isShowNull) {
-      return emptyDisplayLayout;
-    } else if (node === undefined && !isShowUndefined) {
-      return emptyDisplayLayout;
-    } else if (this.isNIL(node) && !isShowRedBlackNIL) {
-      return emptyDisplayLayout;
-    } else if (node !== null && node !== undefined) {
-      // Real node
-      const key = node.key,
-        line = this.isNIL(node) ? 'S' : String(key),
-        width = line.length;
-
-      return _buildNodeDisplay(
-        line,
-        width,
-        this._displayAux(node.left, options),
-        this._displayAux(node.right, options)
-      );
-    } else {
-      // Null or Undefined
-      const line = node === undefined ? 'U' : 'N',
-        width = line.length;
+    const emptyDisplayLayout = <NodeDisplayLayout>[['─'], 1, 0, 0];
+
+    // Iterative post-order: compute display layout bottom-up using an explicit stack.
+    // Stages: 0=process left, 1=process right, 2=merge
+    type Frame = {
+      node: BinaryTreeNode<K, V> | null | undefined;
+      stage: 0 | 1 | 2;
+      leftLayout: NodeDisplayLayout;
+      rightLayout: NodeDisplayLayout;
+    };
+
+    const newFrame = (n: BinaryTreeNode<K, V> | null | undefined): Frame => ({
+      node: n, stage: 0, leftLayout: emptyDisplayLayout, rightLayout: emptyDisplayLayout
+    });
 
-      // Treat as a leaf
-      return _buildNodeDisplay(line, width, [[''], 1, 0, 0], [[''], 1, 0, 0]);
+    const stack: Frame[] = [newFrame(node)];
+    let result: NodeDisplayLayout = emptyDisplayLayout;
+
+    const setChildResult = (layout: NodeDisplayLayout) => {
+      if (stack.length === 0) { result = layout; return; }
+      const parent = stack[stack.length - 1];
+      if (parent.stage === 1) parent.leftLayout = layout;
+      else parent.rightLayout = layout;
+    };
+
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      const cur = frame.node;
+
+      if (frame.stage === 0) {
+        // Leaf / empty node — resolve immediately
+        if (this._isDisplayLeaf(cur, options)) {
+          stack.pop();
+          const layout = this._resolveDisplayLeaf(cur, options, emptyDisplayLayout);
+          setChildResult(layout);
+          continue;
+        }
+        frame.stage = 1;
+        stack.push(newFrame(cur!.left));
+      } else if (frame.stage === 1) {
+        frame.stage = 2;
+        stack.push(newFrame(cur!.right));
+      } else {
+        stack.pop();
+        const line = this.isNIL(cur) ? 'S' : String(cur!.key);
+        const layout = BinaryTree._buildNodeDisplay(line, line.length, frame.leftLayout, frame.rightLayout);
+        setChildResult(layout);
+      }
     }
 
-    /**
-     * (Inner) Builds the display lines for a node.
-     * @remarks Time/Space: Proportional to the width and height of the subtrees.
-     */
-    function _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
+    return result;
+  }
+
+  protected static _buildNodeDisplay(line: string, width: number, left: NodeDisplayLayout, right: NodeDisplayLayout) {
       const [leftLines, leftWidth, leftHeight, leftMiddle] = left;
       const [rightLines, rightWidth, rightHeight, rightMiddle] = right;
       const firstLine =
@@ -2323,7 +2345,57 @@ export class BinaryTree<K = any, V = any, R = any>
         Math.max(leftHeight, rightHeight) + 2,
         leftWidth + Math.floor(width / 2)
       ];
+  }
+
+  /**
+   * Check if a node is a display leaf (empty, null, undefined, NIL, or real leaf).
+   */
+  protected _isDisplayLeaf(
+    node: BinaryTreeNode<K, V> | null | undefined,
+    options: BinaryTreePrintOptions
+  ): boolean {
+    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+    // Empty/hidden nodes are always leaves
+    if (node === null && !isShowNull) return true;
+    if (node === undefined && !isShowUndefined) return true;
+    if (this.isNIL(node) && !isShowRedBlackNIL) return true;
+    // Shown null/undefined are leaves (no children to recurse into)
+    if (node === null || node === undefined) return true;
+    // Real node: check if it has any children that would be displayed
+    const hasDisplayableLeft = this._hasDisplayableChild(node.left, options);
+    const hasDisplayableRight = this._hasDisplayableChild(node.right, options);
+    return !hasDisplayableLeft && !hasDisplayableRight;
+  }
+
+  protected _hasDisplayableChild(
+    child: BinaryTreeNode<K, V> | null | undefined,
+    options: BinaryTreePrintOptions
+  ): boolean {
+    if (child === null) return !!options.isShowNull;
+    if (child === undefined) return !!options.isShowUndefined;
+    if (this.isNIL(child)) return !!options.isShowRedBlackNIL;
+    return true; // real node is always displayable
+  }
+
+  /**
+   * Resolve a display leaf node to its layout.
+   */
+  protected _resolveDisplayLeaf(
+    node: BinaryTreeNode<K, V> | null | undefined,
+    options: BinaryTreePrintOptions,
+    emptyDisplayLayout: NodeDisplayLayout
+  ): NodeDisplayLayout {
+    const { isShowNull, isShowUndefined, isShowRedBlackNIL } = options;
+    if (node === null && !isShowNull) return emptyDisplayLayout;
+    if (node === undefined && !isShowUndefined) return emptyDisplayLayout;
+    if (this.isNIL(node) && !isShowRedBlackNIL) return emptyDisplayLayout;
+    if (node !== null && node !== undefined) {
+      const line = this.isNIL(node) ? 'S' : String(node.key);
+      return BinaryTree._buildNodeDisplay(line, line.length, emptyDisplayLayout, emptyDisplayLayout);
     }
+    // Shown null / undefined
+    const line = node === undefined ? 'U' : 'N';
+    return BinaryTree._buildNodeDisplay(line, line.length, [[''], 1, 0, 0], [[''], 1, 0, 0]);
   }
 
   /**

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

@@ -26,7 +26,7 @@ import { BinaryTree } from './binary-tree';
 import { IBinaryTree } from '../../interfaces';
 import { Queue } from '../queue';
 import { isComparable } from '../../utils';
-import { Range } from '../../common';
+import { ERR, Range } from '../../common';
 
 /**
  * Represents a Node in a Binary Search Tree.
@@ -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.
@@ -1523,10 +1523,18 @@ export class BST<K = any, V = any, R = any> extends BinaryTree<K, V, R> implemen
         return 0;
       }
 
+      // Date keys: compare by getTime()
+      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(ERR.invalidDate('BST'));
+        return ta > tb ? 1 : ta < tb ? -1 : 0;
+      }
+
       // If keys are objects and no comparator is provided, throw an error
       if (typeof a === 'object' || typeof b === 'object') {
-        throw TypeError(
-          `When comparing object type keys, a custom comparator must be provided in the constructor's options!`
+        throw new TypeError(
+          ERR.comparatorRequired('BST')
         );
       }
 

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

@@ -13,6 +13,7 @@ import type {
   FamilyPosition, NodePredicate,
   OptNode,
   RBTNColor,
+  IterationType,
   RedBlackTreeOptions
 } from '../../types';
 import { BST } from './bst';
@@ -918,6 +919,25 @@ export class RedBlackTree<K = any, V = any, R = any> extends BST<K, V, R> implem
    * @param [thisArg] - See parameter type for details.
    * @returns A new RedBlackTree with mapped entries.
    */
+  /**
+   * Red-Black trees are self-balancing — `perfectlyBalance` rebuilds via
+   * sorted bulk insert, which naturally produces a balanced RBT.
+   * @remarks Time O(N), Space O(N)
+   */
+  override perfectlyBalance(iterationType?: IterationType): boolean {
+    // Extract sorted entries, clear, re-insert — RBT self-balances on insert
+    const entries: [K, V | undefined][] = [];
+    for (const [key, value] of this) entries.push([key, value]);
+    if (entries.length <= 1) return true;
+    this.clear();
+    this.setMany(
+      entries.map(([k]) => k),
+      entries.map(([, v]) => v),
+      true // isBalanceAdd
+    );
+    return true;
+  }
+
   override map<MK = K, MV = V, MR = any>(
     callback: EntryCallback<K, V | undefined, [MK, MV]>,
     options?: Partial<RedBlackTreeOptions<MK, MV, MR>>,

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

@@ -10,6 +10,7 @@
 import type { Comparator } from '../../types';
 import type { TreeMapEntryCallback, TreeMapOptions, TreeMapRangeOptions, TreeMapReduceCallback } from '../../types';
 import { RedBlackTree } from './red-black-tree';
+import { ERR } from '../../common';
 
 /**
  * An ordered Map backed by a red-black tree.
@@ -58,7 +59,7 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
       } else {
         // Validate entries like native Map: each item must be a 2-tuple-like value.
         if (!Array.isArray(item) || item.length < 2) {
-          throw new TypeError('TreeMap: each entry must be a [key, value] tuple');
+          throw new TypeError(ERR.invalidEntry('TreeMap'));
         }
         k = item[0] as K;
         v = item[1] as V | undefined;
@@ -81,7 +82,7 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
   static createDefaultComparator<K>(): Comparator<K> {
     return (a: K, b: K): number => {
       if (typeof a === 'number' && typeof b === 'number') {
-        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError('TreeMap: NaN is not a valid key');
+        if (Number.isNaN(a) || Number.isNaN(b)) throw new TypeError(ERR.invalidNaN('TreeMap'));
         const aa = Object.is(a, -0) ? 0 : a;
         const bb = Object.is(b, -0) ? 0 : b;
         return aa > bb ? 1 : aa < bb ? -1 : 0;
@@ -94,11 +95,11 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
       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('TreeMap: invalid Date key');
+        if (Number.isNaN(ta) || Number.isNaN(tb)) throw new TypeError(ERR.invalidDate('TreeMap'));
         return ta > tb ? 1 : ta < tb ? -1 : 0;
       }
 
-      throw new TypeError('TreeMap: comparator is required for non-number/non-string/non-Date keys');
+      throw new TypeError(ERR.comparatorRequired('TreeMap'));
     };
   }
 
@@ -106,18 +107,18 @@ export class TreeMap<K = any, V = any, R = [K, V]> implements Iterable<[K, V | u
     if (!this.#isDefaultComparator) return;
 
     if (typeof key === 'number') {
-      if (Number.isNaN(key)) throw new TypeError('TreeMap: NaN is not a valid key');
+      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN('TreeMap'));
       return;
     }
 
     if (typeof key === 'string') return;
 
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError('TreeMap: invalid Date key');
+      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate('TreeMap'));
       return;
     }
 
-    throw new TypeError('TreeMap: comparator is required for non-number/non-string/non-Date keys');
+    throw new TypeError(ERR.comparatorRequired('TreeMap'));
   }
 
   /**

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

@@ -7,7 +7,7 @@
  */
 
 import type { Comparator, TreeMultiMapOptions } from '../../types';
-import { Range } from '../../common';
+import { ERR, Range } from '../../common';
 import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 import { TreeSet } from './tree-set';
 
@@ -261,15 +261,15 @@ export class TreeMultiMap<K = any, V = any, R = any> implements Iterable<[K, V[]
     // reuse TreeSet strict validation (same policy)
     // NOTE: TreeSet._validateKey is private, so we replicate the checks.
     if (typeof key === 'number') {
-      if (Number.isNaN(key)) throw new TypeError('TreeMultiMap: NaN is not a valid key');
+      if (Number.isNaN(key)) throw new TypeError(ERR.invalidNaN('TreeMultiMap'));
       return;
     }
     if (typeof key === 'string') return;
     if (key instanceof Date) {
-      if (Number.isNaN(key.getTime())) throw new TypeError('TreeMultiMap: invalid Date key');
+      if (Number.isNaN(key.getTime())) throw new TypeError(ERR.invalidDate('TreeMultiMap'));
       return;
     }
-    throw new TypeError('TreeMultiMap: comparator is required for non-number/non-string/non-Date keys');
+    throw new TypeError(ERR.comparatorRequired('TreeMultiMap'));
   }
 
   /**