data-structure-typed 2.4.0 → 2.4.2

package/test/unit/data-structures/binary-tree/bst.bound-by-predicate.coverage.test.ts

@@ -1,33 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST _boundByPredicate coverage', () => {
-  it('recursive traversal: returns first in-order match and short-circuits once found', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
-
-    const pred = (node: any) => node.key >= 7;
-    const out = (t as any)._boundByPredicate(pred, 'RECURSIVE');
-    expect(out?.key).toBe(7);
-  });
-
-  it('recursive traversal: returns undefined when no match', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = (t as any)._boundByPredicate((node: any) => node.key === 999, 'RECURSIVE');
-    expect(out).toBeUndefined();
-  });
-
-  it('iterative traversal: returns first match and breaks when stack pop is not real', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = (t as any)._boundByPredicate((node: any) => node.key === 10, 'ITERATIVE');
-    expect(out?.key).toBe(10);
-
-    // Force the internal stack-pop guard branch by clearing the tree and calling again.
-    t.clear();
-    const out2 = (t as any)._boundByPredicate((node: any) => node.key === 1, 'ITERATIVE');
-    expect(out2).toBeUndefined();
-  });
-});

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

@@ -1,94 +0,0 @@
-import { BST, Range } from '../../../../src';
-
-/**
- * Coverage-focused tests for overload dispatch + iterationType string handling.
- *
- * IMPORTANT: Do NOT touch the existing @example tests (used for docs generation).
- */
-describe('BST coverage: overloads & bound helpers', () => {
-  let bst: BST<number, string>;
-
-  beforeEach(() => {
-    bst = new BST<number, string>([10, 5, 15, 3, 7, 12, 20, 1, 4, 6, 8, 11, 13, 18, 25]);
-  });
-
-  it('ceiling supports iterationType passed as 2nd arg string', () => {
-    expect(bst.ceiling(9, n => n.key, 'ITERATIVE')).toBe(10);
-    expect(bst.ceiling(10, n => n.key, 'RECURSIVE')).toBe(10);
-  });
-
-  it('ceiling supports callback + explicit iterationType', () => {
-    const got = bst.ceiling(14, node => node.key, 'ITERATIVE');
-    expect(got).toBe(15);
-  });
-
-  it('higher supports iterationType passed as 2nd arg string', () => {
-    expect(bst.higher(10, n => n.key , 'ITERATIVE')).toBe(11);
-    expect(bst.higher(25, n => n.key, 'RECURSIVE')).toBeUndefined();
-  });
-
-  it('higher supports callback + explicit iterationType', () => {
-    const got = bst.higher(14, node => node.key, 'RECURSIVE');
-    expect(got).toBe(15);
-  });
-
-  it('floor supports iterationType passed as 2nd arg string', () => {
-    expect(bst.floor(9, n => n.key, 'ITERATIVE')).toBe(8);
-    expect(bst.floor(1, n => n.key, 'RECURSIVE')).toBe(1);
-  });
-
-  it('floor supports callback + explicit iterationType', () => {
-    const got = bst.floor(14, node => node.key, 'ITERATIVE');
-    expect(got).toBe(13);
-  });
-
-  it('lower supports iterationType passed as 2nd arg string', () => {
-    expect(bst.lower(10, n => n.key, 'ITERATIVE')).toBe(8);
-    expect(bst.lower(1, n => n.key, 'RECURSIVE')).toBeUndefined();
-  });
-
-  it('lower supports callback + explicit iterationType', () => {
-    const got = bst.lower(11, node => node.key, 'RECURSIVE');
-    expect(got).toBe(10);
-  });
-
-  it('bound helpers accept a NodePredicate input (smoke)', () => {
-    // These overloads allow a predicate; this primarily exercises the dispatch logic.
-    const pred = (node: any) => node.key === 12;
-    expect(bst.ceiling(pred, node => node.key)).toBe(12);
-
-    // Predicate overload semantics are implementation-defined; we mainly want to exercise the dispatch.
-    const higher = bst.higher(pred, node => node.key);
-    expect(higher).toBeDefined();
-    expect(higher as number).toBeGreaterThanOrEqual(12);
-
-    expect(bst.floor(pred, node => node.key)).toBe(12);
-
-    const lower = bst.lower(pred, node => node.key);
-    expect(lower === 11 || lower === 12).toBe(true);
-  });
-
-  it('getNode covers predicate branch + runtime Range branch + entry edge cases', () => {
-    // predicate branch (delegates to getNodes)
-    const pred = (node: any) => node.key === 12;
-    expect(bst.getNode(pred)?.key).toBe(12);
-
-    // runtime Range branch (Range is not in overload but allowed at runtime)
-    const range = new Range(6, 12);
-    const inRange = bst.getNode(range as any);
-    expect(inRange?.key).toBe(6);
-
-    // entry branch: null/undefined key should return undefined
-    expect(bst.getNode([null as any, 'x'] as any)).toBeUndefined();
-    expect(bst.getNode([undefined as any, 'x'] as any)).toBeUndefined();
-  });
-
-  it('search covers entry-with-null-key early return and Range search callback path', () => {
-    // entry with null key => should yield [] (targetKey stays undefined)
-    expect(bst.search([null as any, 'x'] as any)).toEqual([]);
-
-    // Range search should exercise isRange predicate path + callback
-    const out = bst.search(new Range(6, 12), false, node => node.key, undefined, 'ITERATIVE');
-    expect(out).toEqual([6, 7, 8, 10, 11, 12]);
-  });
-});

