data-structure-typed 2.4.0 → 2.4.2

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

@@ -1,30 +0,0 @@
-import { RedBlackTree } from '../../../../src';
-
-describe('RedBlackTree update-branch coverage', () => {
-  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');
-    t.set(5, 'min');
-    t.set(15, 'max');
-
-    // Update min/max keys with undefined (bypasses store-fast-path, uses _setValue branch).
-    t.set(5, undefined as any);
-    t.set(15, undefined as any);
-
-    // 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', () => {
-    const t = new RedBlackTree<number, string>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 12]) t.set(k, String(k));
-
-    // key=12 is interior (not min/max)
-    const size0 = t.size;
-    t.set(12, 'twelve');
-    expect(t.size).toBe(size0);
-    expect(t.getNode(12)?.value).toBe('twelve');
-  });
-});

package/test/unit/data-structures/binary-tree/segment-tree.more-branches.coverage.test.ts

@@ -1,31 +0,0 @@
-import { SegmentTree } from '../../../../src';
-
-describe('SegmentTree remaining branch coverage', () => {
-  it('build(start>end) returns a zero-sum node (covers start>end guard)', () => {
-    const st = new SegmentTree([1, 2, 3]);
-    const n = st.build(2, 1);
-    expect(n.start).toBe(2);
-    expect(n.end).toBe(1);
-    expect(n.sum).toBe(0);
-  });
-
-  it('querySumByRange returns NaN when descending into missing left subtree (j<=mid && !cur.left)', () => {
-    const st = new SegmentTree([10, 20]);
-    const root = st.root!;
-
-    // Corrupt to remove left child.
-    root.left = undefined;
-
-    expect(Number.isNaN(st.querySumByRange(0, 0))).toBe(true);
-  });
-
-  it('querySumByRange returns NaN when descending into missing right subtree (i>mid && !cur.right)', () => {
-    const st = new SegmentTree([10, 20]);
-    const root = st.root!;
-
-    // Corrupt to remove right child.
-    root.right = undefined;
-
-    expect(Number.isNaN(st.querySumByRange(1, 1))).toBe(true);
-  });
-});

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

@@ -1,104 +0,0 @@
-import { SegmentTree, SegmentTreeNode } from '../../../../src';
-
-describe('SegmentTreeNode', () => {
-  it('should initialize with correct start, end, sum, and optional value', () => {
-    const node = new SegmentTreeNode(0, 1, 10, 2);
-    expect(node.start).toBe(0);
-    expect(node.end).toBe(1);
-    expect(node.sum).toBe(10);
-    expect(node.value).toBe(2);
-  });
-
-  it('should allow setting start, end, sum, value, left, and right', () => {
-    const node = new SegmentTreeNode(0, 1, 10);
-    node.start = 2;
-    node.end = 3;
-    node.sum = 15;
-    node.value = 2;
-
-    const leftNode = new SegmentTreeNode(0, 1, 5);
-    const rightNode = new SegmentTreeNode(2, 3, 10);
-
-    node.left = leftNode;
-    node.right = rightNode;
-
-    expect(node.start).toBe(2);
-    expect(node.end).toBe(3);
-    expect(node.sum).toBe(15);
-    expect(node.value).toBe(2);
-    expect(node.left).toBe(leftNode);
-    expect(node.right).toBe(rightNode);
-  });
-});
-
-describe('SegmentTree', () => {
-  it('should initialize with correct values, start, end, and root', () => {
-    const values = [1, 2, 3, 4];
-    const tree = new SegmentTree(values);
-
-    expect(tree.values).toEqual(values);
-    expect(tree.start).toBe(0);
-    expect(tree.end).toBe(3);
-    expect(tree.root).toBeDefined();
-  });
-
-  it('should correctly build segment tree with sum of values', () => {
-    const values = [1, 2, 3, 4];
-    const tree = new SegmentTree(values);
-
-    expect(tree.root?.sum).toBe(10); // 1 + 2 + 3 + 4
-  });
-
-  it('should handle empty values array gracefully', () => {
-    const tree = new SegmentTree([]);
-    expect(tree.values).toEqual([]);
-    expect(tree.root).toBeUndefined();
-  });
-
-  describe('updateNode', () => {
-    it('should update node value and sum correctly', () => {
-      const values = [1, 2, 3, 4];
-      const tree = new SegmentTree(values);
-      tree.updateNode(1, 5, 2);
-
-      expect(tree.root?.sum).toBe(13); // 1 + 5 + 3 + 4
-      expect(tree.root?.left?.right?.sum).toBe(5);
-      expect(tree.root?.left?.right?.value).toBe(2);
-    });
-
-    it('should do nothing if root is undefined', () => {
-      const tree = new SegmentTree([]);
-      tree.updateNode(0, 10);
-      expect(tree.root).toBeUndefined();
-    });
-  });
-
-  describe('querySumByRange', () => {
-    it('should return sum for a given range', () => {
-      const values = [1, 2, 3, 4, 5];
-      const tree = new SegmentTree(values);
-      const result = tree.querySumByRange(1, 3); // 2 + 3 + 4 = 9
-      expect(result).toBe(9);
-    });
-
-    it('should return NaN for an invalid range', () => {
-      const values = [1, 2, 3, 4, 5];
-      const tree = new SegmentTree(values);
-      const result = tree.querySumByRange(3, 1); // Invalid range
-      expect(result).toBeNaN();
-    });
-
-    it('should return 0 if root is undefined', () => {
-      const tree = new SegmentTree([]);
-      const result = tree.querySumByRange(0, 1);
-      expect(result).toBe(0);
-    });
-
-    it('should return NaN if range is out of bounds', () => {
-      const values = [1, 2, 3, 4];
-      const tree = new SegmentTree(values);
-      const result = tree.querySumByRange(-1, 10);
-      expect(result).toBeNaN();
-    });
-  });
-});

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

