data-structure-typed 2.2.7 → 2.3.0

package/test/unit/data-structures/matrix/matrix.pivotElement-nullish.coverage.test.ts

@@ -0,0 +1,28 @@
+import { Matrix } from '../../../../src';
+
+describe('Matrix inverse pivotElement ?? 1 remaining branch coverage', () => {
+  it('inverse() uses pivotElement fallback 1 when get(i,i) is nullish', () => {
+    const origGet = Matrix.prototype.get;
+    try {
+      Matrix.prototype.get = function (row: number, col: number): any {
+        if (row === 0 && col === 0) return undefined;
+        return origGet.call(this, row, col);
+      };
+
+      const m = new Matrix([
+        [1, 0],
+        [0, 1]
+      ]);
+
+      const inv = m.inverse();
+
+      // Restore before asserting so inv.get is not affected.
+      Matrix.prototype.get = origGet;
+
+      expect(inv?.get(0, 0)).toBe(1);
+      expect(inv?.get(1, 1)).toBe(1);
+    } finally {
+      Matrix.prototype.get = origGet;
+    }
+  });
+});

package/test/unit/data-structures/priority-queue/max-priority-queue.more-branches.coverage.test.ts

@@ -0,0 +1,10 @@
+import { MaxPriorityQueue } from '../../../../src';
+
+describe('MaxPriorityQueue remaining branch coverage', () => {
+  it('default comparator throws when comparing object elements', () => {
+    const pq = new MaxPriorityQueue<any>();
+    // call comparator directly to deterministically hit the throw branch
+    const cmp = (pq as any).comparator as (a: any, b: any) => number;
+    expect(() => cmp({ a: 1 }, { b: 2 })).toThrow(TypeError);
+  });
+});

package/test/unit/data-structures/priority-queue/priority-queue.coverage.test.ts

@@ -0,0 +1,21 @@
+import { PriorityQueue } from '../../../../src';
+
+/**
+ * Coverage-focused test for PriorityQueue thin wrapper.
+ * Keep existing @example tests intact.
+ */
+describe('PriorityQueue coverage', () => {
+  it('constructs and supports basic add/poll via Heap API', () => {
+    const pq = new PriorityQueue<number>();
+    pq.add(3);
+    pq.add(1);
+    pq.add(2);
+
+    // Default PriorityQueue here behaves as a min-heap.
+    expect(pq.peek()).toBe(1);
+    expect(pq.poll()).toBe(1);
+    expect(pq.poll()).toBe(2);
+    expect(pq.poll()).toBe(3);
+    expect(pq.poll()).toBe(undefined);
+  });
+});

package/test/unit/data-structures/queue/deque.coverage.test.ts