package/test/unit/data-structures/binary-tree/bst.deletebykey.coverage.test.ts

@@ -1,70 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST _deleteByKey coverage', () => {
-  it('returns false when key not found', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    expect((t as any)._deleteByKey(999)).toBe(false);
-    expect(t.size).toBe(3);
-  });
-
-  it('deletes node with no left child (node.left === undefined)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 15]) t.set(k, k);
-
-    expect((t as any)._deleteByKey(10)).toBe(true);
-    expect(t.has(10)).toBe(false);
-    expect(t.has(15)).toBe(true);
-  });
-
-  it('deletes node with no right child (node.right === undefined)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5]) t.set(k, k);
-
-    expect((t as any)._deleteByKey(10)).toBe(true);
-    expect(t.has(10)).toBe(false);
-    expect(t.has(5)).toBe(true);
-  });
-
-  it('deletes node with two children where successor is direct right child (succ.parent === node)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    //      10
-    //     /  \
-    //    5   15
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    expect((t as any)._deleteByKey(10)).toBe(true);
-    expect(t.has(10)).toBe(false);
-    expect(t.has(5)).toBe(true);
-    expect(t.has(15)).toBe(true);
-
-    // Root should now be 15.
-    expect((t as any)._root?.key).toBe(15);
-    expect((t as any)._root?.left?.key).toBe(5);
-  });
-
-  it('deletes node with two children where successor is deeper (succ.parent !== node) and minNode loop handles null left', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    //        10
-    //       /  \
-    //      5    20
-    //          /  \
-    //         15  25
-    //        /
-    //       13   (successor)
-    for (const k of [10, 5, 20, 15, 25, 13]) t.set(k, k);
-
-    // Make successor.left explicitly null to cover `x.left !== null` check in minNode loop.
-    const n13 = t.getNode(13)!;
-    n13._left = null as any;
-
-    expect((t as any)._deleteByKey(10)).toBe(true);
-    expect(t.has(10)).toBe(false);
-
-    // New root should be successor (13).
-    expect((t as any)._root?.key).toBe(13);
-    expect(t.has(20)).toBe(true);
-    expect(t.getNode(20)?.parent?.key).toBe(13);
-  });
-});

package/test/unit/data-structures/binary-tree/bst.deletewhere.coverage.test.ts

@@ -1,37 +0,0 @@
-import { BST, Range } from '../../../../src';
-
-describe('BST deleteWhere coverage', () => {
-  it('deleteWhere(predicate) uses default args (onlyOne/startNode/iterationType)', () => {
-    const bst = new BST<number, number>();
-    for (const k of [4, 2, 6, 1, 3, 5, 7]) bst.set(k, k);
-
-    // delete evens (should remove 2,4,6)
-    const res = bst.deleteWhere(node => node.key % 2 === 0);
-    expect(res.length).toBe(3);
-    expect(bst.has(2)).toBe(false);
-    expect(bst.has(4)).toBe(false);
-    expect(bst.has(6)).toBe(false);
-
-    // odd keys remain
-    expect([...bst].map(([k]) => k).sort((a, b) => a - b)).toEqual([1, 3, 5, 7]);
-  });
-
-  it('deleteWhere(range, onlyOne=true) deletes a single match', () => {
-    const bst = new BST<number, number>();
-    for (const k of [10, 5, 15, 3, 7, 12, 18]) bst.set(k, k);
-
-    const r = new Range<number>(7, 15, true, true);
-    const before = bst.size;
-
-    const res = bst.deleteWhere(r, true);
-    expect(res.length).toBe(1);
-    expect(bst.size).toBe(before - 1);
-  });
-
-  it('protected _createLike default iterable branch', () => {
-    const bst = new BST<number, number>([2, 1, 3]);
-    const like = (bst as any)._createLike();
-    expect(like).toBeInstanceOf(BST);
-    expect(like.size).toBe(0);
-  });
-});

