data-structure-typed 2.2.7 → 2.3.0

package/test/unit/data-structures/heap/heap.misc-branches.coverage.test.ts

@@ -0,0 +1,110 @@
+import { Heap, FibonacciHeap } from '../../../../src';
+
+describe('Heap / FibonacciHeap misc branch coverage', () => {
+  it('Heap.deleteBy covers not-found, idx=0 poll, idx=last pop, idx=middle splice paths', () => {
+    const h = new Heap<number>();
+    h.add(3);
+    h.add(1);
+    h.add(2);
+
+    expect(h.deleteBy(() => false)).toBe(false); // idx stays -1
+
+    // idx === 0
+    expect(h.deleteBy(x => x === h.peek())).toBe(true);
+
+    // ensure at least 2 elems again
+    h.add(4);
+    h.add(5);
+
+    // idx === last
+    const last = (h as any).elements[(h as any).elements.length - 1];
+    expect(h.deleteBy(x => x === last)).toBe(true);
+
+    // idx in middle
+    const mid = (h as any).elements[1];
+    expect(h.deleteBy(x => x === mid)).toBe(true);
+  });
+
+  it('Heap.filter covers thisArg branch and else(i++) branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+    h.add(3);
+
+    const ctx = { ok: true };
+    const out = h.filter(function (this: any, x: number) {
+      // keep only one element so the else branch runs too
+      return this.ok && x === 2;
+    }, ctx);
+
+    expect(out.toArray()).toEqual([2]);
+  });
+
+  it('Heap.map throws when comparator missing, and uses thisArg branch when provided', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+
+    expect(() => h.map(x => ({ x }), {} as any)).toThrow(/requires options\.comparator/i);
+
+    const ctx = { mul: 10 };
+    const mapped = h.map(
+      function (this: any, x: number) {
+        return x * this.mul;
+      },
+      { comparator: (a: number, b: number) => a - b },
+      ctx
+    );
+
+    expect(mapped.peek()).toBe(10);
+  });
+
+  it('Heap.mapSame covers thisArg branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(3);
+
+    const ctx = { add: 7 };
+    const out = h.mapSame(function (this: any, x: number) {
+      return x + this.add;
+    }, ctx);
+
+    expect(out.peek()).toBe(8);
+  });
+
+  it('Heap._createLike default-arg path can be called via (heap as any)._createLike()', () => {
+    const h = new Heap<number>();
+    const like = (h as any)._createLike();
+    expect(like.size).toBe(0);
+  });
+
+  it('FibonacciHeap constructor throws when comparator is not a function', () => {
+    expect(() => new FibonacciHeap<number>(123 as any)).toThrow(/comparator must be a function/i);
+  });
+
+  it('FibonacciHeap.consumeLinkedList(undefined) returns [] (covers !head guard)', () => {
+    const fh = new FibonacciHeap<number>();
+    expect(fh.consumeLinkedList(undefined)).toEqual([]);
+  });
+
+  it('FibonacciHeap.merge covers empty-merge early return, empty-this adopt-root, and non-empty root-merge', () => {
+    const a = new FibonacciHeap<number>();
+    const b = new FibonacciHeap<number>();
+
+    // empty merge early return
+    a.merge(b);
+    expect(a.size).toBe(0);
+
+    // empty-this adopt-root
+    b.add(5);
+    a.merge(b);
+    expect(a.size).toBe(1);
+
+    // non-empty root-merge + min update paths
+    const c = new FibonacciHeap<number>();
+    c.add(1);
+    c.add(10);
+    a.merge(c);
+    expect(a.peek()).toBe(1);
+  });
+});

package/test/unit/data-structures/heap/heap.remaining-branches.coverage.test.ts

@@ -0,0 +1,22 @@
+import { Heap } from '../../../../src';
+
+describe('Heap remaining branch coverage', () => {
+  it('Heap.map with options undefined hits (options ?? {}) path and throws for missing comparator', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    expect(() => (h as any).map((x: number) => x, undefined)).toThrow(/requires options\.comparator/i);
+  });
+
+  it('Heap.mapSame without thisArg hits thisArg===undefined branch', () => {
+    const h = new Heap<number>();
+    h.add(1);
+    h.add(2);
+    const out = h.mapSame(x => x * 2);
+    expect(out.toArray().sort((a, b) => a - b)).toEqual([2, 4]);
+  });
+
+  it('Heap default comparator throws when comparing object types', () => {
+    const h = new Heap<any>();
+    expect(() => (h as any)._DEFAULT_COMPARATOR({}, 1)).toThrow(TypeError);
+  });
+});

package/test/unit/data-structures/heap/max-heap.coverage.test.ts

@@ -0,0 +1,29 @@
+import { MaxHeap } from '../../../../src';
+
+/**
+ * Coverage-focused test for MaxHeap comparator branches.
+ * Keep existing @example tests intact.
+ */
+describe('MaxHeap coverage', () => {
+  it('orders numbers as a max-heap (a<b / a>b / equal branches)', () => {
+    const h = new MaxHeap<number>();
+
+    h.add(2);
+    h.add(1);
+    h.add(3);
+    h.add(3); // equal branch exercised during comparisons
+
+    expect(h.peek()).toBe(3);
+    expect(h.poll()).toBe(3);
+    expect(h.poll()).toBe(3);
+    expect(h.poll()).toBe(2);
+    expect(h.poll()).toBe(1);
+    expect(h.poll()).toBe(undefined);
+  });
+
+  it('throws when comparing object types without custom comparator', () => {
+    const h = new MaxHeap<any>();
+    h.add({ k: 1 });
+    expect(() => h.add({ k: 2 })).toThrow(TypeError);
+  });
+});

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

@@ -0,0 +1,72 @@
+import { DoublyLinkedList, DoublyLinkedListNode } from '../../../../src';
+
+describe('DoublyLinkedList additional branch coverage', () => {
+  it('unshiftMany uses toElementFn branch when provided', () => {
+    const l = new DoublyLinkedList<number, { v: number }>([], {
+      toElementFn: r => r.v
+    });
+    expect(l.unshiftMany([{ v: 1 }, { v: 2 }])).toEqual([true, true]);
+    expect(l.toArray()).toEqual([2, 1]);
+  });
+
+  it('getNode(undefined) returns undefined (covers early return)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2]);
+    expect(l.getNode(undefined)).toBeUndefined();
+  });
+
+  it('setAt returns false when node does not exist', () => {
+    const l = new DoublyLinkedList<number>();
+    expect(l.setAt(0, 1)).toBe(false);
+  });
+
+  it('search returns value when predicate matches (covers predicate(current) true branch)', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2, 3]);
+    expect(l.search(n => n.value === 2)).toBe(2);
+  });
+
+  it('mapSame covers both thisArg branches', () => {
+    const l = new DoublyLinkedList<number>();
+    l.pushMany([1, 2]);
+
+    // thisArg === undefined arm
+    expect(l.mapSame(v => v + 1).toArray()).toEqual([2, 3]);
+
+    // thisArg provided arm
+    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 DoublyLinkedList<number>();
+    l.pushMany([1, 3]);
+
+    const existing = l.getNodeAt(0)!;
+    const newNode = new DoublyLinkedListNode(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 DoublyLinkedList<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 DoublyLinkedList<number>();
+    const like = (l as any)._createLike();
+    expect(like.length).toBe(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);
+  });
+});