@@ -0,0 +1,173 @@
+import { Deque } from '../../../../src';
+
+describe('Deque coverage', () => {
+  it('constructor handles iterable-like length()/size() branches and bucketSize option', () => {
+    const arr = [1, 2, 3, 4, 5];
+
+    const withLengthFn = {
+      length: () => arr.length,
+      [Symbol.iterator]: function* () {
+        yield* arr;
+      }
+    } as any;
+
+    const d1 = new Deque<number>(withLengthFn, { bucketSize: 4 });
+    expect(d1.bucketSize).toBe(4);
+    expect([...d1]).toEqual(arr);
+
+    const withSizeFn = {
+      size: () => arr.length,
+      [Symbol.iterator]: function* () {
+        yield* arr;
+      }
+    } as any;
+
+    const d2 = new Deque<number>(withSizeFn, { bucketSize: 4 });
+    expect([...d2]).toEqual(arr);
+  });
+
+  it('push/unshift respect maxLen (trigger shift/pop) and cover wrap-around + reallocate', () => {
+    // small bucket to make wrap/reallocate reachable with few ops
+    const d = new Deque<number>([], { bucketSize: 4, maxLen: 5 });
+
+    // Fill and force internal pointers to wrap a couple times
+    for (let i = 0; i < 20; i++) d.push(i);
+    expect(d.length).toBe(5);
+    expect([...d]).toEqual([15, 16, 17, 18, 19]);
+
+    for (let i = 100; i < 110; i++) d.unshift(i);
+    expect(d.length).toBe(5);
+    // unshift beyond maxLen pops from end
+    expect([...d]).toEqual([109, 108, 107, 106, 105]);
+  });
+
+  it('pop/shift on empty and singleton cases', () => {
+    const empty = new Deque<number>([], { bucketSize: 4 });
+    expect(empty.pop()).toBeUndefined();
+    expect(empty.shift()).toBeUndefined();
+    expect(empty.first).toBeUndefined();
+    expect(empty.last).toBeUndefined();
+
+    const one = new Deque<number>([1], { bucketSize: 4 });
+    expect(one.first).toBe(1);
+    expect(one.last).toBe(1);
+    expect(one.pop()).toBe(1);
+    expect(one.length).toBe(0);
+
+    one.push(2);
+    expect(one.shift()).toBe(2);
+    expect(one.length).toBe(0);
+  });
+
+  it('at/setAt/addAt/deleteAt/splice rangeCheck throwing + success paths', () => {
+    const d = new Deque<number>([1, 2, 3], { bucketSize: 4 });
+
+    expect(d.at(-1)).toBeUndefined();
+    expect(d.at(999)).toBeUndefined();
+
+    expect(() => d.setAt(-1 as any, 0)).toThrow();
+    expect(() => d.setAt(999 as any, 0)).toThrow();
+    expect(d.setAt(1, 20)).toBe(true);
+    expect([...d]).toEqual([1, 20, 3]);
+
+    expect(() => d.addAt(-1 as any, 0)).toThrow();
+    expect(() => d.deleteAt(-1 as any)).toThrow();
+    expect(() => d.splice(999 as any, 0)).toThrow();
+
+    // addAt: pos=0 and pos=length branches
+    d.addAt(0, 9, 2);
+    d.addAt(d.length, 7, 1);
+    expect(d.first).toBe(9);
+    expect(d.last).toBe(7);
+
+    // deleteAt: middle shift loop branch
+    const mid = d.deleteAt(2);
+    expect(mid).toBeDefined();
+  });
+
+  it('cut/cutRest cover in-place and copy branches', () => {
+    const d = new Deque<number>([1, 2, 3, 4, 5], { bucketSize: 4 });
+
+    const prefix = d.cut(2, false);
+    expect([...prefix]).toEqual([1, 2, 3]);
+
+    const suffix = d.cutRest(3, false);
+    expect([...suffix]).toEqual([4, 5]);
+
+    // in-place cut with pos<0 clears
+    d.cut(-1, true);
+    expect(d.length).toBe(0);
+
+    const d2 = new Deque<number>([1, 2, 3, 4, 5], { bucketSize: 4 });
+    d2.cutRest(-1, true);
+    expect([...d2]).toEqual([1, 2, 3, 4, 5]);
+  });
+
+  it('delete/deleteWhere/setEquality/unique/reverse/shrinkToFit cover branches', () => {
+    type Obj = { id: number };
+    const a: Obj = { id: 1 };
+    const b: Obj = { id: 1 };
+    const c: Obj = { id: 2 };
+
+    const d = new Deque<Obj>([a, c], { bucketSize: 4 });
+
+    // default Object.is: b not found
+    expect(d.delete(b)).toBe(true); // returns true even when not found? it compacts all != element
+    expect(d.length).toBe(2);
+
+    d.setEquality((x, y) => x.id === y.id);
+    expect(d.delete(b)).toBe(true);
+    expect([...d].map(x => x.id)).toEqual([2]);
+
+    d.push({ id: 2 });
+    d.push({ id: 3 });
+
+    expect(d.deleteWhere(v => v.id === 2)).toBe(true);
+    expect(d.deleteWhere(v => v.id === 999)).toBe(false);
+
+    // unique
+    const nums = new Deque<number>([1, 1, 2, 2, 2, 3], { bucketSize: 4 });
+    nums.unique();
+    expect([...nums]).toEqual([1, 2, 3]);
+
+    // unique early return
+    expect(new Deque<number>([1], { bucketSize: 4 }).unique().length).toBe(1);
+
+    // reverse
+    nums.reverse();
+    expect([...nums]).toEqual([3, 2, 1]);
+
+    // shrinkToFit branches
+    const s0 = new Deque<number>([], { bucketSize: 4 });
+    s0.shrinkToFit();
+
+    const s1 = new Deque<number>([1, 2, 3, 4, 5, 6, 7, 8], { bucketSize: 2 });
+    s1.shift();
+    s1.shift();
+    s1.pop();
+    s1.pop();
+    // now likely spans multiple buckets; just ensure no throw
+    s1.shrinkToFit();
+    expect(s1.length).toBeGreaterThan(0);
+  });
+
+  it('filter/mapSame/map cover thisArg and toElementFn branches', () => {
+    const d = new Deque<number, { v: number }>([{ v: 1 }, { v: 2 }, { v: 3 }] as any, {
+      bucketSize: 4,
+      toElementFn: r => r.v
+    });
+
+    const filtered = d.filter(v => v % 2 === 1);
+    expect([...filtered]).toEqual([1, 3]);
+
+    const ctx = { mul: 3 };
+    const mappedSame = d.mapSame(function (v) {
+      // @ts-ignore
+      return v * this.mul;
+    }, ctx);
+    expect([...mappedSame]).toEqual([3, 6, 9]);
+
+    const mapped = d.map(v => String(v));
+    expect([...mapped]).toEqual(['1', '2', '3']);
+  });
+});

