linked-list-typed 2.5.0 → 2.5.1

package/dist/umd/linked-list-typed.js

@@ -762,6 +762,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic SinglyLinkedList creation and push operation
     *  // Create a simple SinglyLinkedList with initial values
@@ -805,6 +826,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList pop and shift operations
     *  const list = new SinglyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -854,6 +896,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove from the front
     *  const list = new SinglyLinkedList<number>([10, 20, 30]);
@@ -884,6 +947,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList unshift and forward traversal
     *  const list = new SinglyLinkedList<number>([20, 30, 40]);
@@ -975,6 +1059,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access element by index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c', 'd']);
@@ -1010,6 +1115,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node at index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1034,6 +1160,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove by index
     *  const list = new SinglyLinkedList<string>(['a', 'b', 'c']);
@@ -1064,6 +1211,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove first occurrence
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 2]);
@@ -1099,6 +1267,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Insert at index
     *  const list = new SinglyLinkedList<number>([1, 3]);
@@ -1142,6 +1331,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new SinglyLinkedList().isEmpty()); // true;
@@ -1162,6 +1372,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all
     *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1188,6 +1419,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reverse the list in-place
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 4]);
@@ -1380,10 +1632,31 @@ var linkedListTyped = (() => {
       
       
       
-       * @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;
@@ -1410,6 +1683,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // SinglyLinkedList filter and map operations
     *  const list = new SinglyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -1468,6 +1762,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform elements
     *  const list = new SinglyLinkedList<number>([1, 2, 3]);
@@ -1759,6 +2074,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // basic DoublyLinkedList creation and push operation
     *  // Create a simple DoublyLinkedList with initial values
@@ -1804,6 +2140,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DoublyLinkedList pop and shift operations
     *  const list = new DoublyLinkedList<number>([10, 20, 30, 40, 50]);
@@ -1848,6 +2205,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove from the front
     *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -1883,6 +2261,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Add to the front
     *  const list = new DoublyLinkedList<number>([2, 3]);
@@ -1947,6 +2346,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access by index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -1972,6 +2392,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Get node at index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2028,6 +2469,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Insert at position
     *  const list = new DoublyLinkedList<number>([1, 3]);
@@ -2112,6 +2574,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove by index
     *  const list = new DoublyLinkedList<string>(['a', 'b', 'c']);
@@ -2143,6 +2626,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove first occurrence
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 2]);
@@ -2176,6 +2680,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check empty
     *  console.log(new DoublyLinkedList().isEmpty()); // true;
@@ -2196,6 +2721,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all
     *  const list = new DoublyLinkedList<number>([1, 2]);
@@ -2220,6 +2766,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Search with predicate
     *  const list = new DoublyLinkedList<number>([10, 20, 30]);
@@ -2248,6 +2815,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find value scanning from tail
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4]);
@@ -2279,6 +2867,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Reverse in-place
     *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2318,6 +2927,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Deep copy
     *  const list = new DoublyLinkedList<number>([1, 2, 3]);
@@ -2347,6 +2977,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter elements
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2395,6 +3046,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // DoublyLinkedList for...of iteration and map operation
     *  const list = new DoublyLinkedList<number>([1, 2, 3, 4, 5]);
@@ -2812,6 +3484,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check if empty
     *  const sl = new SkipList<number, string>();
@@ -2830,6 +3523,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove all entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2851,6 +3565,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Create independent copy
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -2880,6 +3615,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // In-memory sorted key-value store
     *  const store = new SkipList<number, string>();
@@ -2934,17 +3690,38 @@ var linkedListTyped = (() => {
       
       
       
-       * @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
@@ -2973,6 +3750,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Check key existence
     *  const sl = new SkipList<number, string>([[1, 'a'], [3, 'c'], [5, 'e']]);
@@ -2995,6 +3793,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Fast lookup with deletion
     *  const cache = new SkipList<string, number>();
@@ -3037,6 +3856,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access the minimum entry
     *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3059,6 +3899,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Access the maximum entry
     *  const sl = new SkipList<number, string>([[5, 'e'], [1, 'a'], [3, 'c']]);
@@ -3083,6 +3944,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove and return smallest
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3105,6 +3987,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Remove and return largest
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);
@@ -3130,6 +4033,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Least entry ≥ key
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3160,6 +4084,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Greatest entry ≤ key
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3188,6 +4133,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Strictly greater entry
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3215,6 +4181,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Strictly less entry
     *  const sl = new SkipList<number, string>([[10, 'a'], [20, 'b'], [30, 'c']]);
@@ -3248,6 +4235,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Find entries in a range
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c'], [4, 'd'], [5, 'e']]);
@@ -3289,6 +4297,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Transform entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b']]);
@@ -3314,6 +4343,27 @@ var linkedListTyped = (() => {
       
       
       
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
+      
        * @example
     * // Filter entries
     *  const sl = new SkipList<number, string>([[1, 'a'], [2, 'b'], [3, 'c']]);