linked-list-typed 2.5.0 → 2.5.1

package/dist/cjs-legacy/index.cjs

@@ -743,6 +743,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic SinglyLinkedList creation and push operation
   *  // Create a simple SinglyLinkedList with initial values
@@ -786,6 +807,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList pop and shift operations
   *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -835,6 +877,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove from the front
   *  const list = new SinglyLinkedList<number>([10, 20, 30]);
@@ -865,6 +928,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList unshift and forward traversal
   *  const list = new SinglyLinkedList<number>([20, 30, 40]);
@@ -956,6 +1040,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access element by index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
@@ -991,6 +1096,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get node at index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1015,6 +1141,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove by index
   *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1045,6 +1192,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove first occurrence
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
@@ -1080,6 +1248,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Insert at index
   *  const list = new SinglyLinkedList<number>([1, 3]);
@@ -1123,6 +1312,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check empty
   *  console.log(new SinglyLinkedList().isEmpty()); // true;
@@ -1143,6 +1353,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all
   *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1169,6 +1400,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reverse the list in-place
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
@@ -1361,10 +1613,31 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
-     * @example
-  * // Deep copy
-  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
-  *     const copy = list.clone();
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Deep copy
+  *  const list = new SinglyLinkedList<number>([1, 2, 3]);
+  *     const copy = list.clone();
   *     copy.pop();
   *     console.log(list.length); // 3;
   *     console.log(copy.length); // 2;
@@ -1391,6 +1664,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // SinglyLinkedList filter and map operations
   *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -1449,6 +1743,27 @@ var _SinglyLinkedList = class _SinglyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform elements
   *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1745,6 +2060,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // basic DoublyLinkedList creation and push operation
   *  // Create a simple DoublyLinkedList with initial values
@@ -1790,6 +2126,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DoublyLinkedList pop and shift operations
   *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -1834,6 +2191,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove from the front
   *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -1869,6 +2247,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Add to the front
   *  const list = new DoublyLinkedList<number>([2, 3]);
@@ -1933,6 +2332,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access by index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -1958,6 +2378,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Get node at index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2014,6 +2455,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Insert at position
   *  const list = new DoublyLinkedList<number>([1, 3]);
@@ -2098,6 +2560,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove by index
   *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2129,6 +2612,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove first occurrence
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
@@ -2162,6 +2666,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check empty
   *  console.log(new DoublyLinkedList().isEmpty()); // true;
@@ -2182,6 +2707,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all
   *  const list = new DoublyLinkedList<number>([1, 2]);
@@ -2206,6 +2752,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Search with predicate
   *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -2234,6 +2801,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find value scanning from tail
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
@@ -2265,6 +2853,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Reverse in-place
   *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2304,6 +2913,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Deep copy
   *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2333,6 +2963,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter elements
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2381,6 +3032,27 @@ var _DoublyLinkedList = class _DoublyLinkedList extends LinearLinkedBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // DoublyLinkedList for...of iteration and map operation
   *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2806,6 +3478,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check if empty
   *  const sl = new SkipList<number, string>();
@@ -2824,6 +3517,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove all entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2845,6 +3559,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Create independent copy
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2874,6 +3609,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // In-memory sorted key-value store
   *  const store = new SkipList<number, string>();
@@ -2928,17 +3684,38 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
-     * @example
-  * // Building a sorted index
-  *  type Product = { id: number; name: string; price: number };
-  *     const products: Product[] = [
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+     * @example
+  * // Building a sorted index
+  *  type Product = { id: number; name: string; price: number };
+  *     const products: Product[] = [
   *       { id: 1, name: 'Widget', price: 25 },
   *       { id: 2, name: 'Gadget', price: 50 },
   *       { id: 3, name: 'Doohickey', price: 15 }
   *     ];
   *
-  *     const index = new SkipList<number, Product>(products as any, {
-  *       toEntryFn: (p: any) => [p.price, p]
+  *     const index = new SkipList<number, Product, Product>(products, {
+  *       toEntryFn: (p: Product) => [p.price, p]
   *     });
   *
   *     // Iterate in sorted order by price
@@ -2967,6 +3744,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Check key existence
   *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
@@ -2989,6 +3787,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Fast lookup with deletion
   *  const cache = new SkipList<string, number>();
@@ -3031,6 +3850,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access the minimum entry
   *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3053,6 +3893,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Access the maximum entry
   *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3077,6 +3938,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove and return smallest
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3099,6 +3981,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Remove and return largest
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3124,6 +4027,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Least entry ≥ key
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3154,6 +4078,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Greatest entry ≤ key
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3182,6 +4127,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Strictly greater entry
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3209,6 +4175,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Strictly less entry
   *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3242,6 +4229,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Find entries in a range
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
@@ -3283,6 +4291,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Transform entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -3308,6 +4337,27 @@ var _SkipList = class _SkipList extends IterableEntryBase {
     
     
     
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
+    
      * @example
   * // Filter entries
   *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);