package/test/unit/data-structures/queue/deque.more-branches-2.coverage.test.ts

@@ -0,0 +1,39 @@
+import { Deque } from '../../../../src';
+
+describe('Deque remaining branch coverage (batch 2)', () => {
+  it('unshiftMany covers toElementFn branch (and is executed at all)', () => {
+    const d = new Deque<number, { v: number }>([], {
+      toElementFn: (r: { v: number }) => r.v
+    });
+
+    expect(d.unshiftMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect(d.toArray()).toEqual([2, 1]);
+  });
+
+  it('splice(start) uses default deleteCount = length - start', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3, 4]);
+
+    // omit deleteCount to hit the default-arg branch
+    const removed = d.splice(1);
+
+    expect(removed.toArray()).toEqual([2, 3, 4]);
+    expect(d.toArray()).toEqual([1]);
+  });
+
+  it('shrinkToFit covers wrap-around bucketFirst > bucketLast branch', () => {
+    const d = new Deque<number>();
+
+    // Force an internal wrap-around layout (reachable-only: test-side corruption).
+    (d as any)._length = 1;
+    (d as any)._bucketFirst = 2;
+    (d as any)._bucketLast = 1;
+    (d as any)._bucketCount = 4;
+    (d as any)._buckets = [[0], [1], [2], [3]];
+
+    expect(() => d.shrinkToFit()).not.toThrow();
+    expect((d as any)._bucketFirst).toBe(0);
+    expect((d as any)._bucketLast).toBe(3);
+    expect((d as any)._buckets.length).toBe(4);
+  });
+});

package/test/unit/data-structures/queue/deque.more-branches-3.coverage.test.ts

@@ -0,0 +1,9 @@
+import { Deque } from '../../../../src';
+
+describe('Deque remaining branch coverage (batch 3)', () => {
+  it('unshiftMany covers else-branch when toElementFn is not provided', () => {
+    const d = new Deque<number>();
+    expect(d.unshiftMany([1, 2])).toEqual([true, true]);
+    expect(d.toArray()).toEqual([2, 1]);
+  });
+});

package/test/unit/data-structures/queue/deque.more-branches.coverage.test.ts

