data-structure-typed 2.2.7 → 2.3.0

package/src/data-structures/binary-tree/tree-counter.ts

@@ -8,17 +8,17 @@
 
 import type {
   BinaryTreeDeleteResult,
-  BSTNOptKeyOrNode,
+  BSTNOptKeyOrNode, BTNRep,
   EntryCallback,
   FamilyPosition,
-  IterationType,
+  IterationType, NodePredicate,
   OptNode,
   RBTNColor,
   TreeCounterOptions
 } from '../../types';
 import { BSTNode } from './bst';
 import { IBinaryTree } from '../../interfaces';
-import { RedBlackTree } from './red-black-tree';
+import { RedBlackTree, RedBlackTreeNode } from './red-black-tree';
 
 /**
  * RB-tree node with an extra 'count' field; keeps parent/child links.
@@ -204,7 +204,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
     options?: TreeCounterOptions<K, V, R>
   ) {
     super([], options);
-    if (keysNodesEntriesOrRaws) this.addMany(keysNodesEntriesOrRaws);
+    if (keysNodesEntriesOrRaws) this.setMany(keysNodesEntriesOrRaws);
   }
 
   protected _count = 0;
@@ -255,14 +255,14 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
    * @param [count] - How much to increase the node's count (default 1).
    * @returns True if inserted/updated; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
     value?: V,
     count = 1
   ): boolean {
     const [newNode, newValue] = this._keyValueNodeOrEntryToNodeAndValue(keyNodeOrEntry, value, count);
     const orgCount = newNode?.count || 0;
-    const isSuccessAdded = super.add(newNode, newValue);
+    const isSuccessAdded = super.set(newNode, newValue);
     if (isSuccessAdded) {
       this._count += orgCount;
       return true;
@@ -274,21 +274,21 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
   /**
    * Delete a node (or decrement its count) and rebalance if needed.
    * @remarks Time O(log N), Space O(1)
-   * @param keyNodeOrEntry - Key, node, or [key, value] entry identifying the node.
+   * @param keyNodeEntryRawOrPredicate - Key, node, or [key, value] entry identifying the node.
    * @param [ignoreCount] - If true, remove the node regardless of its count.
    * @returns Array of deletion results including deleted node and a rebalance hint when present.
    */
   override delete(
-    keyNodeOrEntry: K | TreeCounterNode<K, V> | [K | null | undefined, V | undefined] | null | undefined,
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, TreeCounterNode<K, V>> | NodePredicate<TreeCounterNode<K, V> | null>,
     ignoreCount = false
   ): BinaryTreeDeleteResult<TreeCounterNode<K, V>>[] {
-    if (keyNodeOrEntry === null) return [];
+    if (keyNodeEntryRawOrPredicate === null) return [];
 
     const results: BinaryTreeDeleteResult<TreeCounterNode<K, V>>[] = [];
 
     let nodeToDelete: OptNode<TreeCounterNode<K, V>>;
-    if (this._isPredicate(keyNodeOrEntry)) nodeToDelete = this.getNode(keyNodeOrEntry);
-    else nodeToDelete = this.isRealNode(keyNodeOrEntry) ? keyNodeOrEntry : this.getNode(keyNodeOrEntry);
+    if (this._isPredicate(keyNodeEntryRawOrPredicate)) nodeToDelete = this.getNode(keyNodeEntryRawOrPredicate);
+    else nodeToDelete = this.isRealNode(keyNodeEntryRawOrPredicate) ? keyNodeEntryRawOrPredicate : this.getNode(keyNodeEntryRawOrPredicate);
     if (!nodeToDelete) {
       return results;
     }
@@ -331,9 +331,10 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
           }
         } else {
           if (ignoreCount || nodeToDelete.count <= 1) {
+            // Removing the successor from its original position should NOT change total count;
+            // only removing the target node should affect the aggregate count.
             if (successor.right !== null) {
               this._transplant(successor, successor.right);
-              this._count -= nodeToDelete.count;
             }
           } else {
             nodeToDelete.count--;
@@ -437,7 +438,7 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
 
     let index = 0;
     for (const [key, value] of this) {
-      out.add(callback.call(thisArg, value, key, index++, this));
+      out.set(callback.call(thisArg, value, key, index++, this));
     }
     return out;
   }
@@ -450,7 +451,18 @@ export class TreeCounter<K = any, V = any, R = any> extends RedBlackTree<K, V, R
   override clone(): this {
     const out = this._createInstance<K, V, R>();
     this._clone(out as unknown as any);
+
+    // Preserve aggregate count and per-node counts.
     (out as any)._count = (this as any)._count;
+
+    // NOTE: RedBlackTree._clone copies structure/keys/values, but TreeCounter nodes also track `count`.
+    // Copy counts by key to keep getComputedCount() consistent.
+    for (const node of this.dfs(n => n, 'IN')) {
+      if (!node) continue;
+      const outNode = (out as unknown as TreeCounter<K, V, R>).getNode(node.key) as any;
+      if (outNode) outNode.count = node.count;
+    }
+
     return out as unknown as this;
   }
 

package/src/data-structures/binary-tree/tree-multi-map.ts

@@ -364,7 +364,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ) {
     super([], { ...options });
     if (keysNodesEntriesOrRaws) {
-      this.addMany(keysNodesEntriesOrRaws);
+      this.setMany(keysNodesEntriesOrRaws);
     }
   }
 