@@ -1,270 +0,0 @@
-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

@@ -1,245 +0,0 @@
-import { TreeMultiMap, TreeMultiMapNode } from '../../../../src';
-
-/**
- * Coverage-focused tests for TreeMultiMap branches.
- * Keep existing @example tests intact.
- */
-describe('TreeMultiMap coverage', () => {
-  it('TreeMultiMapNode.familyPosition covers ROOT/LEFT/RIGHT/ISOLATED cases', () => {
-    const isolated = new TreeMultiMapNode<number, number>(1);
-    expect(isolated.familyPosition).toBe('ISOLATED');
-
-    const root = new TreeMultiMapNode<number, number>(10);
-    const left = new TreeMultiMapNode<number, number>(5);
-    root.left = left;
-    expect(root.familyPosition).toBe('ROOT');
-    expect(left.familyPosition).toBe('LEFT');
-
-    left.left = new TreeMultiMapNode<number, number>(2);
-    expect(left.familyPosition).toBe('ROOT_LEFT');
-
-    const right = new TreeMultiMapNode<number, number>(15);
-    root.right = right;
-    expect(right.familyPosition).toBe('RIGHT');
-
-    right.right = new TreeMultiMapNode<number, number>(20);
-    expect(right.familyPosition).toBe('ROOT_RIGHT');
-  });
-
-  it('set branches: mapMode true uses _setByNode before _setToValues', () => {
-    const tmm = new TreeMultiMap<number, string>();
-
-    // Create key with empty bucket via bare key insert
-    tmm.set(2 as any);
-    expect(tmm.get(2)).toEqual([]);
-
-    // Now set a value: hits existingNode real + values append
-    tmm.set(2, 'a');
-    expect(tmm.get(2)).toEqual(['a']);
-
-    // Append single value (existingValues defined)
-    tmm.set(2, 'b');
-    expect(tmm.get(2)).toEqual(['a', 'b']);
-
-    // Entry form with explicit values array
-    tmm.set([2, ['c', 'd']]);
-    expect(tmm.get(2)).toEqual(['a', 'b', 'c', 'd']);
-
-    // // Entry form + value param should wrap into [value]
-    // tmm.set([2, ['ignored']], 'e');
-    // expect(tmm.get(2)).toEqual(['a', 'b', 'c', 'd', 'e']);
-
-    // null key ignored
-    expect(tmm.set([null as any, ['x']] as any)).toBe(false);
-  });
-
-  it('set branches: mapMode false prefers _setToValues before _setByNode', () => {
-    const tmm = new TreeMultiMap<number, string>([], { isMapMode: false });
-
-    // When bucket exists, it should append without changing tree structure.
-    tmm.set(1, 'a');
-    tmm.set(1, 'b');
-    expect(tmm.get(1)).toEqual(['a', 'b']);
-
-    // When bucket missing, it should create via super.set
-    tmm.set(3 as any); // insert key-only => bucket may be created as empty array
-    expect(tmm.get(3)).toEqual([]);
-    tmm.set(3, 'x');
-    expect(tmm.get(3)).toEqual(['x']);
-  });
-
-  it('deleteValue branches: not found, found, and delete-when-empty', () => {
-    const tmm = new TreeMultiMap<number, number>();
-
-    // not found bucket
-    expect(tmm.deleteValue(1, 1)).toBe(false);
-
-    tmm.set(1, 1);
-    tmm.set(1, 2);
-
-    // value not present
-    expect(tmm.deleteValue(1, 999)).toBe(false);
-
-    // delete present
-    expect(tmm.deleteValue(1, 1)).toBe(true);
-    expect(tmm.get(1)).toEqual([2]);
-
-    // delete last -> removes key
-    expect(tmm.deleteValue(1, 2)).toBe(true);
-    expect(tmm.get(1)).toBeUndefined();
-  });
-
-  it('_createInstance/_createLike are exercised via clone/map', () => {
-    const tmm = new TreeMultiMap<number, number>();
-    tmm.set(1, 10);
-    tmm.set(1, 11);
-
-    const cloned = tmm.clone();
-    expect(cloned.get(1)).toEqual([10, 11]);
-
-    const mapped = tmm.map((values, key) => [key + 1, values ?? []]);
-    // 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([]);
-  });
-});