package/test/unit/data-structures/binary-tree/bst.floor-lower-predicate.coverage.test.ts

@@ -1,29 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST floor()/lower() predicate + callback-shape coverage', () => {
-  it('floor(predicate, iterationTypeString) returns node.key (actualCallback undefined branch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
-
-    // callback is a string => treated as iterationType; actualCallback stays undefined.
-    const out = t.floor((node: any) => node.key <= 7, 'ITERATIVE' as any);
-    // floor-by-predicate returns the last node satisfying the predicate.
-    expect(out).toBe(7);
-  });
-
-  it('lower(predicate, iterationTypeString) returns node.key (actualCallback undefined branch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
-
-    const out = t.lower((node: any) => node.key < 7, 'RECURSIVE' as any);
-    // lower-by-predicate returns the last node satisfying the predicate.
-    expect(out).toBe(5);
-  });
-
-  it('_floorByPredicate hits early return when root is not real (covers dfs guard)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    // empty tree
-    const out = (t as any)._floorByPredicate((n: any) => !!n, 'RECURSIVE');
-    expect(out).toBeUndefined();
-  });
-});

package/test/unit/data-structures/binary-tree/bst.floor-setmany.coverage.test.ts

@@ -1,72 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST floor() and setMany() extra coverage', () => {
-  it('floor: nullish input returns undefined (callback string and callback function cases)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-
-    expect(t.floor(null as any, 'RECURSIVE' as any)).toBeUndefined();
-    expect(t.floor(undefined as any, 'ITERATIVE' as any)).toBeUndefined();
-
-    // also with callback function
-    expect(t.floor(null as any, (n: any) => n.key)).toBeUndefined();
-  });
-
-  it('floor: entry with null/undefined key returns undefined (covers key-null guard)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    expect(t.floor([null as any, 1] as any, (n: any) => n.key)).toBeUndefined();
-    expect(t.floor([undefined as any, 1] as any, (n: any) => n.key)).toBeUndefined();
-  });
-
-  it('floor: predicate path returns callback(node) when found and undefined when not found', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
-
-    const found = t.floor((node: any) => node.key >= 7, (node: any) => node.key, 'ITERATIVE' as any);
-    // floor-by-predicate returns the first node that satisfies the predicate in the chosen traversal.
-    expect(found).toBe(15);
-
-    const notFound = t.floor((node: any) => node.key === 999, (node: any) => node.key, 'RECURSIVE' as any);
-    expect(notFound).toBeUndefined();
-  });
-
-  it('setMany: non-balanced insertion converts raw items via _toEntryFn and passes values iterator', () => {
-    type Raw = { k: number | null; v: number };
-    const t = new BST<number, number, Raw>([], { isMapMode: false } as any);
-
-    // Enable raw conversion.
-    (t as any)._toEntryFn = (r: Raw) => [r.k as any, r.v];
-
-    const raws: Raw[] = [
-      { k: 3, v: 30 },
-      { k: 1, v: 10 },
-      { k: null, v: 999 } // should become a [null, v] entry; set should fail
-    ];
-
-    const out = t.setMany(raws as any, [undefined, undefined, undefined], false);
-    expect(out.length).toBe(3);
-
-    expect(t.has(1)).toBe(true);
-    expect(t.has(3)).toBe(true);
-  });
-
-  it('setMany: balanced insertion sort comparator covers (keyA==null || keyB==null) fallback', () => {
-    type Raw = { k: number | null; v: number };
-    const t = new BST<number, number, Raw>([], { isMapMode: false } as any);
-    (t as any)._toEntryFn = (r: Raw) => [r.k as any, r.v];
-
-    // Use only raw objects (arrays are also typeof 'object' and would be treated as raw when _toEntryFn is set).
-    // Include a null key so the sort comparator hits the `return 0` fallback.
-    const items: Raw[] = [
-      { k: null, v: 0 },
-      { k: 2, v: 20 },
-      { k: 1, v: 10 }
-    ];
-    const out = t.setMany(items as any, undefined, true, 'ITERATIVE' as any);
-    expect(out.length).toBe(3);
-
-    expect(t.has(1)).toBe(true);
-    expect(t.has(2)).toBe(true);
-  });
-});