@@ -385,29 +385,29 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
     return keyNodeOrEntry instanceof TreeMultiMapNode;
   }
 
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined
   ): boolean;
 
-  override add(key: K, value: V): boolean;
+  override set(key: K, value: V): boolean;
 
   /**
    * Insert a value or a list of values into the multimap. If the key exists, values are appended.
    * @remarks Time O(log N + M), Space O(1)
    * @param keyNodeOrEntry - Key, node, or [key, values] entry.
-   * @param [value] - Single value to add when a bare key is provided.
+   * @param [value] - Single value to set when a bare key is provided.
    * @returns True if inserted or appended; false if ignored.
    */
-  override add(
+  override set(
     keyNodeOrEntry: K | TreeMultiMapNode<K, V> | [K | null | undefined, V[] | undefined] | null | undefined,
     value?: V
   ): boolean {
-    if (this.isRealNode(keyNodeOrEntry)) return super.add(keyNodeOrEntry);
+    if (this.isRealNode(keyNodeOrEntry)) return super.set(keyNodeOrEntry);
 
     const _commonAdd = (key?: BTNOptKeyOrNull<K>, values?: V[]) => {
       if (key === undefined || key === null) return false;
 
-      const _addToValues = () => {
+      const _setToValues = () => {
         const existingValues = this.get(key);
         if (existingValues !== undefined && values !== undefined) {
           for (const value of values) existingValues.push(value);
@@ -416,12 +416,12 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
         return false;
       };
 
-      const _addByNode = () => {
+      const _setByNode = () => {
         const existingNode = this.getNode(key);
         if (this.isRealNode(existingNode)) {
           const existingValues = this.get(existingNode);
           if (existingValues === undefined) {
-            super.add(key, values);
+            super.set(key, values);
             return true;
           }
           if (values !== undefined) {
@@ -431,14 +431,14 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
             return false;
           }
         } else {
-          return super.add(key, values);
+          return super.set(key, values);
         }
       };
 
       if (this._isMapMode) {
-        return _addByNode() || _addToValues();
+        return _setByNode() || _setToValues();
       }
-      return _addToValues() || _addByNode();
+      return _setToValues() || _setByNode();
     };
 
     if (this.isEntry(keyNodeOrEntry)) {
@@ -503,7 +503,7 @@ export class TreeMultiMap<K = any, V = any, R = any> extends RedBlackTree<K, V[]
   ): RedBlackTree<MK, MV, MR> {
     const out = this._createLike<MK, MV, MR>([], options);
     let i = 0;
-    for (const [k, v] of this) out.add(callback.call(thisArg, v, k, i++, this));
+    for (const [k, v] of this) out.set(callback.call(thisArg, v, k, i++, this));
     return out;
   }
 

package/src/data-structures/queue/deque.ts

@@ -880,6 +880,16 @@ export class Deque<E = any, R = any> extends LinearBase<E, R> {
 
   protected _setBucketSize(size: number): void {
     this._bucketSize = size;
+
+    // When adjusting bucketSize on a freshly created empty deque (common in helpers like cut/splice/clone),
+    // we must also realign internal pointers/buckets to avoid `_getBucketAndPosition` producing out-of-range
+    // indices based on the previous bucketSize.
+    if (this._length === 0) {
+      this._buckets = [new Array(this._bucketSize)];
+      this._bucketCount = 1;
+      this._bucketFirst = this._bucketLast = 0;
+      this._firstInBucket = this._lastInBucket = this._bucketSize >> 1;
+    }
   }
 
   /**

package/src/interfaces/binary-tree.ts

@@ -50,7 +50,7 @@ export interface IBinaryTree<K = any, V = any, R = any> {
 
   // Accept BTNRep, predicate, or raw R for deletion
   delete(
-    keyNodeEntryRawOrPredicate: R | BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
+    keyNodeEntryRawOrPredicate: BTNRep<K, V, BinaryTreeNode<K, V>> | NodePredicate<BinaryTreeNode<K, V> | null>
   ): BinaryTreeDeleteResult<BinaryTreeNode<K, V>>[];
 
   clear(): void;

package/test/performance/data-structures/binary-tree/red-black-tree.test.ts

@@ -17,8 +17,7 @@ suite
   //   for (let i = 0; i < randomArray.length; i++) rbTree.set(randomArray[i]);
   // })
   .add(`${MILLION.toLocaleString()} set`, () => {
-    rbTree.clear();
-    for (let i = 0; i < randomArray.length; i++) rbTree.set(i);
+    for (let i = 0; i < randomArray.length; i++) rbTree.set(randomArray[i], randomArray[i]);
   })
   .add(`${MILLION.toLocaleString()} get`, () => {
     for (let i = 0; i < randomArray.length; i++) rbTree.get(randomArray[i]);

package/test/unit/data-structures/base/iterable-element-base.coverage.test.ts

@@ -0,0 +1,106 @@
+import { IterableElementBase } from '../../../../src/data-structures/base/iterable-element-base';
+
+class TestIterable extends IterableElementBase<number, number> {
+  private _arr: number[];
+
+  constructor(arr: number[] = [], opts?: any) {
+    super(opts);
+    this._arr = [...arr];
+  }
+
+  protected *_getIterator(): IterableIterator<number> {
+    yield* this._arr;
+  }
+
+  isEmpty(): boolean {
+    return this._arr.length === 0;
+  }
+
+  clear(): void {
+    this._arr.length = 0;
+  }
+
+  clone(): this {
+    return new TestIterable(this._arr, { toElementFn: this.toElementFn }) as unknown as this;
+  }
+
+  map<EM, RM>(cb: any, options?: any, thisArg?: unknown): IterableElementBase<EM, RM> {
+    const out = this._arr.map((v, i) => cb.call(thisArg, v, i, this));
+    // For tests we keep it minimal; toElementFn unused.
+    return new TestIterable(out as any, options) as any;
+  }
+
+  mapSame(cb: any, thisArg?: unknown): this {
+    return new TestIterable(this._arr.map((v, i) => cb.call(thisArg, v, i, this))) as unknown as this;
+  }
+
+  filter(pred: any, thisArg?: unknown): this {
+    const out: number[] = [];
+    let i = 0;
+    for (const v of this) {
+      if (pred.call(thisArg, v, i++, this)) out.push(v);
+    }
+    return new TestIterable(out) as unknown as this;
+  }
+}
+
+/**
+ * Coverage-focused tests for IterableElementBase.
+ * Keep existing @example tests intact.
+ */
+describe('IterableElementBase coverage', () => {
+  it('constructor rejects non-function toElementFn when truthy', () => {
+    expect(() => new TestIterable([], { toElementFn: 123 as any })).toThrow(TypeError);
+  });
+
+  it('every/some/forEach/find cover thisArg and non-thisArg paths', () => {
+    const t = new TestIterable([1, 2, 3]);
+
+    // thisArg === undefined path
+    expect(t.every(v => v > 0)).toBe(true);
+    expect(t.some(v => v === 2)).toBe(true);
+
+    // thisArg path
+    const ctx = { mul: 2, seen: [] as number[] };
+    expect(
+      t.every(function (this: any, v: number) {
+        return v * this.mul > 0;
+      }, ctx)
+    ).toBe(true);
+
+    t.forEach(function (this: any, v: number) {
+      this.seen.push(v);
+    }, ctx);
+    expect(ctx.seen).toEqual([1, 2, 3]);
+
+    const found = t.find(function (this: any, v: number) {
+      return v === 3;
+    }, ctx);
+    expect(found).toBe(3);
+  });
+
+  it('reduce throws on empty without initialValue, works with/without initialValue', () => {
+    const empty = new TestIterable([]);
+    expect(() => empty.reduce((acc: number, v: number) => acc + v)).toThrow(TypeError);
+
+    const t = new TestIterable([1, 2, 3]);
+    expect(t.reduce((acc: number, v: number) => acc + v, 0)).toBe(6);
+
+    // no initialValue uses first element
+    expect(t.reduce((acc: number, v: number) => acc + v)).toBe(6);
+  });
+
+  it('values/toArray/toVisual/print/has basics', () => {
+    const t = new TestIterable([1, 2]);
+    expect([...t.values()]).toEqual([1, 2]);
+    expect(t.toArray()).toEqual([1, 2]);
+    expect(t.toVisual()).toEqual([1, 2]);
+    expect(t.has(2)).toBe(true);
+    expect(t.has(3)).toBe(false);
+
+    const spy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    t.print();
+    expect(spy).toHaveBeenCalled();
+    spy.mockRestore();
+  });
+});

package/test/unit/data-structures/base/iterable-element-base.more-branches.coverage.test.ts

@@ -0,0 +1,61 @@
+import { ElementCallback, IterableElementBaseOptions } from 'src';
+import { IterableElementBase } from '../../../../src/data-structures/base/iterable-element-base';
+
+class NumIter extends IterableElementBase<number, number> {
+  override isEmpty(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  override clone(): this {
+    throw new Error('Method not implemented.');
+  }
+  override map<EM, RM>(
+    callback: ElementCallback<number, number, EM>,
+    options?: IterableElementBaseOptions<EM, RM> | undefined,
+    thisArg?: unknown
+  ): IterableElementBase<EM, RM> {
+    throw new Error('Method not implemented.');
+  }
+  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  protected override _getIterator(...args: unknown[]): IterableIterator<number> {
+    throw new Error('Method not implemented.');
+  }
+  constructor(private readonly data: number[]) {
+    super();
+  }
+
+  override *[Symbol.iterator](): IterableIterator<number> {
+    for (const n of this.data) yield n;
+  }
+}
+
+describe('IterableElementBase remaining branch coverage', () => {
+  it('every() uses thisArg branch (fn.call) and can early-return false', () => {
+    const it = new NumIter([1, 2, 3]);
+
+    const ctx = { limit: 2 };
+    const res = it.every(function (this: any, v: number) {
+      return v <= this.limit;
+    }, ctx);
+
+    expect(res).toBe(false);
+  });
+
+  it('some() uses thisArg branch (fn.call) and can early-return true', () => {
+    const it = new NumIter([1, 2, 3]);
+
+    const ctx = { pick: 2 };
+    const res = it.some(function (this: any, v: number) {
+      return v === this.pick;
+    }, ctx);
+
+    expect(res).toBe(true);
+  });
+});

package/test/unit/data-structures/base/linear-base.array.coverage.test.ts

@@ -0,0 +1,168 @@
+import { IterableElementBase } from 'src';
+import { LinearBase } from '../../../../src/data-structures/base/linear-base';
+import type { ElementCallback, IterableElementBaseOptions, LinearBaseOptions } from '../../../../src/types';
+
+class TestArrayLinear extends LinearBase<number, number> {
+  override isEmpty(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override map<EM, RM>(
+    callback: ElementCallback<number, number, EM>,
+    options?: IterableElementBaseOptions<EM, RM> | undefined,
+    thisArg?: unknown
+  ): IterableElementBase<EM, RM> {
+    throw new Error('Method not implemented.');
+  }
+  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  private _arr: number[];
+
+  constructor(values: number[] = [], options?: LinearBaseOptions<number, number>) {
+    super(options);
+    this._arr = values.slice();
+  }
+
+  get length(): number {
+    return this._arr.length;
+  }
+
+  clear(): void {
+    this._arr.length = 0;
+  }
+
+  setAt(index: number, value: number): boolean {
+    if (index < 0 || index >= this._arr.length) return false;
+    this._arr[index] = value;
+    return true;
+  }
+
+  clone(): this {
+    const out = this._createInstance();
+    out.pushMany(this._arr);
+    return out;
+  }
+
+  reverse(): this {
+    this._arr.reverse();
+    return this;
+  }
+
+  push(elementOrNode: number): boolean {
+    if (this.maxLen > 0 && this._arr.length >= this.maxLen) return false;
+    this._arr.push(elementOrNode);
+    return true;
+  }
+
+  pushMany(elements: Iterable<number>): boolean[] {
+    const out: boolean[] = [];
+    for (const e of elements) out.push(this.push(e));
+    return out;
+  }
+
+  delete(elementOrNode: number | undefined): boolean {
+    if (elementOrNode === undefined) return false;
+    const idx = this._arr.indexOf(elementOrNode);
+    if (idx === -1) return false;
+    this._arr.splice(idx, 1);
+    return true;
+  }
+
+  at(index: number): number | undefined {
+    return this._arr[index];
+  }
+
+  deleteAt(pos: number): number | undefined {
+    if (pos < 0 || pos >= this._arr.length) return undefined;
+    return this._arr.splice(pos, 1)[0];
+  }
+
+  addAt(index: number, newElementOrNode: number): boolean {
+    if (this.maxLen > 0 && this._arr.length >= this.maxLen) return false;
+    if (index < 0) index = 0;
+    if (index > this._arr.length) index = this._arr.length;
+    this._arr.splice(index, 0, newElementOrNode);
+    return true;
+  }
+
+  override toArray(): number[] {
+    return this._arr.slice();
+  }
+
+  protected _createInstance(options?: LinearBaseOptions<number, number>): this {
+    return new TestArrayLinear([], options) as unknown as this;
+  }
+
+  protected *_getIterator(): IterableIterator<number> {
+    for (const v of this._arr) yield v;
+  }
+
+  protected *_getReverseIterator(): IterableIterator<number> {
+    for (let i = this._arr.length - 1; i >= 0; i--) yield this._arr[i];
+  }
+}
+
+describe('LinearBase coverage (array-backed subclass)', () => {
+  it('constructor maxLen branch: accept positive int and ignore non-int/invalid', () => {
+    const a = new TestArrayLinear([], { maxLen: 3 });
+    expect(a.maxLen).toBe(3);
+
+    const b = new TestArrayLinear([], { maxLen: 2.2 } as any);
+    expect(b.maxLen).toBe(-1);
+
+    const c = new TestArrayLinear([], { maxLen: -5 } as any);
+    expect(c.maxLen).toBe(-1);
+  });
+
+  it('indexOf/lastIndexOf cover empty and fromIndex normalization', () => {
+    const empty = new TestArrayLinear();
+    expect(empty.indexOf(1)).toBe(-1);
+    expect(empty.lastIndexOf(1)).toBe(-1);
+
+    const list = new TestArrayLinear([1, 2, 3, 2, 1]);
+
+    expect(list.indexOf(2, -2)).toBe(3); // length + (-2) => 3
+    expect(list.indexOf(1, -999)).toBe(0); // clamp to 0
+    expect(list.lastIndexOf(2, 999)).toBe(3); // clamp to length-1
+
+    // fromIndex < 0 => length + fromIndex (may still be negative) -> returns -1
+    expect(list.lastIndexOf(2, -999)).toBe(-1);
+  });
+
+  it('concat/sort/join/toReversedArray exercise LinearBase helpers', () => {
+    const a = new TestArrayLinear([3, 1, 2]);
+    const b = new TestArrayLinear([9]);
+
+    const c = a.concat(b, 7);
+    expect(c.toArray()).toEqual([3, 1, 2, 9, 7]);
+
+    expect(c.join('-')).toBe('3-1-2-9-7');
+    expect(c.toReversedArray()).toEqual([7, 9, 2, 1, 3]);
+
+    c.sort((x, y) => x - y);
+    expect(c.toArray()).toEqual([1, 2, 3, 7, 9]);
+  });
+
+  it('slice/splice/fill cover negative indices and early-return branches', () => {
+    const list = new TestArrayLinear([1, 2, 3, 4]);
+
+    // slice negative end/start
+    expect(list.slice(1, -1).toArray()).toEqual([2, 3]);
+    expect(list.slice(-1, -1).toArray()).toEqual([]);
+
+    // splice clamps start/deleteCount
+    const removed = list.splice(-2, 999, 8, 9);
+    expect(removed.toArray()).toEqual([3, 4]);
+    expect(list.toArray()).toEqual([1, 2, 8, 9]);
+
+    // fill clamps and early return when start>=end
+    list.fill(0, 3, 2);
+    expect(list.toArray()).toEqual([1, 2, 8, 9]);
+
+    list.fill(5, -999, 999);
+    expect(list.toArray()).toEqual([5, 5, 5, 5]);
+  });
+});

package/test/unit/data-structures/base/linear-base.concat-else.coverage.test.ts

@@ -0,0 +1,82 @@
+import { ElementCallback, IterableElementBaseOptions, IterableElementBase } from 'src';
+import { LinearBase, LinkedListNode } from '../../../../src/data-structures/base/linear-base';
+
+type R = number;
+
+class ArrayLinear extends LinearBase<number, R> {
+  override setAt(index: number, value: number): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override reverse(): this {
+    throw new Error('Method not implemented.');
+  }
+  override delete(elementOrNode: number | LinkedListNode<number> | undefined): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override deleteAt(pos: number): number | undefined {
+    throw new Error('Method not implemented.');
+  }
+  override addAt(index: number, newElementOrNode: number | LinkedListNode<number>): boolean {
+    throw new Error('Method not implemented.');
+  }
+  protected override _getReverseIterator(...args: any[]): IterableIterator<number> {
+    throw new Error('Method not implemented.');
+  }
+  override isEmpty(): boolean {
+    throw new Error('Method not implemented.');
+  }
+  override clear(): void {
+    throw new Error('Method not implemented.');
+  }
+  override map<EM, RM>(
+    callback: ElementCallback<number, number, EM>,
+    options?: IterableElementBaseOptions<EM, RM> | undefined,
+    thisArg?: unknown
+  ): IterableElementBase<EM, RM> {
+    throw new Error('Method not implemented.');
+  }
+  override mapSame(callback: ElementCallback<number, number, number>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  override filter(predicate: ElementCallback<number, number, boolean>, thisArg?: unknown): this {
+    throw new Error('Method not implemented.');
+  }
+  protected _data: number[];
+  constructor(iter: Iterable<number> = []) {
+    super();
+    this._data = Array.from(iter);
+  }
+  override get length(): number {
+    return this._data.length;
+  }
+  protected _getIterator(): IterableIterator<number> {
+    return this._data[Symbol.iterator]();
+  }
+  protected _createInstance(): this {
+    return new ArrayLinear() as any;
+  }
+  override clone(): this {
+    return new ArrayLinear(this._data) as any;
+  }
+  override push(element: number): boolean {
+    this._data.push(element);
+    return true;
+  }
+  override pushMany(elements: Iterable<number>): boolean[] {
+    const ans: boolean[] = [];
+    for (const e of elements) ans.push(this.push(e));
+    return ans;
+  }
+  override at(index: number): number | undefined {
+    return this._data[index];
+  }
+}
+
+describe('LinearBase concat else-branch coverage', () => {
+  it('concat(item) uses else-branch when item is not a LinearBase', () => {
+    const l = new ArrayLinear([1, 2]);
+    // Use any-call to avoid TS overload narrowing affecting runtime call site.
+    const out = (l as any).concat(3);
+    expect(out.toArray()).toEqual([1, 2, 3]);
+  });
+});