data-structure-typed 2.2.8 → 2.3.0

package/test/unit/data-structures/linked-list/linked-list.unshiftMany-else.coverage.test.ts

@@ -0,0 +1,15 @@
+import { DoublyLinkedList, SinglyLinkedList } from '../../../../src';
+
+describe('LinkedList unshiftMany else-branch coverage', () => {
+  it('DoublyLinkedList.unshiftMany uses else-branch when toElementFn is not provided', () => {
+    const l = new DoublyLinkedList<number>();
+    expect(l.unshiftMany([1, 2])).toEqual([true, true]);
+    expect(l.toArray()).toEqual([2, 1]);
+  });
+
+  it('SinglyLinkedList.unshiftMany uses else-branch when toElementFn is not provided', () => {
+    const l = new SinglyLinkedList<number>();
+    expect(l.unshiftMany([1, 2])).toEqual([true, true]);
+    expect(l.toArray()).toEqual([2, 1]);
+  });
+});

package/test/unit/data-structures/linked-list/singly-linked-list.coverage.test.ts

@@ -0,0 +1,221 @@
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
+
+describe('SinglyLinkedList coverage', () => {
+  it('push respects maxLen by shifting when over capacity', () => {
+    const list = new SinglyLinkedList<number>([], { maxLen: 2 });
+    list.push(1);
+    list.push(2);
+    list.push(3); // should shift 1
+    expect([...list]).toEqual([2, 3]);
+    expect(list.length).toBe(2);
+    expect(list.first).toBe(2);
+    expect(list.last).toBe(3);
+  });
+
+  it('pop covers empty, single-node, and multi-node cases', () => {
+    const empty = new SinglyLinkedList<number>();
+    expect(empty.pop()).toBeUndefined();
+
+    const single = new SinglyLinkedList<number>([1]);
+    expect(single.pop()).toBe(1);
+    expect(single.length).toBe(0);
+    expect(single.head).toBeUndefined();
+    expect(single.tail).toBeUndefined();
+
+    const multi = new SinglyLinkedList<number>([1, 2, 3]);
+    expect(multi.pop()).toBe(3);
+    expect([...multi]).toEqual([1, 2]);
+    expect(multi.tail?.value).toBe(2);
+  });
+
+  it('shift/unshift handle empty and update tail when last removed', () => {
+    const list = new SinglyLinkedList<number>();
+    expect(list.shift()).toBeUndefined();
+
+    list.unshift(1);
+    expect(list.shift()).toBe(1);
+    expect(list.head).toBeUndefined();
+    expect(list.tail).toBeUndefined();
+    expect(list.length).toBe(0);
+  });
+
+  it('pushMany/unshiftMany exercise toElementFn conversion branch', () => {
+    const list = new SinglyLinkedList<number, { v: number }>([], { toElementFn: r => r.v });
+
+    expect(list.pushMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect([...list]).toEqual([1, 2]);
+
+    expect(list.unshiftMany([{ v: 3 }, { v: 4 }])).toEqual([true, true]);
+    expect([...list]).toEqual([4, 3, 1, 2]);
+  });
+
+  it('at/getNodeAt/setAt cover bounds and success cases', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+
+    expect(list.at(-1)).toBeUndefined();
+    expect(list.at(999)).toBeUndefined();
+    expect(list.at(1)).toBe(2);
+
+    expect(list.getNodeAt(-1)).toBeUndefined();
+    expect(list.getNodeAt(999)).toBeUndefined();
+
+    expect(list.setAt(999, 0)).toBe(false);
+    expect(list.setAt(1, 20)).toBe(true);
+    expect([...list]).toEqual([1, 20, 3]);
+  });
+
+  it('deleteAt covers head delete, tail delete, and middle delete', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+
+    expect(list.deleteAt(-1)).toBeUndefined();
+    expect(list.deleteAt(999)).toBeUndefined();
+
+    // head
+    expect(list.deleteAt(0)).toBe(1);
+    expect([...list]).toEqual([2, 3]);
+
+    // tail
+    expect(list.deleteAt(1)).toBe(3);
+    expect([...list]).toEqual([2]);
+    expect(list.tail?.value).toBe(2);
+
+    // middle (rebuild)
+    list.pushMany([3, 4]); // [2,3,4]
+    expect(list.deleteAt(1)).toBe(3);
+    expect([...list]).toEqual([2, 4]);
+  });
+
+  it('delete covers undefined input, missing node, and deleting head/tail', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+
+    expect(list.delete(undefined)).toBe(false);
+    expect(list.delete(999)).toBe(false);
+
+    // delete head
+    expect(list.delete(1)).toBe(true);
+    expect([...list]).toEqual([2, 3]);
+
+    // delete tail
+    expect(list.delete(3)).toBe(true);
+    expect([...list]).toEqual([2]);
+    expect(list.tail?.value).toBe(2);
+  });
+
+  it('reverse early-return and full reverse path', () => {
+    const empty = new SinglyLinkedList<number>();
+    expect(empty.reverse()).toBe(empty);
+
+    const single = new SinglyLinkedList<number>([1]);
+    expect([...single.reverse()]).toEqual([1]);
+
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+    list.reverse();
+    expect([...list]).toEqual([3, 2, 1]);
+    expect(list.first).toBe(3);
+    expect(list.last).toBe(1);
+  });
+
+  it('getNode/search handle undefined, node pass-through, and predicate branches', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+    expect(list.getNode(undefined)).toBeUndefined();
+
+    const n2 = list.getNodeAt(1)!;
+    expect(list.getNode(n2)).toBe(n2);
+
+    expect(list.getNode(node => node.value === 3)?.value).toBe(3);
+    expect(list.search(node => node.value === 2)).toBe(2);
+  });
+
+  it('addAt/addBefore/addAfter cover boundary and missing-node cases', () => {
+    const list = new SinglyLinkedList<number>([2, 4]);
+
+    expect(list.addAt(-1, 0)).toBe(false);
+    expect(list.addAt(999, 0)).toBe(false);
+
+    // addAt head/tail/middle
+    expect(list.addAt(0, 1)).toBe(true);
+    expect(list.addAt(list.length, 5)).toBe(true);
+    expect(list.addAt(2, 3)).toBe(true);
+    expect([...list]).toEqual([1, 2, 3, 4, 5]);
+
+    // addBefore/After missing
+    expect(list.addBefore(999, 0)).toBe(false);
+    expect(list.addAfter(999, 0)).toBe(false);
+
+    // addBefore head
+    expect(list.addBefore(1, 0)).toBe(true);
+    // addAfter tail
+    expect(list.addAfter(5, 6)).toBe(true);
+    expect([...list]).toEqual([0, 1, 2, 3, 4, 5, 6]);
+  });
+
+  it('splice covers remove-only, insert-only, remove+insert, and empty-result reset', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
+
+    // remove middle
+    const removed = list.splice(1, 2);
+    expect([...removed]).toEqual([2, 3]);
+    expect([...list]).toEqual([1, 4]);
+
+    // insert at head without deletion
+    const removed2 = list.splice(0, 0, 9, 8);
+    expect([...removed2]).toEqual([]);
+    expect([...list]).toEqual([9, 8, 1, 4]);
+
+    // remove tail and insert
+    const removed3 = list.splice(3, 10, 7);
+    expect([...removed3]).toEqual([4]);
+    expect([...list]).toEqual([9, 8, 1, 7]);
+
+    // remove everything, expect head/tail reset
+    const removedAll = list.splice(0, 999);
+    expect([...removedAll]).toEqual([9, 8, 1, 7]);
+    expect(list.length).toBe(0);
+    expect(list.head).toBeUndefined();
+    expect(list.tail).toBeUndefined();
+  });
+
+  it('countOccurrences covers element/node/predicate branches and setEquality', () => {
+    type Obj = { id: number };
+    const a: Obj = { id: 1 };
+    const b: Obj = { id: 1 };
+    const c: Obj = { id: 2 };
+
+    const list = new SinglyLinkedList<Obj>([a, c]);
+
+    // default Object.is: b is not the same ref as a
+    expect(list.countOccurrences(b)).toBe(0);
+
+    list.setEquality((x, y) => x.id === y.id);
+    expect(list.countOccurrences(b)).toBe(1);
+
+    const nodeA = list.getNodeAt(0)!;
+    expect(list.countOccurrences(nodeA)).toBe(1);
+
+    expect(list.countOccurrences(node => node.value.id === 2)).toBe(1);
+  });
+
+  it('deleteWhere covers deleting head and tail branches + no-match', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+
+    // delete head branch
+    expect(list.deleteWhere(v => v === 1)).toBe(true);
+    expect([...list]).toEqual([2, 3]);
+
+    // delete tail branch
+    expect(list.deleteWhere(v => v === 3)).toBe(true);
+    expect([...list]).toEqual([2]);
+    expect(list.tail?.value).toBe(2);
+
+    // no match
+    expect(list.deleteWhere(v => v === 999)).toBe(false);
+  });
+
+  it('_getPrevNode not-found branch via foreign node', () => {
+    const list = new SinglyLinkedList<number>([1, 2, 3]);
+    const foreign = new SinglyLinkedListNode(2);
+
+    // Access protected for branch coverage.
+    expect((list as any)._getPrevNode(foreign)).toBeUndefined();
+  });
+});