@@ -0,0 +1,95 @@
+import { Deque } from '../../../../src';
+
+describe('Deque additional branch coverage', () => {
+  it('unshiftMany() default-arg empty iterable returns []', () => {
+    const d = new Deque<number>();
+    expect(d.unshiftMany()).toEqual([]);
+  });
+
+  it('splice clamps deleteCount when negative / too large (covers both clamp branches)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3, 4]);
+
+    // deleteCount < 0 => clamp to 0
+    const r0 = d.splice(1, -1, 99);
+    expect(r0.toArray()).toEqual([]);
+
+    // deleteCount too large => clamp to length-start
+    const r1 = d.splice(1, 999);
+    expect(r1.toArray()).toEqual([99, 2, 3, 4]);
+    expect(d.toArray()).toEqual([1]);
+  });
+
+  it('shrinkToFit returns early when bucketFirst===bucketLast (covers that return branch)', () => {
+    const d = new Deque<number>();
+    d.push(1);
+    // Force bucketFirst===bucketLast and length>0
+    (d as any)._bucketFirst = 0;
+    (d as any)._bucketLast = 0;
+    d.shrinkToFit();
+    expect(d.length).toBe(1);
+  });
+
+  it('mapSame uses the thisArg===undefined branch', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    const out = d.mapSame(v => v * 2);
+    expect(out.toArray()).toEqual([2, 4, 6]);
+  });
+
+  it('map() uses thisArg branch and also covers options??{} merge path', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2]);
+    const ctx = { add: 10 };
+
+    const out = d.map(
+      function (this: any, v: number) {
+        return v + this.add;
+      },
+      undefined,
+      ctx
+    );
+
+    expect(out.toArray()).toEqual([11, 12]);
+  });
+
+  it('_setBucketSize does not reinit buckets when length>0 (covers length===0 false branch)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    const before = (d as any)._buckets;
+    (d as any)._setBucketSize((d as any)._bucketSize);
+    expect((d as any)._buckets).toBe(before);
+  });
+
+  it('_getIterator yields only defined values (covers v!==undefined true branch)', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+    // Corrupt one slot to undefined; _getIterator should skip it.
+    const loc = (d as any)._getBucketAndPosition(1);
+    (d as any)._buckets[loc.bucketIndex][loc.indexInBucket] = undefined;
+
+    const got: number[] = [];
+    for (const v of d) got.push(v);
+    expect(got).toEqual([1, 3]);
+  });
+
+  it('_createLike default-arg path can be called with no args', () => {
+    const d = new Deque<number>();
+    const like = (d as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+
+  it('_getReverseIterator handles v===undefined by not yielding it', () => {
+    const d = new Deque<number>();
+    d.pushMany([1, 2, 3]);
+
+    // Make last element undefined
+    const loc = (d as any)._getBucketAndPosition(2);
+    (d as any)._buckets[loc.bucketIndex][loc.indexInBucket] = undefined;
+
+    const it = (d as any)._getReverseIterator();
+    const got: number[] = [];
+    for (const v of it) got.push(v);
+    expect(got).toEqual([2, 1]);
+  });
+});

package/test/unit/data-structures/queue/queue.coverage.test.ts

@@ -0,0 +1,138 @@
+import { Queue } from '../../../../src';
+
+describe('Queue coverage', () => {
+  it('constructor options set autoCompactRatio and push respects maxLen via shift', () => {
+    const q = new Queue<number>([], { maxLen: 2, autoCompactRatio: 1 });
+    expect(q.autoCompactRatio).toBe(1);
+
+    q.push(1);
+    q.push(2);
+    q.push(3); // maxLen overflow triggers shift()
+
+    expect([...q]).toEqual([2, 3]);
+    expect(q.length).toBe(2);
+    expect(q.first).toBe(2);
+    expect(q.last).toBe(3);
+  });
+
+  it('pushMany uses toElementFn branch', () => {
+    const q = new Queue<number, { v: number }>([], { toElementFn: r => r.v });
+    expect(q.pushMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect([...q]).toEqual([1, 2]);
+  });
+
+  it('shift covers empty branch and compaction trigger', () => {
+    const q = new Queue<number>();
+    expect(q.shift()).toBeUndefined();
+
+    // Force compaction quickly.
+    q.autoCompactRatio = 0.25;
+    q.pushMany([1, 2, 3, 4]);
+
+    expect(q.shift()).toBe(1);
+    // offset=1, elements.length=4 => 0.25, not strictly greater
+    expect(q.offset).toBe(1);
+
+    expect(q.shift()).toBe(2);
+    // offset=2, elements.length=4 => 0.5 > 0.25 => compact()
+    expect(q.offset).toBe(0);
+    expect(q.elements).toEqual([3, 4]);
+  });
+
+  it('delete/deleteAt/addAt/setAt cover bounds and success', () => {
+    const q = new Queue<number>([1, 2, 3, 4]);
+    // consume one to introduce offset
+    expect(q.shift()).toBe(1);
+
+    expect(q.delete(999)).toBe(false);
+    expect(q.delete(3)).toBe(true);
+    expect([...q]).toEqual([2, 4]);
+
+    expect(q.at(-1)).toBeUndefined();
+    expect(q.at(999)).toBeUndefined();
+    expect(q.at(0)).toBe(2);
+
+    expect(q.deleteAt(-1)).toBeUndefined();
+    expect(q.deleteAt(999)).toBeUndefined();
+    expect(q.deleteAt(0)).toBe(2);
+    expect([...q]).toEqual([4]);
+
+    expect(q.addAt(-1, 0)).toBe(false);
+    expect(q.addAt(999, 0)).toBe(false);
+    expect(q.addAt(0, 3)).toBe(true);
+    expect([...q]).toEqual([3, 4]);
+
+    expect(q.setAt(-1, 0)).toBe(false);
+    expect(q.setAt(999, 0)).toBe(false);
+    expect(q.setAt(1, 40)).toBe(true);
+    expect([...q]).toEqual([3, 40]);
+  });
+
+  it('reverse/clear/compact basic behaviors', () => {
+    const q = new Queue<number>([1, 2, 3]);
+    q.shift();
+    expect(q.offset).toBe(1);
+
+    q.reverse();
+    expect(q.offset).toBe(0);
+    expect([...q]).toEqual([3, 2]);
+
+    q.clear();
+    expect(q.length).toBe(0);
+    expect(q.offset).toBe(0);
+
+    q.pushMany([1, 2]);
+    q.shift();
+    expect(q.compact()).toBe(true);
+    expect(q.offset).toBe(0);
+  });
+
+  it('splice triggers optional compaction and returns removed queue with copied ratio', () => {
+    const q = new Queue<number>([1, 2, 3, 4, 5], { autoCompactRatio: 0.2 });
+    q.shift();
+    q.shift(); // offset=2, len=5 => 0.4 > 0.2 would compact on next splice
+
+    const removed = q.splice(1, 2, 9, 8);
+    expect([...removed]).toEqual([4, 5]);
+    expect(removed.autoCompactRatio).toBe(q.autoCompactRatio);
+
+    expect([...q]).toEqual([3, 9, 8]);
+    expect(q.offset).toBe(0);
+  });
+
+  it('map/mapSame cover thisArg and default branches, and _createLike default elements branch', () => {
+    const q = new Queue<number>([1, 2, 3], { autoCompactRatio: 0.9 });
+
+    const mapped1 = q.map(v => v + 1);
+    expect([...mapped1]).toEqual([2, 3, 4]);
+
+    const ctx = { mul: 2 };
+    const mapped2 = q.map(function (v) {
+      // @ts-ignore
+      return v * this.mul;
+    }, undefined, ctx);
+    expect([...mapped2]).toEqual([2, 4, 6]);
+
+    const same1 = q.mapSame(v => v * 10);
+    expect([...same1]).toEqual([10, 20, 30]);
+
+    const same2 = q.mapSame(function (v) {
+      // @ts-ignore
+      return v + this.inc;
+    }, { inc: 5 });
+    expect([...same2]).toEqual([6, 7, 8]);
+
+    const like = (q as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+
+  it('_getReverseIterator skips undefined items', () => {
+    const q = new Queue<number | undefined>([1, undefined, 2]);
+    expect([...q.toReversedArray()]).toEqual([2, undefined, 1]);
+
+    const rev: (number | undefined)[] = [];
+    for (const v of (q as any)._getReverseIterator()) rev.push(v);
+    // undefined is skipped by implementation
+    expect(rev).toEqual([2, 1]);
+  });
+});

package/test/unit/data-structures/queue/queue.more-branches-2.coverage.test.ts

@@ -0,0 +1,27 @@
+import { Queue } from '../../../../src';
+
+describe('Queue remaining branch coverage (batch 2)', () => {
+  it('splice(start) hits default deleteCount=0 and can trigger auto-compaction branch', () => {
+    const q = new Queue<number>();
+    q.pushMany([1, 2, 3]);
+
+    // Prevent auto-compaction during the shifts; we want a non-zero offset.
+    q.autoCompactRatio = 1;
+
+    // Create offset > 0 while keeping underlying elements array non-empty.
+    expect(q.shift()).toBe(1);
+    expect(q.shift()).toBe(2);
+    expect(q.offset).toBe(2);
+
+    // Now ensure the condition `offset/elements.length > autoCompactRatio` is true at splice-time.
+    q.autoCompactRatio = 0;
+
+    // Omit deleteCount to hit the default-arg branch.
+    const removed = q.splice(0, undefined as any, 9);
+
+    // Should have compacted (offset reset) and inserted item.
+    expect(q.offset).toBe(0);
+    expect(q.toArray()).toEqual([9, 3]);
+    expect(removed.toArray()).toEqual([]);
+  });
+});

package/test/unit/data-structures/stack/stack.coverage.test.ts

@@ -0,0 +1,112 @@
+import { Stack } from '../../../../src';
+
+describe('Stack coverage', () => {
+  it('fromArray + basic ops cover isEmpty/peek/pop on empty', () => {
+    // constructor default params branch
+    const empty = new Stack<number>();
+    expect(empty.size).toBe(0);
+
+    const s = Stack.fromArray([1, 2, 3]);
+    expect([...s]).toEqual([1, 2, 3]);
+
+    expect(s.peek()).toBe(3);
+    expect(s.pop()).toBe(3);
+    expect(s.pop()).toBe(2);
+    expect(s.pop()).toBe(1);
+
+    expect(s.isEmpty()).toBe(true);
+    expect(s.peek()).toBeUndefined();
+    expect(s.pop()).toBeUndefined();
+  });
+
+  it('pushMany uses toElementFn conversion branch', () => {
+    const s = new Stack<number, { v: number }>([], { toElementFn: r => r.v });
+    const res = s.pushMany([{ v: 1 }, { v: 2 }]);
+    expect(res).toEqual([true, true]);
+    expect([...s]).toEqual([1, 2]);
+  });
+
+  it('delete/deleteAt cover not-found and bounds', () => {
+    const s = new Stack<number>([1, 2, 3, 2]);
+
+    // not found => _indexOfByEquals returns -1 => deleteAt(-1) false
+    expect(s.delete(999)).toBe(false);
+
+    // bounds
+    expect(s.deleteAt(-1)).toBe(false);
+    expect(s.deleteAt(999)).toBe(false);
+
+    // delete first matching occurrence (bottom-up)
+    expect(s.delete(2)).toBe(true);
+    expect([...s]).toEqual([1, 3, 2]);
+
+    // deleteAt valid
+    expect(s.deleteAt(1)).toBe(true);
+    expect([...s]).toEqual([1, 2]);
+  });
+
+  it('deleteWhere covers both match and no-match branches', () => {
+    const s = new Stack<number>([1, 2, 3]);
+    expect(s.deleteWhere(v => v === 2)).toBe(true);
+    expect([...s]).toEqual([1, 3]);
+
+    expect(s.deleteWhere(v => v === 999)).toBe(false);
+    expect([...s]).toEqual([1, 3]);
+  });
+
+  it('clear/clone/filter/mapSame/map cover instance factories and thisArg call path', () => {
+    const raw = [{ v: 1 }, { v: 2 }, { v: 3 }];
+    const s = new Stack<number, { v: number }>(raw, { toElementFn: r => r.v });
+
+    const cloned = s.clone();
+    expect([...cloned]).toEqual([1, 2, 3]);
+
+    const filtered = s.filter(v => v % 2 === 1);
+    expect([...filtered]).toEqual([1, 3]);
+
+    const mappedSame = s.mapSame(v => v * 2);
+    expect([...mappedSame]).toEqual([2, 4, 6]);
+
+    // mapSame with thisArg branch
+    const ctx2 = { mul: 3 };
+    const mappedSame2 = s.mapSame(function (v) {
+      // @ts-ignore
+      return v * this.mul;
+    }, ctx2);
+    expect([...mappedSame2]).toEqual([3, 6, 9]);
+
+
+    // map with thisArg branch
+    const ctx = { inc: 10 };
+    const mapped = s.map(function (v) {
+      // @ts-ignore
+      return v + this.inc;
+    }, undefined, ctx);
+    expect([...mapped]).toEqual([11, 12, 13]);
+
+    // map with undefined thisArg branch
+    const mapped2 = s.map(v => v + 1);
+    expect([...mapped2]).toEqual([2, 3, 4]);
+
+    // _createLike default elements branch (protected)
+    const like = (s as any)._createLike();
+    expect(like.size).toBe(0);
+
+    s.clear();
+    expect(s.size).toBe(0);
+  });
+
+  it('setEquality affects delete/search semantics', () => {
+    type Obj = { id: number };
+    const a = { id: 1 };
+    const b = { id: 2 };
+    const s = new Stack<Obj>([a, b]);
+
+    // default Object.is: new object not found
+    expect(s.delete({ id: 1 } as any)).toBe(false);
+
+    s.setEquality((x, y) => x.id === y.id);
+    expect(s.delete({ id: 1 } as any)).toBe(true);
+    expect([...s].map(x => x.id)).toEqual([2]);
+  });
+});

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

@@ -0,0 +1,9 @@
+import { TreeNode } from '../../../../src';
+
+describe('TreeNode remaining branch coverage', () => {
+  it('constructor assigns children when provided (covers if(children) branch)', () => {
+    const child = new TreeNode('c');
+    const root = new TreeNode('r', undefined, [child]);
+    expect(root.children).toEqual([child]);
+  });
+});