package/test/unit/data-structures/binary-tree/bst.getnode.range-ensure.coverage.test.ts

@@ -1,22 +0,0 @@
-import { BST } from '../../../../src';
-import { Range } from '../../../../src/common';
-
-describe('BST getNode() extra coverage', () => {
-  it('treats runtime Range input by forwarding to getNodes and returning first result', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7, 12, 18]) t.set(k, k);
-
-    const range = new Range(6, 13, true, true);
-    const n = t.getNode(range as any);
-    expect(n?.key).toBe(7);
-  });
-
-  it('returns undefined when ensureNode(startNode) fails (startNode is null)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    // bypass type and pass null startNode
-    const out = t.getNode(10 as any, null as any);
-    expect(out).toBeUndefined();
-  });
-});

package/test/unit/data-structures/binary-tree/bst.misc-branches.coverage.test.ts

@@ -1,100 +0,0 @@
-import { BST } from '../../../../src';
-import { Range } from '../../../../src/common';
-
-describe('BST remaining misc branch coverage', () => {
-  it('getNode(range) returns undefined when getNodes(range) is empty (covers ?? fallback)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const range = new Range(100, 200);
-    const out = t.getNode(range as any);
-    expect(out).toBeUndefined();
-  });
-
-  it('search(entry) with undefined key covers the second operand of (k !== null && k !== undefined)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = t.search([undefined as any, 1] as any);
-    expect(out).toEqual([]);
-  });
-
-  it('floor(entry null key, callback as string) hits the typeof-callback guard branch', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    expect(t.floor([null as any, 1] as any, 'RECURSIVE' as any)).toBeUndefined();
-  });
-
-  it('lower(predicate, callback fn) returns undefined when predicate matches none (covers cond-expr false branch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = t.lower((n: any) => n.key === 999, (n: any) => n.key, 'ITERATIVE' as any);
-    expect(out).toBeUndefined();
-  });
-
-  it('lower(key, callback fn) returns undefined when no lower key exists (covers key-path cond-expr false branch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = t.lower(1 as any, (n: any) => n.key, 'ITERATIVE' as any);
-    expect(out).toBeUndefined();
-  });
-
-  it('default comparator throws when comparing object keys (covers typeof b === object arm)', () => {
-    const t = new BST<any, any>([], { isMapMode: false } as any);
-    const cmp = (t as any)._createDefaultComparator();
-    expect(() => cmp(1, {})).toThrow(TypeError);
-  });
-
-  it('_floorByPredicate(RECURSIVE) updates result when predicate becomes true (covers predicate(cur) true branch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15, 3, 7]) t.set(k, k);
-
-    const node = (t as any)._floorByPredicate((n: any) => n.key <= 7, 'RECURSIVE');
-    expect(node?.key).toBe(7);
-  });
-
-  it('_lowerByPredicate(RECURSIVE) early-returns on empty tree (covers !isRealNode(cur) guard)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    const node = (t as any)._lowerByPredicate((n: any) => !!n, 'RECURSIVE');
-    expect(node).toBeUndefined();
-  });
-
-  it('_bound(entry null key) returns undefined (covers key-null guard in _bound)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    const out = (t as any)._bound([null as any, 1] as any, true, 'ITERATIVE');
-    expect(out).toBeUndefined();
-  });
-
-  it('_boundByPredicate(RECURSIVE) early-returns on empty tree (covers !isRealNode(cur) guard)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    const out = (t as any)._boundByPredicate((n: any) => !!n, 'RECURSIVE');
-    expect(out).toBeUndefined();
-  });
-
-  it('_deleteByKey takes the cmp>0 left-walk branch and transplant(p.left===u) branch', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    // Ensure root has a left child so delete walks left and transplant sees p.left===u.
-    for (const k of [10, 5, 15]) t.set(k, k);
-
-    expect((t as any)._deleteByKey(1)).toBe(false); // walk left, not found
-    expect((t as any)._deleteByKey(5)).toBe(true); // delete left child
-    expect(t.has(5)).toBe(false);
-  });
-
-  it('setMany balanced sort comparator hits isRealNode(b) branch when inputs include nodes', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    for (const k of [2, 1, 3]) t.set(k, k);
-
-    const n1 = t.getNode(1)!;
-    const n2 = t.getNode(2)!;
-    const n3 = t.getNode(3)!;
-
-    const out = t.setMany([n3, n1, n2] as any, undefined, true, 'ITERATIVE' as any);
-    expect(out.length).toBe(3);
-  });
-});

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