package/test/unit/data-structures/linked-list/singly-linked-list.more-branches.coverage.test.ts

@@ -0,0 +1,86 @@
+import { SinglyLinkedList, SinglyLinkedListNode } from '../../../../src';
+
+describe('SinglyLinkedList additional branch coverage', () => {
+  it('unshiftMany uses toElementFn branch when provided', () => {
+    const l = new SinglyLinkedList<number, { v: number }>([], {
+      toElementFn: r => r.v
+    });
+    expect(l.unshiftMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect(l.toArray()).toEqual([2, 1]);
+  });
+
+  it('addBefore sets tail when prevNode is undefined and internal tail is missing (covers if(!this._tail))', () => {
+    const l = new SinglyLinkedList<number>();
+    l.push(1);
+
+    // Corrupt internal tail so the recovery branch runs.
+    (l as any)._tail = undefined;
+
+    expect(l.addBefore(1, 0)).toBe(true);
+    expect(l.toArray()).toEqual([0, 1]);
+    // and tail should be restored (best-effort invariant)
+    expect((l as any)._tail).toBeDefined();
+  });
+
+  it('splice uses default deleteCount=0 when omitted', () => {
+    const l = new SinglyLinkedList<number>();
+    l.pushMany([1, 2, 3]);
+
+    const removed = l.splice(1); // deleteCount omitted
+    expect(removed.toArray()).toEqual([]);
+    expect(l.toArray()).toEqual([1, 2, 3]);
+  });
+
+  it('deleteWhere sets tail to undefined when removing the only element (covers current===_tail branch)', () => {
+    const l = new SinglyLinkedList<number>();
+    l.push(1);
+
+    expect(l.deleteWhere(v => v === 1)).toBe(true);
+    expect(l.length).toBe(0);
+    expect((l as any)._tail).toBeUndefined();
+  });
+
+  it('mapSame covers both ternary arms (thisArg undefined vs defined)', () => {
+    const l = new SinglyLinkedList<number>();
+    l.pushMany([1, 2]);
+
+    // thisArg === undefined branch
+    expect(l.mapSame(v => v + 1).toArray()).toEqual([2, 3]);
+
+    // thisArg provided branch
+    const ctx = { add: 10 };
+    expect(
+      l
+        .mapSame(function (this: any, v: number) {
+          return v + this.add;
+        }, ctx)
+        .toArray()
+    ).toEqual([11, 12]);
+  });
+
+  it('_ensureNode returns the same node when input is a node (covers isNode true branch)', () => {
+    const l = new SinglyLinkedList<number>();
+    l.pushMany([1, 3]);
+
+    const existing = l.getNodeAt(0)!;
+    const newNode = new SinglyLinkedListNode(2);
+
+    // addAfter calls _ensureNode(newElementOrNode)
+    expect(l.addAfter(existing, newNode)).toBe(true);
+    expect(l.toArray()).toEqual([1, 2, 3]);
+  });
+
+  it('_ensurePredicate covers isNode(target) branch via search(node)', () => {
+    const l = new SinglyLinkedList<number>();
+    l.pushMany([1, 2, 3]);
+
+    const target = l.getNodeAt(1)!;
+    expect(l.search(target)).toBe(2);
+  });
+
+  it('_createLike default-arg path can be called with no args', () => {
+    const l = new SinglyLinkedList<number>();
+    const like = (l as any)._createLike();
+    expect(like.length).toBe(0);
+  });
+});

package/test/unit/data-structures/linked-list/skip-linked-list.more-branches.coverage.test.ts

@@ -0,0 +1,31 @@
+import { SkipList } from '../../../../src';
+
+describe('SkipList additional branch coverage', () => {
+  it('constructor applies options branches (maxLevel/probability) and first() returns undefined when empty', () => {
+    const s = new SkipList<number, number>([], { maxLevel: 8, probability: 0.25 });
+    expect(s.maxLevel).toBe(8);
+    expect(s.probability).toBe(0.25);
+
+    // covers `firstNode ? ... : undefined` false arm
+    expect(s.first).toBeUndefined();
+  });
+
+  it('delete() covers the break branch when deleted node has smaller level than list level', () => {
+    const s = new SkipList<number, string>();
+
+    // Force deterministic node levels: first node makes list level high, second is low-level.
+    const origRandomLevel = (s as any)._randomLevel;
+    const levels = [4, 1];
+    (s as any)._randomLevel = () => levels.shift() ?? 1;
+    try {
+      s.add(1, 'hi'); // level 4, end -> raises list level
+      s.add(2, 'lo'); // level 1, end, list level stays 4
+
+      expect(s.level).toBeGreaterThan(1);
+      expect(s.delete(2)).toBe(true);
+      expect(s.get(2)).toBeUndefined();
+    } finally {
+      (s as any)._randomLevel = origRandomLevel;
+    }
+  });
+});

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

@@ -0,0 +1,81 @@
+import { Matrix } from '../../../../src';
+
+describe('Matrix additional branch coverage', () => {
+  it('inverse throws when matrix is singular (pivotRow reaches rows)', () => {
+    const m = new Matrix([[0]], { rows: 1, cols: 1 });
+    expect(() => m.inverse()).toThrow(/singular/i);
+  });
+
+  it('inverse hits division-by-zero guard (pivotElement===0) via get() monkeypatch', () => {
+    const m = new Matrix(
+      [
+        [1, 0],
+        [0, 1]
+      ],
+      { rows: 2, cols: 2 }
+    );
+
+    const origGet = (Matrix as any).prototype.get;
+    try {
+      (Matrix as any).prototype.get = function (row: number, col: number) {
+        // Make pivot search succeed (non-zero) but pivot element read as 0.
+        if (row === col) return 0;
+        return 1;
+      };
+      expect(() => m.inverse()).toThrow(/division by zero/i);
+    } finally {
+      (Matrix as any).prototype.get = origGet;
+    }
+  });
+
+  it('inverse treats undefined elimination factor as 0 (factor===undefined branch)', () => {
+    const m = new Matrix(
+      [
+        [1, 0],
+        [0, 1]
+      ],
+      { rows: 2, cols: 2 }
+    );
+
+    const origGet = (Matrix as any).prototype.get;
+    try {
+      (Matrix as any).prototype.get = function (row: number, col: number) {
+        // Provide real diagonal for pivoting
+        if (row === col) return 1;
+        // For elimination factor reads (j,i) when j!=i, return undefined
+        return undefined;
+      };
+
+      // Should still return something (we only care about branch execution)
+      const inv = m.inverse();
+      expect(inv?.rows).toBe(2);
+      expect(inv?.cols).toBe(2);
+    } finally {
+      (Matrix as any).prototype.get = origGet;
+    }
+  });
+
+  it('_scaleRow and _addScaledRow coerce undefined multiply/add results to 0', () => {
+    const m = new Matrix(
+      [
+        [1, 2],
+        [3, 4]
+      ],
+      {
+        rows: 2,
+        cols: 2,
+        multiplyFn: () => undefined as any,
+        addFn: () => undefined as any
+      }
+    );
+
+    // call protected helpers via any
+    (m as any)._scaleRow(0, 2);
+    expect(m.data[0][0]).toBe(0);
+    expect(m.data[0][1]).toBe(0);
+
+    (m as any)._addScaledRow(1, 0, 3);
+    expect(m.data[1][0]).toBe(0);
+    expect(m.data[1][1]).toBe(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']);
+  });
+});