data-structure-typed 2.3.0 → 2.4.0

package/test/unit/data-structures/binary-tree/red-black-tree.update-branches.coverage.test.ts

@@ -1,7 +1,7 @@
 import { RedBlackTree } from '../../../../src';
 
 describe('RedBlackTree update-branch coverage', () => {
-  it('mapMode: updating existing min/max with undefined value hits _setValue branches (value unchanged)', () => {
+  it('mapMode: updating existing min/max with undefined value overwrites values (node-index store)', () => {
     const t = new RedBlackTree<number, string>(); // mapMode default
 
     t.set(10, 'mid');
@@ -12,9 +12,9 @@ describe('RedBlackTree update-branch coverage', () => {
     t.set(5, undefined as any);
     t.set(15, undefined as any);
 
-    // Existing semantics: undefined does not overwrite stored values.
-    expect(t.get(5)).toBe('min');
-    expect(t.get(15)).toBe('max');
+    // In node-index mapMode, node.value is the source of truth, so undefined overwrites.
+    expect(t.get(5)).toBe(undefined);
+    expect(t.get(15)).toBe(undefined);
   });
 
   it('set mode: updating an existing interior key uses current.value assignment branch', () => {

package/test/unit/data-structures/binary-tree/tree-map.test.ts

@@ -0,0 +1,270 @@
+import { TreeMap } from '../../../../src';
+
+describe('TreeMap (RedBlackTree-backed, no node exposure)', () => {
+  test('basic operations: set/get/has/delete/size/isEmpty/clear', () => {
+    const m = new TreeMap<number, string>();
+    expect(m.isEmpty()).toBe(true);
+    expect(m.size).toBe(0);
+
+    expect(m.set(2, 'b')).toBe(m);
+    expect(m.set(1, 'a')).toBe(m);
+    expect(m.set(3, 'c')).toBe(m);
+
+    expect(m.size).toBe(3);
+    expect(m.isEmpty()).toBe(false);
+
+    expect(m.get(2)).toBe('b');
+    expect(m.has(2)).toBe(true);
+    expect(m.has(999)).toBe(false);
+
+    expect(m.delete(2)).toBe(true);
+    expect(m.delete(2)).toBe(false);
+    expect(m.get(2)).toBe(undefined);
+
+    m.clear();
+    expect(m.size).toBe(0);
+    expect(m.isEmpty()).toBe(true);
+  });
+
+  test('iteration: keys/values/entries and ordering', () => {
+    const m = new TreeMap<number, string>([
+      [3, 'c'],
+      [1, 'a'],
+      [2, 'b']
+    ]);
+
+    expect([...m.keys()]).toEqual([1, 2, 3]);
+    expect([...m.values()]).toEqual(['a', 'b', 'c']);
+    expect([...m.entries()]).toEqual<([number, string | undefined])[]>([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
+    expect([...m]).toEqual<([number, string | undefined])[]>([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
+
+    const seen: Array<[number, string | undefined]> = [];
+    const ctx = { tag: 'ctx' };
+    m.forEach(function (this: typeof ctx, v, k) {
+      // verify thisArg binding
+      expect(this).toBe(ctx);
+      seen.push([k, v]);
+    }, ctx);
+    expect(seen).toEqual([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
+  });
+
+  test('allows undefined values; has() distinguishes missing vs present-undefined', () => {
+    const m = new TreeMap<number, undefined>();
+    m.set(1, undefined);
+    expect(m.has(1)).toBe(true);
+    expect(m.get(1)).toBe(undefined);
+    expect(m.has(2)).toBe(false);
+  });
+
+  test('constructor throws TypeError for invalid entries (native Map behavior)', () => {
+    expect(() => new TreeMap([['a', 1], ['b'] as unknown as [string, number]])).toThrow(TypeError);
+    expect(() => new TreeMap([123 as unknown as [string, number]])).toThrow(TypeError);
+  });
+
+  test('constructor throws when encountering invalid keys under default comparator', () => {
+    expect(() => new TreeMap<number, number>([[Number.NaN, 1]])).toThrow(TypeError);
+
+    const bad = new Date('not-a-date');
+    expect(() => new TreeMap<Date, number>([[bad, 1]])).toThrow(TypeError);
+
+    type Obj = { n: number };
+    expect(() => new TreeMap<Obj, number>([[{ n: 1 }, 1]])).toThrow(TypeError);
+  });
+
+  test('default comparator: NaN throws (even on empty tree)', () => {
+    const m = new TreeMap<number, number>();
+    expect(() => m.set(Number.NaN, 1)).toThrow(TypeError);
+    expect(() => m.get(Number.NaN)).toThrow(TypeError);
+    expect(() => m.has(Number.NaN)).toThrow(TypeError);
+    expect(() => m.delete(Number.NaN)).toThrow(TypeError);
+    expect(() => m.ceiling(Number.NaN)).toThrow(TypeError);
+  });
+
+  test('default comparator: -0 and 0 are the same key', () => {
+    const m = new TreeMap<number, string>();
+    m.set(-0, 'z');
+    expect(m.size).toBe(1);
+    expect(m.has(0)).toBe(true);
+    expect(m.get(0)).toBe('z');
+
+    m.set(0, 'zz');
+    expect(m.size).toBe(1);
+    expect(m.get(-0)).toBe('zz');
+  });
+
+  test('default comparator: Date supported; invalid Date throws', () => {
+    const d1 = new Date('2020-01-01T00:00:00.000Z');
+    const d2 = new Date('2021-01-01T00:00:00.000Z');
+
+    const m = new TreeMap<Date, number>([
+      [d2, 2],
+      [d1, 1]
+    ]);
+
+    expect([...m.keys()]).toEqual([d1, d2]);
+    expect(m.first()).toEqual<[Date, number | undefined]>([d1, 1]);
+
+    const bad = new Date('not-a-date');
+    const m2 = new TreeMap<Date, number>();
+    expect(() => m2.set(bad, 1)).toThrow(TypeError);
+  });
+
+  test('default comparator: string key ordering is supported', () => {
+    const m = new TreeMap<string, number>([
+      ['b', 2],
+      ['a', 1],
+      ['c', 3]
+    ]);
+    expect([...m.keys()]).toEqual(['a', 'b', 'c']);
+    expect(m.ceiling('bb')).toEqual(['c', 3]);
+  });
+
+  test('default comparator: non-primitive/non-Date requires custom comparator', () => {
+    type Obj = { n: number };
+    const o1: Obj = { n: 1 };
+
+    expect(() => new TreeMap<Obj, number>([[o1, 1]])).toThrow(TypeError);
+
+    const byN = (a: Obj, b: Obj) => a.n - b.n;
+    const m = new TreeMap<Obj, number>([[o1, 1]], { comparator: byN });
+    expect(m.size).toBe(1);
+  });
+
+  test('createDefaultComparator throws for unsupported key types', () => {
+    const cmp = TreeMap.createDefaultComparator<object>();
+    expect(() => cmp({} as unknown as object, {} as unknown as object)).toThrow(TypeError);
+  });
+
+  test('navigable operations: first/last/pollFirst/pollLast', () => {
+    const m = new TreeMap<number, string>();
+    expect(m.first()).toBe(undefined);
+    expect(m.last()).toBe(undefined);
+    expect(m.pollFirst()).toBe(undefined);
+    expect(m.pollLast()).toBe(undefined);
+
+    m.set(2, 'b').set(1, 'a').set(3, 'c');
+    expect(m.first()).toEqual([1, 'a']);
+    expect(m.last()).toEqual([3, 'c']);
+
+    expect(m.pollFirst()).toEqual([1, 'a']);
+    expect([...m.keys()]).toEqual([2, 3]);
+
+    expect(m.pollLast()).toEqual([3, 'c']);
+    expect([...m.keys()]).toEqual([2]);
+  });
+
+  test('navigable operations: ceiling/floor/higher/lower (tuples)', () => {
+    const m = new TreeMap<number, string>([
+      [1, 'a'],
+      [3, 'c'],
+      [5, 'e']
+    ]);
+
+    expect(m.ceiling(0)).toEqual([1, 'a']);
+    expect(m.ceiling(2)).toEqual([3, 'c']);
+    expect(m.ceiling(6)).toBe(undefined);
+
+    expect(m.floor(0)).toBe(undefined);
+    expect(m.floor(2)).toEqual([1, 'a']);
+    expect(m.floor(6)).toEqual([5, 'e']);
+
+    expect(m.higher(1)).toEqual([3, 'c']);
+    expect(m.higher(5)).toBe(undefined);
+
+    expect(m.lower(1)).toBe(undefined);
+    expect(m.lower(5)).toEqual([3, 'c']);
+  });
+
+  test('rangeSearch supports inclusive/exclusive bounds (tuples)', () => {
+    const m = new TreeMap<number, string>([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c'],
+      [4, 'd'],
+      [5, 'e']
+    ]);
+
+    expect(m.rangeSearch([2, 4])).toEqual([
+      [2, 'b'],
+      [3, 'c'],
+      [4, 'd']
+    ]);
+
+    expect(m.rangeSearch([2, 4], { lowInclusive: true, highInclusive: false })).toEqual([
+      [2, 'b'],
+      [3, 'c']
+    ]);
+
+    expect(m.rangeSearch([2, 4], { lowInclusive: false, highInclusive: true })).toEqual([
+      [3, 'c'],
+      [4, 'd']
+    ]);
+
+    expect(m.rangeSearch([2, 4], { lowInclusive: false, highInclusive: false })).toEqual([[3, 'c']]);
+  });
+
+  test('map/filter/reduce/every/some/find/toArray/print', () => {
+    const m = new TreeMap<number, string>([
+      [3, 'c'],
+      [1, 'a'],
+      [2, 'b']
+    ]);
+
+    expect(m.map((v, k) => [k, `${k}:${v ?? 'u'}`] as [number, string]).toArray()).toEqual<
+      ([number, string | undefined])[]
+    >([
+      [1, '1:a'],
+      [2, '2:b'],
+      [3, '3:c']
+    ]);
+
+    const ctx = { prefix: 'x' };
+    expect(
+      m.map(function (this: typeof ctx, v, k) {
+        return [k, `${this.prefix}${k}:${v ?? 'u'}`] as [number, string];
+      }, {}, ctx).toArray()
+    ).toEqual<([number, string | undefined])[]>([
+      [1, 'x1:a'],
+      [2, 'x2:b'],
+      [3, 'x3:c']
+    ]);
+
+    expect(m.filter((v, k) => k >= 2).toArray()).toEqual<([number, string | undefined])[]>([
+      [2, 'b'],
+      [3, 'c']
+    ]);
+    expect(m.reduce((acc, v) => acc + (v ? v.length : 0), 0)).toBe(3);
+
+    expect(m.every((v, k) => k >= 1 && v !== undefined)).toBe(true);
+    expect(m.every((v, k) => k >= 2)).toBe(false);
+
+    expect(m.some((v, k) => k === 2)).toBe(true);
+    expect(m.some((v, k) => k === 999)).toBe(false);
+
+    expect(m.find((v, k) => k >= 2)).toEqual<[number, string | undefined]>([2, 'b']);
+    expect(m.find((v, k) => k >= 999)).toBe(undefined);
+
+    expect(m.toArray()).toEqual<([number, string | undefined])[]>([
+      [1, 'a'],
+      [2, 'b'],
+      [3, 'c']
+    ]);
+
+    const spy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    m.print();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
+});

package/test/unit/data-structures/binary-tree/tree-multi-map.coverage.test.ts

@@ -29,11 +29,11 @@ describe('TreeMultiMap coverage', () => {
   it('set branches: mapMode true uses _setByNode before _setToValues', () => {
     const tmm = new TreeMultiMap<number, string>();
 
-    // Create key with undefined bucket via bare key insert
+    // Create key with empty bucket via bare key insert
     tmm.set(2 as any);
-    expect(tmm.get(2)).toBeUndefined();
+    expect(tmm.get(2)).toEqual([]);
 
-    // Now set a value: hits existingNode real + existingValues undefined => super.set(key, values)
+    // Now set a value: hits existingNode real + values append
     tmm.set(2, 'a');
     expect(tmm.get(2)).toEqual(['a']);
 
@@ -101,4 +101,145 @@ describe('TreeMultiMap coverage', () => {
     // map returns TreeMultiMap when mapping to array values
     expect((mapped as any).get(2)).toEqual([10, 11]);
   });
+
+  // ━━━ Additional branch coverage tests ━━━
+
+  it('set() with null/undefined entry returns false', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    expect(tmm.set(null as any)).toBe(false);
+    expect(tmm.set(undefined as any)).toBe(false);
+    expect(tmm.size).toBe(0);
+  });
+
+  it('set([key, bucket], value) uses add() for the value parameter', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    // Entry array + value param => should add value, ignoring bucket
+    tmm.set([1, ['ignored']], 'actual');
+    expect(tmm.get(1)).toEqual(['actual']);
+  });
+
+  it('set([key, undefined]) creates empty bucket', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    tmm.set([1, undefined]);
+    expect(tmm.has(1)).toBe(true);
+    expect(tmm.get(1)).toEqual([]);
+  });
+
+  it('constructor with null/undefined entries skips them', () => {
+    const tmm = new TreeMultiMap<number, string>([
+      [1, ['a']],
+      null as any,
+      undefined as any,
+      [2, ['b']]
+    ]);
+    expect(tmm.size).toBe(2);
+    expect(tmm.get(1)).toEqual(['a']);
+    expect(tmm.get(2)).toEqual(['b']);
+  });
+
+  it('constructor with [null, bucket] entry skips it', () => {
+    const tmm = new TreeMultiMap<number, string>([
+      [null as any, ['x']],
+      [1, ['a']]
+    ]);
+    expect(tmm.size).toBe(1);
+  });
+
+  it('custom comparator skips _validateKey branches', () => {
+    const tmm = new TreeMultiMap<{ id: number }, string>([], {
+      comparator: (a, b) => a.id - b.id
+    });
+    // With custom comparator, any key type is allowed (no validation throws)
+    const key1 = { id: 1 };
+    const key2 = { id: 2 };
+    tmm.add(key1, 'a');
+    tmm.add(key2, 'b');
+    expect(tmm.size).toBe(2);
+    // Iteration shows both entries were added
+    expect([...tmm.keys()].map(k => k.id)).toEqual([1, 2]);
+  });
+
+  it('_validateKey throws for invalid types with default comparator', () => {
+    const tmm = new TreeMultiMap<any, string>();
+    // Object without comparator should throw
+    expect(() => tmm.add({ foo: 'bar' }, 'x')).toThrow(TypeError);
+    // NaN should throw
+    expect(() => tmm.add(NaN, 'x')).toThrow(TypeError);
+    // Invalid Date should throw
+    expect(() => tmm.add(new Date('invalid'), 'x')).toThrow(TypeError);
+  });
+
+  it('_validateKey accepts string keys', () => {
+    const tmm = new TreeMultiMap<string, number>();
+    tmm.add('hello', 1);
+    tmm.add('world', 2);
+    expect(tmm.has('hello')).toBe(true);
+  });
+
+  it('_validateKey accepts Date keys', () => {
+    const tmm = new TreeMultiMap<Date, string>();
+    const d1 = new Date('2025-01-01');
+    const d2 = new Date('2025-06-01');
+    tmm.add(d1, 'new year');
+    tmm.add(d2, 'mid year');
+    expect(tmm.has(d1)).toBe(true);
+  });
+
+  it('deleteValues returns 0 on non-existent bucket', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    expect(tmm.deleteValues(999, 'x')).toBe(0);
+  });
+
+  it('deleteValues returns 0 on empty bucket', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    tmm.set([1, []]);
+    expect(tmm.deleteValues(1, 'x')).toBe(0);
+  });
+
+  it('entriesOf/valuesOf on non-existent key yields nothing', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    expect([...tmm.entriesOf(999)]).toEqual([]);
+    expect([...tmm.valuesOf(999)]).toEqual([]);
+  });
+
+  it('hasEntry returns false on non-existent bucket', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    expect(tmm.hasEntry(999, 'x')).toBe(false);
+  });
+
+  it('navigable methods return undefined on empty map', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    expect(tmm.first()).toBeUndefined();
+    expect(tmm.last()).toBeUndefined();
+    expect(tmm.pollFirst()).toBeUndefined();
+    expect(tmm.pollLast()).toBeUndefined();
+    expect(tmm.ceiling(5)).toBeUndefined();
+    expect(tmm.floor(5)).toBeUndefined();
+    expect(tmm.higher(5)).toBeUndefined();
+    expect(tmm.lower(5)).toBeUndefined();
+  });
+
+  it('navigable methods return undefined when key not found', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    tmm.add(10, 'a');
+    tmm.add(20, 'b');
+    // ceiling/floor/higher/lower that miss should return undefined
+    expect(tmm.ceiling(100)).toBeUndefined();
+    expect(tmm.floor(5)).toBeUndefined();
+    expect(tmm.higher(20)).toBeUndefined();
+    expect(tmm.lower(10)).toBeUndefined();
+  });
+
+  it('setMany handles various entry types', () => {
+    const tmm = new TreeMultiMap<number, string>();
+    const results = tmm.setMany([
+      [1, ['a']],
+      [2, ['b', 'c']],
+      3 as any // key-only
+    ]);
+    expect(results).toEqual([true, true, true]);
+    expect(tmm.get(1)).toEqual(['a']);
+    expect(tmm.get(2)).toEqual(['b', 'c']);
+    expect(tmm.get(3)).toEqual([]);
+  });
 });

package/test/unit/data-structures/binary-tree/{tree-multi-map.test.ts → tree-multi-map.legacy.test.ts.skip}

@@ -1,4 +1,4 @@
-import { IBinaryTree, Range, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
+import { IBinaryTree, Range, RedBlackTreeNode, TreeMultiMap, TreeMultiMapNode } from '../../../../src';
 import { getRandomInt } from '../../../utils';
 import { isDebugTest } from '../../../config';
 import { costOfLiving } from './data/cost-of-living-by-country';
@@ -35,9 +35,9 @@ describe('TreeMultiMap 1', () => {
       tmm.set(20);
       tmm.set(5);
 
-      expect(tmm.getNode(10)).toBeInstanceOf(TreeMultiMapNode);
-      expect(tmm.getNode(20)).toBeInstanceOf(TreeMultiMapNode);
-      expect(tmm.getNode(5)).toBeInstanceOf(TreeMultiMapNode);
+      expect(tmm.getNode(10)).toBeInstanceOf(RedBlackTreeNode);
+      expect(tmm.getNode(20)).toBeInstanceOf(RedBlackTreeNode);
+      expect(tmm.getNode(5)).toBeInstanceOf(RedBlackTreeNode);
       expect(tmm.getNode(15)).toBe(undefined);
     });
 
@@ -45,8 +45,8 @@ describe('TreeMultiMap 1', () => {
       tmm.set(-10);
       tmm.set(-20);
 
-      expect(tmm.getNode(-10)).toBeInstanceOf(TreeMultiMapNode);
-      expect(tmm.getNode(-20)).toBeInstanceOf(TreeMultiMapNode);
+      expect(tmm.getNode(-10)).toBeInstanceOf(RedBlackTreeNode);
+      expect(tmm.getNode(-20)).toBeInstanceOf(RedBlackTreeNode);
     });
   });
 
@@ -162,7 +162,7 @@ describe('TreeMultiMap 1', () => {
   });
 
   it('should the clone method', () => {
-    function checkTreeStructure(tmm: IBinaryTree<string, number[]>) {
+    function checkTreeStructure(tmm: TreeMultiMap<string, number>) {
       expect(tmm.size).toBe(4);
       expect(tmm.root?.key).toBe('2');
       expect(tmm.root?.left?.key).toBe('1');
@@ -201,19 +201,19 @@ describe('TreeMultiMap 1', () => {
   it('should add value', () => {
     const tmm = new TreeMultiMap<number, string>([4, 5, [1, ['1']], 2, 3]);
     expect(tmm.get(1)).toEqual(['1']);
-    expect(tmm.getNode(1)?.value).toEqual([]);
+    expect(tmm.getNode(1)?.value).toEqual(['1']);
     tmm.set(1, 'a');
     expect(tmm.get(1)).toEqual(['1', 'a']);
     tmm.set([1, ['b']]);
-    expect(tmm.getNode(1)?.value).toEqual([]);
+    expect(tmm.getNode(1)?.value).toEqual(['1', 'a', 'b']);
     expect(tmm.get(1)).toEqual(['1', 'a', 'b']);
     const tmmMapped = new TreeMultiMap<number>([4, 5, [1, ['1']], 2, 3]);
     expect(tmmMapped.get(1)).toEqual(['1']);
-    expect(tmmMapped.getNode(1)?.value).toEqual([]);
+    expect(tmmMapped.getNode(1)?.value).toEqual(['1']);
     tmmMapped.set(1, 'a');
     expect(tmmMapped.get(1)).toEqual(['1', 'a']);
     tmmMapped.set([1, ['b']]);
-    expect(tmmMapped.getNode(1)?.value).toEqual([]);
+    expect(tmmMapped.getNode(1)?.value).toEqual(['1', 'a', 'b']);
     expect(tmmMapped.get(1)).toEqual(['1', 'a', 'b']);
   });
 });
@@ -585,7 +585,7 @@ describe('TreeMultiMap 2', () => {
       }
 
       let nanCount = 0;
-      const dfs = (cur: TreeMultiMapNode<number>) => {
+      const dfs = (cur: RedBlackTreeNode<number, number[]>) => {
         if (isNaN(cur.key)) nanCount++;
         if (cur.left) dfs(cur.left);
         if (cur.right) dfs(cur.right);
@@ -610,7 +610,7 @@ describe('TreeMultiMap 2', () => {
       }
 
       let nanCount = 0;
-      const dfs = (cur: TreeMultiMapNode<number>) => {
+      const dfs = (cur: RedBlackTreeNode<number, number[]>) => {
         if (isNaN(cur.key)) nanCount++;
         if (cur.left) dfs(cur.left);
         if (cur.right) dfs(cur.right);
@@ -638,7 +638,7 @@ describe('TreeMultiMap 2', () => {
       const node3 = tmm.getNode(3);
       // expect(node3).toBeInstanceOf(BinaryTreeNode);
       // expect(node3).toBeInstanceOf(BSTNode);
-      expect(node3).toBeInstanceOf(TreeMultiMapNode);
+      expect(node3).toBeInstanceOf(RedBlackTreeNode);
     });
 
     it('forEach should iterate over all elements', () => {
@@ -663,7 +663,7 @@ describe('TreeMultiMap 2', () => {
     });
 
     it('map should return a new tmm with modified elements', () => {
-      const tmmMapped = tmm.map((value, key) => [(key * 2).toString(), value ? value : []]);
+      const tmmMapped = tmm.map((value, key) => [(key * 2).toString(), value ? value : []] as any);
       expect(tmmMapped.size).toBe(3);
       expect([...tmmMapped]).toEqual([
         ['2', ['a']],
@@ -963,7 +963,7 @@ describe('classic use', () => {
       isMapMode: false
     });
 
-    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node));
+    const topPlayersEquipments = playerRankings.rangeSearch([8900, 10000], node => playerRankings.get(node.key));
     expect(topPlayersEquipments).toEqual([
       [
         {

package/test/unit/data-structures/binary-tree/tree-multi-map.rfc.test.ts

@@ -0,0 +1,99 @@
+import { TreeMultiMap } from '../../../../src';
+
+describe('TreeMultiMap (RFC additions)', () => {
+  it('get() returns a live bucket reference (mutating it mutates the container); empty bucket does not auto-delete key', () => {
+    const mm = new TreeMultiMap<number, string>();
+    mm.set(1, 'a');
+    mm.set(1, 'b');
+
+    const bucket = mm.get(1)!;
+    expect(bucket).toEqual(['a', 'b']);
+
+    bucket.push('c');
+    expect(mm.get(1)).toEqual(['a', 'b', 'c']);
+
+    // If bucket is emptied by mutation, key remains until delete(key) is called.
+    bucket.length = 0;
+    expect(mm.has(1)).toBe(true);
+    expect(mm.get(1)).toEqual([]);
+  });
+
+  it('totalSize is the sum of bucket lengths across all keys', () => {
+    const mm = new TreeMultiMap<number, string>();
+    mm.set(1, 'a');
+    mm.set(1, 'b');
+    mm.set(2, 'x');
+    expect(mm.totalSize).toBe(3);
+
+    // live bucket mutation reflected
+    mm.get(2)!.push('y', 'z');
+    expect(mm.totalSize).toBe(5);
+  });
+
+  it('hasEntry/deleteValue/deleteValues default Object.is and optional eq', () => {
+    const mm = new TreeMultiMap<number, { id: number }>();
+    const a1 = { id: 1 };
+    const a1b = { id: 1 };
+
+    mm.set(1, a1);
+    mm.set(1, a1b);
+
+    // Object.is uses reference equality for objects
+    expect(mm.hasEntry(1, { id: 1 })).toBe(false);
+    expect(mm.hasEntry(1, a1)).toBe(true);
+
+    const eq = (x: { id: number }, y: { id: number }) => x.id === y.id;
+    expect(mm.hasEntry(1, { id: 1 }, eq)).toBe(true);
+
+    // deleteValue deletes one match
+    expect(mm.deleteValue(1, { id: 1 }, eq)).toBe(true);
+    expect(mm.get(1)!.length).toBe(1);
+
+    // deleteValues deletes all matches
+    mm.set(1, { id: 1 });
+    mm.set(1, { id: 2 });
+    expect(mm.deleteValues(1, { id: 1 }, eq)).toBe(2);
+    expect(mm.get(1)).toEqual([{ id: 2 }]);
+  });
+
+  it('navigable methods return entry tuples [K, V[]]; pollFirst/pollLast delete whole buckets', () => {
+    const mm = new TreeMultiMap<number, string>();
+    mm.set(2, 'b');
+    mm.set(1, 'a');
+    mm.set(3, 'c');
+
+    expect(mm.first()).toEqual([1, ['a']]);
+    expect(mm.last()).toEqual([3, ['c']]);
+    expect(mm.ceiling(2)).toEqual([2, ['b']]);
+    expect(mm.floor(2)).toEqual([2, ['b']]);
+    expect(mm.higher(2)).toEqual([3, ['c']]);
+    expect(mm.lower(2)).toEqual([1, ['a']]);
+
+    const pf = mm.pollFirst();
+    expect(pf).toEqual([1, ['a']]);
+    expect(mm.has(1)).toBe(false);
+
+    const pl = mm.pollLast();
+    expect(pl).toEqual([3, ['c']]);
+    expect(mm.has(3)).toBe(false);
+  });
+
+  it('flatEntries()/entriesOf()/valuesOf() provide entry-flat views', () => {
+    const mm = new TreeMultiMap<number, string>();
+    mm.set(1, 'a');
+    mm.set(1, 'b');
+    mm.set(2, 'x');
+
+    expect([...mm.entriesOf(1)]).toEqual([
+      [1, 'a'],
+      [1, 'b']
+    ]);
+    expect([...mm.valuesOf(1)]).toEqual(['a', 'b']);
+
+    expect([...mm.flatEntries()]).toEqual([
+      [1, 'a'],
+      [1, 'b'],
+      [2, 'x']
+    ]);
+  });
+});