@@ -1,133 +0,0 @@
-import { BST, BSTNode } from '../../../../src';
-
-describe('BST additional branch coverage (batch 2)', () => {
-  it('search(): forces pruning key-branches by toggling _isPredicate (covers shouldVisitLeft/Right key-path guards)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    t.set(10, 10);
-
-    // Make the first _isPredicate check return true (to skip the key fast-path),
-    // but subsequent calls return false (so pruning takes the key-search branches).
-    const origIsPredicate = (t as any)._isPredicate;
-    let first = true;
-    (t as any)._isPredicate = () => {
-      if (first) {
-        first = false;
-        return true;
-      }
-      return false;
-    };
-    try {
-      // Root has no real children => shouldVisitLeft/Right hits `!isRealNode(cur.left/right)` early returns.
-      expect(t.search(7 as any, false, n => n.key)).toEqual([]);
-
-      // Add children and try again so the compare-based pruning expressions execute too.
-      t.set(5, 5);
-      t.set(15, 15);
-
-      expect(t.search(7 as any, false, n => n.key)).toEqual([]);
-      expect(t.search(12 as any, false, n => n.key)).toEqual([]);
-    } finally {
-      (t as any)._isPredicate = origIsPredicate;
-    }
-  });
-
-  it('setMany(): covers raw-key path in both recursive and iterative builders, and hits !popped continue via pop monkeypatch', () => {
-    type Raw = { k: number; v: string };
-    const t = new BST<number, string, Raw>([], {
-      isMapMode: false,
-      toEntryFn: (r: Raw) => [r.k, r.v]
-    });
-
-    const raws: Raw[] = [
-      { k: 3, v: 'c' },
-      { k: 1, v: 'a' },
-      { k: 2, v: 'b' }
-    ];
-
-    // Recursive path hits `if (this.isRaw(key)) ... this.set(entry)`.
-    const insertedR = t.setMany(raws as any, undefined as any, false, 'RECURSIVE');
-    expect(insertedR.length).toBe(3);
-    expect(t.get(1)).toBe('a');
-
-    // Iterative path: monkeypatch pop once to return undefined so `if (!popped) continue` executes.
-    const origPop = Array.prototype.pop;
-    let did = false;
-    try {
-      // reset tree
-      t.clear();
-      Array.prototype.pop = function () {
-        if (!did) {
-          did = true;
-          return undefined as any;
-        }
-        return origPop.call(this);
-      };
-
-      const insertedI = t.setMany(raws as any, undefined as any, false, 'ITERATIVE');
-      expect(insertedI.length).toBe(3);
-      expect(t.get(2)).toBe('b');
-    } finally {
-      Array.prototype.pop = origPop;
-    }
-  });
-
-  it('floor/lower: covers nullish key entry guards and callback-string/empty branches', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    t.setMany([1, 2, 3] as any);
-
-    // entry with nullish key => should return undefined through guard branches
-    expect(t.floor([undefined, 1] as any)).toBeUndefined();
-    expect(t.lower([undefined, 1] as any)).toBeUndefined();
-
-    // null input with callback string => also returns undefined (guard branch)
-    expect(t.lower(undefined as any, 'RECURSIVE' as any)).toBeUndefined();
-  });
-
-  it('_floorByPredicate/_lowerByPredicate/_boundByPredicate iterative: hits break when stack.pop returns non-real (Array.pop monkeypatch)', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    t.set(2, 2);
-    t.set(1, 1);
-    t.set(3, 3);
-
-    const origPop = Array.prototype.pop;
-    let did = false;
-    try {
-      Array.prototype.pop = function () {
-        if (!did) {
-          did = true;
-          return undefined as any;
-        }
-        return origPop.call(this);
-      };
-
-      // Access protected helpers via any and force ITERATIVE.
-      // With pop monkeypatch, these may return undefined due to early-break; we only care about executing the branch.
-      expect(() => (t as any)._floorByPredicate((n: BSTNode<number, number>) => n.key <= 2, 'ITERATIVE')).not.toThrow();
-      did = false;
-      expect(() => (t as any)._lowerByPredicate((n: BSTNode<number, number>) => n.key < 2, 'ITERATIVE')).not.toThrow();
-      did = false;
-      expect(() => (t as any)._boundByPredicate((n: BSTNode<number, number>) => n.key >= 2, true, 'ITERATIVE')).not.toThrow();
-    } finally {
-      Array.prototype.pop = origPop;
-    }
-  });
-
-  it('_deleteByKey: covers transplant else-branch (u is right child) and minNode(!x) early return via null corruption', () => {
-    const t = new BST<number, number>([], { isMapMode: false });
-    // Build: 2 with children 1 and 3
-    t.set(2, 2);
-    t.set(1, 1);
-    t.set(3, 3);
-
-    // delete right child => transplant sees p.left!==u and takes p.right=v branch
-    expect((t as any)._deleteByKey(3)).toBe(true);
-    expect(t.get(3)).toBeUndefined();
-
-    // Corrupt: make node.right null so two-children branch is taken but minNode receives null
-    // and hits `if (!x) return undefined;`.
-    const n2 = t.getNode(2)!;
-    (n2 as any).right = null;
-
-    expect(() => (t as any)._deleteByKey(2)).toThrow();
-  });
-});

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

