data-structure-typed 0.9.16 → 1.12.9

package/dist/data-structures/hash/coordinate-map.js

@@ -16,6 +16,10 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateMap = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var CoordinateMap = /** @class */ (function (_super) {
     __extends(CoordinateMap, _super);
     function CoordinateMap(joint) {
@@ -25,15 +29,43 @@ var CoordinateMap = /** @class */ (function (_super) {
             _this._joint = joint;
         return _this;
     }
+    /**
+     * The "has" function overrides the base class's "has" function and checks if a key exists in the map by joining the
+     * key array with a specified delimiter.
+     * @param {number[]} key - The parameter "key" is an array of numbers.
+     * @returns The `has` method is being overridden to return the result of calling the `has` method of the superclass
+     * (`super.has`) with the `key` array joined together using the `_joint` property.
+     */
     CoordinateMap.prototype.has = function (key) {
         return _super.prototype.has.call(this, key.join(this._joint));
     };
+    /**
+     * The function overrides the set method of a Map object to convert the key from an array to a string using a specified
+     * delimiter before calling the original set method.
+     * @param {number[]} key - The key parameter is an array of numbers.
+     * @param {V} value - The value parameter is the value that you want to associate with the specified key.
+     * @returns The `set` method is returning the result of calling the `set` method of the superclass
+     * (`super.set(key.join(this._joint), value)`).
+     */
     CoordinateMap.prototype.set = function (key, value) {
         return _super.prototype.set.call(this, key.join(this._joint), value);
     };
+    /**
+     * The function overrides the get method to join the key array with a specified joint and then calls the super get
+     * method.
+     * @param {number[]} key - An array of numbers
+     * @returns The code is returning the value associated with the specified key in the map.
+     */
     CoordinateMap.prototype.get = function (key) {
         return _super.prototype.get.call(this, key.join(this._joint));
     };
+    /**
+     * The function overrides the delete method and joins the key array using a specified joint character before calling
+     * the super delete method.
+     * @param {number[]} key - An array of numbers that represents the key to be deleted.
+     * @returns The `delete` method is returning the result of calling the `delete` method on the superclass, with the
+     * `key` array joined together using the `_joint` property.
+     */
     CoordinateMap.prototype.delete = function (key) {
         return _super.prototype.delete.call(this, key.join(this._joint));
     };

package/dist/data-structures/hash/coordinate-set.d.ts

@@ -1,7 +1,32 @@
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 export declare class CoordinateSet extends Set {
     private readonly _joint;
     constructor(joint?: string);
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
     has(value: number[]): boolean;
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
     add(value: number[]): this;
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
     delete(value: number[]): boolean;
 }

package/dist/data-structures/hash/coordinate-set.js

@@ -16,6 +16,10 @@ var __extends = (this && this.__extends) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CoordinateSet = void 0;
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var CoordinateSet = /** @class */ (function (_super) {
     __extends(CoordinateSet, _super);
     function CoordinateSet(joint) {
@@ -25,12 +29,33 @@ var CoordinateSet = /** @class */ (function (_super) {
             _this._joint = joint;
         return _this;
     }
+    /**
+     * The "has" function overrides the "has" method of the superclass and checks if a value exists in an array after
+     * joining its elements with a specified separator.
+     * @param {number[]} value - The parameter "value" is an array of numbers.
+     * @returns The overridden `has` method is returning the result of calling the `has` method of the superclass, passing
+     * in the joined value as an argument.
+     */
     CoordinateSet.prototype.has = function (value) {
         return _super.prototype.has.call(this, value.join(this._joint));
     };
+    /**
+     * The "add" function overrides the parent class's "add" function by joining the elements of the input array with a
+     * specified delimiter before calling the parent class's "add" function.
+     * @param {number[]} value - An array of numbers
+     * @returns The overridden `add` method is returning the result of calling the `add` method of the superclass
+     * (`super.add`) with the joined string representation of the `value` array (`value.join(this._joint)`).
+     */
     CoordinateSet.prototype.add = function (value) {
         return _super.prototype.add.call(this, value.join(this._joint));
     };
+    /**
+     * The function overrides the delete method and deletes an element from a Set by joining the elements of the input
+     * array with a specified joint and then calling the delete method of the parent class.
+     * @param {number[]} value - An array of numbers
+     * @returns The `delete` method is returning the result of calling the `delete` method of the superclass, with the
+     * `value` array joined together using the `_joint` property.
+     */
     CoordinateSet.prototype.delete = function (value) {
         return _super.prototype.delete.call(this, value.join(this._joint));
     };

package/dist/data-structures/heap/heap.d.ts

@@ -1,66 +1,61 @@
-import { PriorityQueue } from '../priority-queue';
-import type { HeapItem, HeapOptions } from '../types';
 /**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
- *
- * @abstract
- * @class Heap
  */
+import { PriorityQueue } from '../priority-queue';
+import type { HeapItem, HeapOptions } from '../types';
 export declare abstract class Heap<T> {
     protected abstract _pq: PriorityQueue<HeapItem<T>>;
     protected _priorityCb: (element: T) => number;
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
      */
     protected constructor(options?: HeapOptions<T>);
     /**
-     * @public
-     * @returns {number}
+     * The function returns the size of a priority queue.
+     * @returns The size of the priority queue.
      */
     get size(): number;
     /**
-     * @public
-     * @returns {boolean}
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     isEmpty(): boolean;
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
      */
     peek(): HeapItem<T> | null;
     /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
      */
     peekLast(): HeapItem<T> | null;
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
     offer(element: T, priority?: number): Heap<T>;
     /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     poll(): HeapItem<T> | null;
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
     toArray(): HeapItem<T>[];
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     clear(): void;
 }

package/dist/data-structures/heap/heap.js

@@ -1,18 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Heap = void 0;
-/**
- * @copyright 2021 Tyler Zeng <zrwusa@gmail.com>
- * @license MIT
- *
- * @abstract
- * @class Heap
- */
 var Heap = /** @class */ (function () {
     /**
-     * Creates a priority queue
-     * @public
-     * @params {object} [options]
+     * The function is a constructor for a class that initializes a priority callback function based on the
+     * options provided.
+     * @param [options] - An optional object that contains configuration options for the Heap.
      */
     function Heap(options) {
         if (options) {
@@ -28,8 +21,8 @@ var Heap = /** @class */ (function () {
     }
     Object.defineProperty(Heap.prototype, "size", {
         /**
-         * @public
-         * @returns {number}
+         * The function returns the size of a priority queue.
+         * @returns The size of the priority queue.
          */
         get: function () {
             return this._pq.size;
@@ -38,33 +31,34 @@ var Heap = /** @class */ (function () {
         configurable: true
     });
     /**
-     * @public
-     * @returns {boolean}
+     * The function checks if a priority queue is empty.
+     * @returns {boolean} A boolean value indicating whether the size of the priority queue is less than 1.
      */
     Heap.prototype.isEmpty = function () {
         return this._pq.size < 1;
     };
     /**
-     * Returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peek` function returns the top item in the priority queue without removing it.
+     * @returns The `peek()` method is returning either a `HeapItem<T>` object or `null`.Returns an element with the highest priority in the queue
      */
     Heap.prototype.peek = function () {
         return this._pq.peek();
     };
     /**
-     * Returns an element with lowest priority in the queue
-     * @public
-     * @returns {object}
+     * The `peekLast` function returns the last item in the heap.
+     * @returns The method `peekLast()` returns either a `HeapItem<T>` object or `null`.Returns an element with the lowest priority in the queue
      */
     Heap.prototype.peekLast = function () {
         return this._pq.leaf();
     };
     /**
-     * Adds an element to the queue
-     * @public
-     * @param {any} element
-     * @param priority
+     * The `offer` function adds an element to a priority queue with an optional priority value.
+     * @param {T} element - The `element` parameter represents the value that you want to add to the heap. It can be of any
+     * type.
+     * @param {number} [priority] - The `priority` parameter is an optional number that represents the priority of the
+     * element being offered to the heap. If the `element` parameter is a number, then the `priority` parameter is set to
+     * the value of `element`. If the `element` parameter is not a number, then the
+     * @returns The `offer` method returns the instance of the `Heap` class.
      * @throws {Error} if priority is not a valid number
      */
     Heap.prototype.offer = function (element, priority) {
@@ -88,9 +82,8 @@ var Heap = /** @class */ (function () {
         return this;
     };
     /**
-     * Removes and returns an element with highest priority in the queue
-     * @public
-     * @returns {object}
+     * The `poll` function returns the top item from a priority queue or null if the queue is empty.Removes and returns an element with the highest priority in the queue
+     * @returns either a HeapItem<T> object or null.
      */
     Heap.prototype.poll = function () {
         var top = this._pq.poll();
@@ -100,16 +93,14 @@ var Heap = /** @class */ (function () {
         return top;
     };
     /**
-     * Returns a sorted list of elements
-     * @public
-     * @returns {array}
+     * The `toArray` function returns an array of `HeapItem<T>` objects.
+     * @returns An array of HeapItem<T> objects.Returns a sorted list of elements
      */
     Heap.prototype.toArray = function () {
         return this._pq.toArray();
     };
     /**
-     * Clears the queue
-     * @public
+     * The clear function clears the priority queue.
      */
     Heap.prototype.clear = function () {
         this._pq.clear();

package/dist/data-structures/heap/max-heap.d.ts

@@ -1,5 +1,5 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 import { Heap } from './heap';
@@ -11,5 +11,10 @@ import type { HeapItem, HeapOptions } from '../types';
  */
 export declare class MaxHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>);
 }

package/dist/data-structures/heap/max-heap.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 var __extends = (this && this.__extends) || (function () {
@@ -28,6 +28,11 @@ var priority_queue_1 = require("../priority-queue");
  */
 var MaxHeap = /** @class */ (function (_super) {
     __extends(MaxHeap, _super);
+    /**
+     * The constructor initializes a PriorityQueue with a custom comparator function.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     function MaxHeap(options) {
         var _this = _super.call(this, options) || this;
         _this._pq = new priority_queue_1.PriorityQueue({

package/dist/data-structures/heap/min-heap.d.ts

@@ -1,5 +1,5 @@
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 import { Heap } from './heap';
@@ -11,5 +11,11 @@ import type { HeapItem, HeapOptions } from '../types';
  */
 export declare class MinHeap<T> extends Heap<T> {
     protected _pq: PriorityQueue<HeapItem<T>>;
+    /**
+     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
+     * objects.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     constructor(options?: HeapOptions<T>);
 }

package/dist/data-structures/heap/min-heap.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @copyright 2020 Tyler Zeng <zrwusa@gmail.com>
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
  * @license MIT
  */
 var __extends = (this && this.__extends) || (function () {
@@ -28,6 +28,12 @@ var priority_queue_1 = require("../priority-queue");
  */
 var MinHeap = /** @class */ (function (_super) {
     __extends(MinHeap, _super);
+    /**
+     * The constructor initializes a PriorityQueue with a comparator function that compares the priority of two HeapItem
+     * objects.
+     * @param [options] - The `options` parameter is an optional object that can be passed to the constructor. It is of
+     * type `HeapOptions<T>`, which is a generic type that represents the options for the heap.
+     */
     function MinHeap(options) {
         var _this = _super.call(this, options) || this;
         _this._pq = new priority_queue_1.PriorityQueue({

package/dist/data-structures/index.d.ts

@@ -8,4 +8,3 @@ export * from './heap';
 export * from './priority-queue';
 export * from './matrix';
 export * from './trie';
-export * from './types';

package/dist/data-structures/index.js

@@ -24,4 +24,3 @@ __exportStar(require("./heap"), exports);
 __exportStar(require("./priority-queue"), exports);
 __exportStar(require("./matrix"), exports);
 __exportStar(require("./trie"), exports);
-__exportStar(require("./types"), exports);

package/dist/data-structures/linked-list/doubly-linked-list.d.ts

@@ -11,13 +11,17 @@ export declare class DoublyLinkedList<T> {
     get size(): number;
     set size(v: number);
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
     offerFirst(val: T): boolean;
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
     offerLast(val: T): boolean;
     peekFirst(): T | null;
@@ -51,8 +55,12 @@ export declare class DoublyLinkedList<T> {
      */
     insert(index: number, val: T): boolean;
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
     remove(index: number): T | null;
 }

package/dist/data-structures/linked-list/doubly-linked-list.js

@@ -28,8 +28,10 @@ var DoublyLinkedList = /** @class */ (function () {
         configurable: true
     });
     /**
-     * Adds a node at the beginning of the linked list
-     * @param val Value to be stored at the beginning of the linked list
+     * The function adds a new node with a given value to the beginning of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the beginning of
+     * the doubly linked list.
+     * @returns A boolean value is being returned.
      */
     DoublyLinkedList.prototype.offerFirst = function (val) {
         var newNode = new DoublyLinkedListNode(val);
@@ -47,8 +49,10 @@ var DoublyLinkedList = /** @class */ (function () {
         return true;
     };
     /**
-     * Adds a node to the end of the linked list
-     * @param val Value to be stored in the Doubly linked list node
+     * The function adds a new node with a given value to the end of a doubly linked list.
+     * @param {T} val - The `val` parameter represents the value of the element that you want to add to the end of the
+     * doubly linked list.
+     * @returns a boolean value, which is always true.
      */
     DoublyLinkedList.prototype.offerLast = function (val) {
         var newNode = new DoublyLinkedListNode(val);
@@ -65,6 +69,14 @@ var DoublyLinkedList = /** @class */ (function () {
         this._size++;
         return true;
     };
+    /**
+     * The `peekFirst` function returns the first node or value in a doubly linked list, depending on the specified
+     * parameter.
+     * @param {DoublyLinkedListGetBy} [by] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy. It
+     * is used to specify whether to return the first node, the value of the first node, or the first node itself.
+     * @returns The method `peekFirst` returns either the first node of the doubly linked list (`DoublyLinkedListNode<T>`),
+     * the value of the first node (`T`), or `null` depending on the value of the `by` parameter.
+     */
     DoublyLinkedList.prototype.peekFirst = function (by) {
         var _a, _b, _c, _d, _e;
         switch (by) {
@@ -76,6 +88,13 @@ var DoublyLinkedList = /** @class */ (function () {
                 return (_e = (_d = this._first) === null || _d === void 0 ? void 0 : _d.val) !== null && _e !== void 0 ? _e : null;
         }
     };
+    /**
+     * The `peekLast` function returns the last node or value in a doubly linked list.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies whether to return the last node, the value of the last node, or both. The default value is 'val', which
+     * means that if no value is provided for the "by" parameter, the method
+     * @returns The method `peekLast` returns the last node, value, or null based on the specified `by` parameter.
+     */
     DoublyLinkedList.prototype.peekLast = function (by) {
         var _a, _b, _c, _d, _e;
         if (by === void 0) { by = 'val'; }
@@ -89,7 +108,14 @@ var DoublyLinkedList = /** @class */ (function () {
         }
     };
     /**
-     * Removes a node form the beginning of the linked list and will return the node val
+     * The function `pollFirst` removes and returns the first element of a doubly linked list, either as a node or its
+     * value, depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The "by" parameter is an optional parameter of type DoublyLinkedListGetBy.
+     * It specifies the criteria by which the first element should be retrieved from the doubly linked list. The default
+     * value is 'val', which means the first element will be retrieved by its value. Other possible values for "by
+     * @returns The method `pollFirst` returns either the value of the first node in the doubly linked list, the first node
+     * itself, or null if the list is empty. The specific return type depends on the value of the `by` parameter. If `by`
+     * is set to 'node', the method returns the first node. If `by` is set to 'val', the method returns the value
      */
     DoublyLinkedList.prototype.pollFirst = function (by) {
         var _a, _b, _c;
@@ -119,7 +145,14 @@ var DoublyLinkedList = /** @class */ (function () {
         }
     };
     /**
-     * Removes a node at the end of the linked list and will return the node value
+     * The function `pollLast` removes and returns the last element in a doubly linked list, either as a node or its value,
+     * depending on the specified parameter.
+     * @param {DoublyLinkedListGetBy} [by=val] - The parameter "by" is of type DoublyLinkedListGetBy, which is an enum that
+     * can have two possible values: 'node' or 'val'. It determines the type of value that will be returned by the pollLast
+     * method. If 'node' is specified, the method will return the
+     * @returns The method `pollLast` returns either a `DoublyLinkedListNode<T>`, the value of the node (`T`), or `null`.
+     * The specific type that is returned depends on the value of the `by` parameter. If `by` is set to `'node'`, then a
+     * `DoublyLinkedListNode<T>` is returned. If `by` is set to `'
      */
     DoublyLinkedList.prototype.pollLast = function (by) {
         var _a, _b, _c;
@@ -230,8 +263,12 @@ var DoublyLinkedList = /** @class */ (function () {
         return true;
     };
     /**
-     * Removes a node at the specified index and returns its value.
-     * @param index Index at which the node has to be removed.
+     * The `remove` function removes an element at a specified index from a data structure, updating the links between
+     * nodes accordingly.
+     * @param {number} index - The index parameter represents the position of the element to be removed in the data
+     * structure. It is of type number.
+     * @returns The `remove` method returns the value of the removed element (`T`) if the removal is successful, or `null`
+     * if the index is out of bounds.
      */
     DoublyLinkedList.prototype.remove = function (index) {
         var _a, _b, _c;

package/dist/data-structures/linked-list/singly-linked-list.d.ts

@@ -1,4 +1,7 @@
-import type { TMapFunction, TTestFunction } from '../types';
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 /**
  * The class which represents one link or node in a linked list
  * ```ts
@@ -114,7 +117,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f A function to be applied to the val of each node
      */
-    findNodeIndex(f: TTestFunction<NodeData>): ({
+    findNodeIndex(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): ({
         node: SinglyLinkedListNode<NodeData>;
         index: number;
     }) | undefined;
@@ -127,7 +130,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    findNode(f: TTestFunction<NodeData>): SinglyLinkedListNode<NodeData> | undefined;
+    findNode(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): SinglyLinkedListNode<NodeData> | undefined;
     /**
      * Returns the value of the first element in the list that
      * satisfies the provided testing function. Otherwise undefined is returned.
@@ -136,7 +139,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    find(f: TTestFunction<NodeData>): NodeData | undefined;
+    find(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): NodeData | undefined;
     /**
      * Returns the index of the first node in the list that
      * satisfies the provided testing function. Ohterwise -1 is returned.
@@ -145,7 +148,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * ```
      * @param f Function to test val against
      */
-    findIndex(f: TTestFunction<NodeData>): number;
+    findIndex(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean): number;
     /**
      * Append one or any number of nodes to the end of the list.
      * This modifies the list in place and returns the list itself
@@ -295,7 +298,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function to execute for each element, taking up to three arguments.
      * @param reverse Indicates if the list should be walked in reverse order, default is false
      */
-    forEach(f: TMapFunction<NodeData>, reverse?: boolean): void;
+    forEach(f: (data: any, index: number, list: SinglyLinkedList<NodeData>) => any, reverse?: boolean): void;
     /**
      * The map() method creates a new list with the results of
      * calling a provided function on every node in the calling list.
@@ -305,7 +308,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function that produces an node of the new list, taking up to three arguments
      * @param reverse Indicates if the list should be mapped in reverse order, default is false
      */
-    map(f: TMapFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    map(f: (data: any, index: number, list: SinglyLinkedList<NodeData>) => any, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
     /**
      * The filter() method creates a new list with all nodes
      * that pass the test implemented by the provided function.
@@ -315,7 +318,7 @@ export declare class SinglyLinkedList<NodeData = any> {
      * @param f Function to test each node val in the list. Return true to keep the node
      * @param reverse Indicates if the list should be filtered in reverse order, default is false
      */
-    filter(f: TTestFunction<NodeData>, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
+    filter(f: (data: NodeData, index: number, list: SinglyLinkedList<NodeData>) => boolean, reverse?: boolean): SinglyLinkedList<NodeData | {}>;
     /**
      * Reduce over each node in the list
      * ```ts

package/dist/data-structures/linked-list/singly-linked-list.js

@@ -1,4 +1,8 @@
 "use strict";
+/**
+ * @copyright 2030 Tyler Zeng <zrwusa@gmail.com>
+ * @license MIT
+ */
 var __generator = (this && this.__generator) || function (thisArg, body) {
     var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
     return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;