@@ -1,45 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST remaining reachable branch coverage (batch 3)', () => {
-  it('search(): entry with nullish key does not set targetKey (covers entry[0] nullish guard)', () => {
-    const t = new BST<number, number>();
-    t.set(1, 1);
-
-    // Should not throw; should return empty due to targetKey undefined.
-    const res = (t as any).search([null, 1], (n: any) => n.key);
-    expect(res).toEqual([]);
-  });
-
-  it('search(): forces key-pruning branches to evaluate inside shouldVisitLeft/Right by toggling _isPredicate', () => {
-    const t = new BST<number, number>();
-    t.setMany([
-      [2, 2],
-      [1, 1],
-      [3, 3]
-    ]);
-
-    const pred = (node: any) => node.key === 2;
-
-    const origIsPred = (t as any)._isPredicate;
-    let calls = 0;
-    (t as any)._isPredicate = (_x: any) => {
-      calls++;
-      // search() calls _isPredicate multiple times (isPred calc + ensurePredicate + pruning closures).
-      // Keep it true for the initial plumbing, then flip to false so pruning takes the key-pruning branch.
-      if (calls <= 3) return true;
-      return false;
-    };
-
-    try {
-      const out = (t as any).search(pred, (n: any) => n.key);
-      expect(out).toEqual([2]);
-    } finally {
-      (t as any)._isPredicate = origIsPred;
-    }
-  });
-
-  it('lower(): nullish input + nullish callback hits `|| !callback` branch', () => {
-    const t = new BST<number, number>();
-    expect((t as any).lower(undefined, undefined)).toBeUndefined();
-  });
-});

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

@@ -1,36 +0,0 @@
-import { BST } from '../../../../src';
-
-describe('BST remaining reachable branch coverage (batch 4)', () => {
-  it('search(): entry with defined key sets targetKey (covers entry[0] non-nullish branch)', () => {
-    const t = new BST<number, number>();
-    t.setMany([
-      [1, 1],
-      [2, 2],
-      [3, 3]
-    ]);
-
-    const res = (t as any).search([2, undefined], (n: any) => n.key);
-    expect(res).toEqual([2]);
-  });
-
-  it('setMany(): recursive balanced build hits isRaw(key) branch', () => {
-    type Raw = { k: number; v: number };
-    const t = new BST<number, number, Raw>([], {
-      toEntryFn: (r: Raw) => [r.k, r.v]
-    });
-
-    const inserted = t.setMany(
-      [
-        { k: 2, v: 20 },
-        { k: 1, v: 10 },
-        { k: 3, v: 30 }
-      ],
-      undefined,
-      true,
-      'RECURSIVE'
-    );
-
-    expect(inserted).toHaveLength(3);
-    expect(t.get(2)).toBe(20);
-  });
-});