min-heap-typed 1.41.0 → 1.41.1

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

@@ -19,7 +19,8 @@ export class BSTNode<V = any, N extends BSTNode<V, N> = BSTNodeNested<V>> extend
 
 export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>>
   extends BinaryTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function initializes a binary search tree object with an optional comparator
    * function.
@@ -153,7 +154,9 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
       return super.addMany(keysOrNodes, data);
     }
     const inserted: (N | null | undefined)[] = [];
-    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map((value:(BTNKey | N), index) => [value, data?.[index]] as [BTNKey | N, V]);
+    const combinedArr: [BTNKey | N, V][] = keysOrNodes.map(
+      (value: BTNKey | N, index) => [value, data?.[index]] as [BTNKey | N, V]
+    );
     let sorted = [];
 
     function isNodeOrNullTuple(arr: [BTNKey | N, V][]): arr is [N, V][] {
@@ -231,7 +234,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
    * @returns either the first node that matches the given nodeProperty and callback, or null if no
    * matching node is found.
    */
-  override get<C extends BTNCallback<N>>(
+  override getNode<C extends BTNCallback<N>>(
     identifier: ReturnType<C> | null,
     callback: C = ((node: N) => node.key) as C,
     beginRoot = this.root,
@@ -362,7 +365,7 @@ export class BST<V = any, N extends BSTNode<V, N> = BSTNode<V, BSTNodeNested<V>>
     targetNode: BTNKey | N | null = this.root,
     iterationType = this.iterationType
   ): ReturnType<C>[] {
-    if (typeof targetNode === 'number') targetNode = this.get(targetNode);
+    if (typeof targetNode === 'number') targetNode = this.getNode(targetNode);
     const ans: ReturnType<BTNCallback<N>>[] = [];
     if (!targetNode) return ans;
     const targetKey = targetNode.key;

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

@@ -1,27 +1,26 @@
-import {RBTNColor} from "../../types";
+import {RBTNColor} from '../../types';
 
 export class RBTreeNode {
-  key: number = 0;
+  key: number;
   parent: RBTreeNode;
   left: RBTreeNode;
   right: RBTreeNode;
   color: number = RBTNColor.BLACK;
 
-  constructor() {
+  constructor(key: number, color: RBTNColor = RBTNColor.BLACK) {
+    this.key = key;
+    this.color = color;
     this.parent = null as unknown as RBTreeNode;
     this.left = null as unknown as RBTreeNode;
     this.right = null as unknown as RBTreeNode;
   }
 }
 
+export const SN = new RBTreeNode(0);
+
 export class RedBlackTree {
-  
   constructor() {
-    this._NIL = new RBTreeNode();
-    this.NIL.color = RBTNColor.BLACK;
-    this.NIL.left = null as unknown as RBTreeNode;
-    this.NIL.right = null as unknown as RBTreeNode;
-    this._root = this.NIL;
+    this._root = SN;
   }
 
   protected _root: RBTreeNode;
@@ -30,12 +29,6 @@ export class RedBlackTree {
     return this._root;
   }
 
-  protected _NIL: RBTreeNode;
-
-  get NIL(): RBTreeNode {
-    return this._NIL;
-  }
-
   /**
    * The `insert` function inserts a new node with a given key into a red-black tree and fixes any
    * violations of the red-black tree properties.
@@ -44,18 +37,14 @@ export class RedBlackTree {
    * @returns The function does not explicitly return anything.
    */
   insert(key: number): void {
-
-    const node: RBTreeNode = new RBTreeNode();
-    node.parent = null as unknown as RBTreeNode;
-    node.key = key;
-    node.left = this.NIL;
-    node.right = this.NIL;
-    node.color = RBTNColor.RED;
+    const node: RBTreeNode = new RBTreeNode(key, RBTNColor.RED);
+    node.left = SN;
+    node.right = SN;
 
     let y: RBTreeNode = null as unknown as RBTreeNode;
     let x: RBTreeNode = this.root;
 
-    while (x !== this.NIL) {
+    while (x !== SN) {
       y = x;
       if (node.key < x.key) {
         x = x.left;
@@ -94,10 +83,9 @@ export class RedBlackTree {
    */
   delete(key: number): void {
     const helper = (node: RBTreeNode): void => {
-
-      let z: RBTreeNode = this.NIL;
+      let z: RBTreeNode = SN;
       let x: RBTreeNode, y: RBTreeNode;
-      while (node !== this.NIL) {
+      while (node !== SN) {
         if (node.key === key) {
           z = node;
         }
@@ -109,17 +97,16 @@ export class RedBlackTree {
         }
       }
 
-      if (z === this.NIL) {
-        console.log("Couldn't find key in the tree");
+      if (z === SN) {
         return;
       }
 
       y = z;
       let yOriginalColor: number = y.color;
-      if (z.left === this.NIL) {
+      if (z.left === SN) {
         x = z.right;
         this._rbTransplant(z, z.right);
-      } else if (z.right === this.NIL) {
+      } else if (z.right === SN) {
         x = z.left;
         this._rbTransplant(z, z.left);
       } else {
@@ -139,13 +126,17 @@ export class RedBlackTree {
         y.left.parent = y;
         y.color = z.color;
       }
-      if (yOriginalColor === 0) {
+      if (yOriginalColor === RBTNColor.BLACK) {
         this._fixDelete(x);
       }
-    }
+    };
     helper(this.root);
   }
 
+  isRealNode(node: RBTreeNode): node is RBTreeNode {
+    return node !== SN && node !== null;
+  }
+
   /**
    * The function `getNode` is a recursive depth-first search algorithm that searches for a node with a
    * given key in a red-black tree.
@@ -158,40 +149,40 @@ export class RedBlackTree {
    */
   getNode(key: number, beginRoot = this.root): RBTreeNode {
     const dfs = (node: RBTreeNode): RBTreeNode => {
-      if (node === this.NIL || key === node.key) {
-        return node;
-      }
+      if (this.isRealNode(node)) {
+        if (key === node.key) {
+          return node;
+        }
 
-      if (key < node.key) {
-        return dfs(node.left);
+        if (key < node.key) return dfs(node.left);
+        return dfs(node.right);
+      } else {
+        return null as unknown as RBTreeNode;
       }
-      return dfs(node.right);
-    }
+    };
     return dfs(beginRoot);
   }
 
-
   /**
    * The function returns the leftmost node in a red-black tree.
    * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode, which represents a node in
    * a Red-Black Tree.
    * @returns The leftmost node in the given RBTreeNode.
    */
-  getLeftMost(node: RBTreeNode): RBTreeNode {
-    while (node.left !== null && node.left !== this.NIL) {
+  getLeftMost(node: RBTreeNode = this.root): RBTreeNode {
+    while (node.left !== null && node.left !== SN) {
       node = node.left;
     }
     return node;
   }
 
-
   /**
    * The function returns the rightmost node in a red-black tree.
    * @param {RBTreeNode} node - The parameter "node" is of type RBTreeNode.
    * @returns the rightmost node in a red-black tree.
    */
   getRightMost(node: RBTreeNode): RBTreeNode {
-    while (node.right !== null && node.right !== this.NIL) {
+    while (node.right !== null && node.right !== SN) {
       node = node.right;
     }
     return node;
@@ -203,13 +194,12 @@ export class RedBlackTree {
    * @returns the successor of the given RBTreeNode.
    */
   getSuccessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.right !== this.NIL) {
+    if (x.right !== SN) {
       return this.getLeftMost(x.right);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && y !== null && x === y.right) {
+    while (y !== SN && y !== null && x === y.right) {
       x = y;
       y = y.parent;
     }
@@ -223,13 +213,12 @@ export class RedBlackTree {
    * @returns the predecessor of the given RBTreeNode 'x'.
    */
   getPredecessor(x: RBTreeNode): RBTreeNode {
-
-    if (x.left !== this.NIL) {
+    if (x.left !== SN) {
       return this.getRightMost(x.left);
     }
 
     let y: RBTreeNode = x.parent;
-    while (y !== this.NIL && x === y.left) {
+    while (y !== SN && x === y.left) {
       x = y;
       y = y.parent;
     }
@@ -244,7 +233,7 @@ export class RedBlackTree {
   protected _leftRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.right;
     x.right = y.left;
-    if (y.left !== this.NIL) {
+    if (y.left !== SN) {
       y.left.parent = x;
     }
     y.parent = x.parent;
@@ -267,7 +256,7 @@ export class RedBlackTree {
   protected _rightRotate(x: RBTreeNode): void {
     const y: RBTreeNode = x.left;
     x.left = y.right;
-    if (y.right !== this.NIL) {
+    if (y.right !== SN) {
       y.right.parent = x;
     }
     y.parent = x.parent;
@@ -289,24 +278,21 @@ export class RedBlackTree {
    */
   protected _fixDelete(x: RBTreeNode): void {
     let s: RBTreeNode;
-    while (x !== this.root && x.color === 0) {
+    while (x !== this.root && x.color === RBTNColor.BLACK) {
       if (x === x.parent.left) {
         s = x.parent.right;
         if (s.color === 1) {
-
           s.color = RBTNColor.BLACK;
           x.parent.color = RBTNColor.RED;
           this._leftRotate(x.parent);
           s = x.parent.right;
         }
 
-        if (s.left.color === 0 && s.right.color === 0) {
-
+        if (s.left !== null && s.left.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
           x = x.parent;
         } else {
-          if (s.right.color === 0) {
-
+          if (s.right.color === RBTNColor.BLACK) {
             s.left.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._rightRotate(s);
@@ -322,20 +308,17 @@ export class RedBlackTree {
       } else {
         s = x.parent.left;
         if (s.color === 1) {
-
           s.color = RBTNColor.BLACK;
           x.parent.color = RBTNColor.RED;
           this._rightRotate(x.parent);
           s = x.parent.left;
         }
 
-        if (s.right.color === 0 && s.right.color === 0) {
-
+        if (s.right.color === RBTNColor.BLACK && s.right.color === RBTNColor.BLACK) {
           s.color = RBTNColor.RED;
           x = x.parent;
         } else {
-          if (s.left.color === 0) {
-
+          if (s.left.color === RBTNColor.BLACK) {
             s.right.color = RBTNColor.BLACK;
             s.color = RBTNColor.RED;
             this._leftRotate(s);
@@ -380,14 +363,12 @@ export class RedBlackTree {
       if (k.parent === k.parent.parent.right) {
         u = k.parent.parent.left;
         if (u.color === 1) {
-
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
           k.parent.parent.color = RBTNColor.RED;
           k = k.parent.parent;
         } else {
           if (k === k.parent.left) {
-
             k = k.parent;
             this._rightRotate(k);
           }
@@ -400,14 +381,12 @@ export class RedBlackTree {
         u = k.parent.parent.right;
 
         if (u.color === 1) {
-
           u.color = RBTNColor.BLACK;
           k.parent.color = RBTNColor.BLACK;
           k.parent.parent.color = RBTNColor.RED;
           k = k.parent.parent;
         } else {
           if (k === k.parent.right) {
-
             k = k.parent;
             this._leftRotate(k);
           }
@@ -423,4 +402,4 @@ export class RedBlackTree {
     }
     this.root.color = RBTNColor.BLACK;
   }
-}
+}

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

@@ -37,7 +37,8 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N> {
+  implements IBinaryTree<V, N>
+{
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -169,7 +170,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       } else if (parent.right === undefined) {
         parent.right = newNode;
         if (newNode !== null) {
-          this._size = (this.size + 1);
+          this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
         return parent.right;
@@ -282,7 +283,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     const bstDeletedResult: BinaryTreeDeletedResult<N>[] = [];
     if (!this.root) return bstDeletedResult;
 
-    const curr: N | null = this.get(identifier, callback);
+    const curr: N | null = this.getNode(identifier, callback);
     if (!curr) return bstDeletedResult;
 
     const parent: N | null = curr?.parent ? curr.parent : null;

package/src/data-structures/graph/abstract-graph.ts

@@ -26,7 +26,6 @@ export abstract class AbstractVertex<V = any> {
     this.key = key;
     this.value = value;
   }
-
 }
 
 export abstract class AbstractEdge<E = any> {
@@ -65,7 +64,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO> {
+> implements IGraph<V, E, VO, EO>
+{
   protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
@@ -513,14 +513,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-    distMap.forEach((d, v) => {
-      if (v !== srcVertex) {
-        if (d < minDist) {
-          minDist = d;
-          if (genPaths) minDest = v;
+      distMap.forEach((d, v) => {
+        if (v !== srcVertex) {
+          if (d < minDist) {
+            minDist = d;
+            if (genPaths) minDest = v;
+          }
         }
-      }
-    });
+      });
 
     genPaths && getPaths(minDest);
 
@@ -582,7 +582,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{key: number; value: VO}>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -811,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): { costs: number[][]; predecessor: (VO | null)[][] } {
+  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -996,5 +996,4 @@ export abstract class AbstractGraph<
   protected _getVertexKey(vertexOrKey: VO | VertexKey): VertexKey {
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
-
 }

package/src/data-structures/graph/directed-graph.ts

@@ -46,13 +46,14 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
 }
 
 export class DirectedGraph<
-  V = any,
-  E = any,
-  VO extends DirectedVertex<V> = DirectedVertex<V>,
-  EO extends DirectedEdge<E> = DirectedEdge<E>
->
+    V = any,
+    E = any,
+    VO extends DirectedVertex<V> = DirectedVertex<V>,
+    EO extends DirectedEdge<E> = DirectedEdge<E>
+  >
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO> {
+  implements IGraph<V, E, VO, EO>
+{
   /**
    * The constructor function initializes an instance of a class.
    */

package/src/data-structures/graph/undirected-graph.ts

@@ -43,13 +43,14 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
 }
 
 export class UndirectedGraph<
-  V = any,
-  E = any,
-  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-  EO extends UndirectedEdge<E> = UndirectedEdge<E>
->
+    V = any,
+    E = any,
+    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+    EO extends UndirectedEdge<E> = UndirectedEdge<E>
+  >
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO> {
+  implements IGraph<V, E, VO, EO>
+{
   /**
    * The constructor initializes a new Map object to store edges.
    */

package/src/data-structures/hash/hash-map.ts

@@ -133,7 +133,7 @@ export class HashMap<K, V> {
     }
   }
 
-  * entries(): IterableIterator<[K, V]> {
+  *entries(): IterableIterator<[K, V]> {
     for (const bucket of this.table) {
       if (bucket) {
         for (const [key, value] of bucket) {

package/src/data-structures/hash/tree-map.ts

@@ -1,2 +1 @@
-export class TreeMap {
-}
+export class TreeMap {}

package/src/data-structures/hash/tree-set.ts

@@ -1,2 +1 @@
-export class TreeSet {
-}
+export class TreeSet {}

package/src/data-structures/heap/heap.ts

@@ -8,7 +8,7 @@
 import type {Comparator, DFSOrderPattern} from '../../types';
 
 export class Heap<E = any> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     this._comparator = options.comparator;
     if (options.nodes && options.nodes.length > 0) {
       this._nodes = options.nodes;
@@ -48,7 +48,7 @@ export class Heap<E = any> {
    * @returns A new Heap instance.
    * @param options
    */
-  static heapify<E>(options: { nodes: E[]; comparator: Comparator<E> }): Heap<E> {
+  static heapify<E>(options: {nodes: E[]; comparator: Comparator<E>}): Heap<E> {
     return new Heap<E>(options);
   }
 

package/src/data-structures/heap/max-heap.ts

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MaxHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/heap/min-heap.ts

@@ -11,7 +11,7 @@ import type {Comparator} from '../../types';
 
 export class MinHeap<E = any> extends Heap<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/linked-list/doubly-linked-list.ts

@@ -594,7 +594,7 @@ export class DoublyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/linked-list/singly-linked-list.ts

@@ -565,7 +565,7 @@ export class SinglyLinkedList<E = any> {
   /**
    * The function returns an iterator that iterates over the values of a linked list.
    */
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     let current = this.head;
 
     while (current) {

package/src/data-structures/matrix/matrix.ts

@@ -14,7 +14,7 @@ export class MatrixNTI2D<V = any> {
    * given initial value or 0 if not provided.
    * @param options - An object containing the following properties:
    */
-  constructor(options: { row: number; col: number; initialVal?: V }) {
+  constructor(options: {row: number; col: number; initialVal?: V}) {
     const {row, col, initialVal} = options;
     this._matrix = new Array(row).fill(undefined).map(() => new Array(col).fill(initialVal || 0));
   }

package/src/data-structures/matrix/vector2d.ts

@@ -10,8 +10,7 @@ export class Vector2D {
     public x: number = 0,
     public y: number = 0,
     public w: number = 1 // needed for matrix multiplication
-  ) {
-  }
+  ) {}
 
   /**
    * The function checks if the x and y values of a point are both zero.

package/src/data-structures/priority-queue/max-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MaxPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

package/src/data-structures/priority-queue/min-priority-queue.ts

@@ -10,7 +10,7 @@ import type {Comparator} from '../../types';
 
 export class MinPriorityQueue<E = any> extends PriorityQueue<E> {
   constructor(
-    options: { comparator: Comparator<E>; nodes?: E[] } = {
+    options: {comparator: Comparator<E>; nodes?: E[]} = {
       comparator: (a: E, b: E) => {
         if (!(typeof a === 'number' && typeof b === 'number')) {
           throw new Error('The a, b params of compare function must be number');

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

@@ -10,7 +10,7 @@ import {Heap} from '../heap';
 import {Comparator} from '../../types';
 
 export class PriorityQueue<E = any> extends Heap<E> {
-  constructor(options: { comparator: Comparator<E>; nodes?: E[] }) {
+  constructor(options: {comparator: Comparator<E>; nodes?: E[]}) {
     super(options);
   }
 }

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

@@ -9,8 +9,7 @@ import {DoublyLinkedList} from '../linked-list';
 
 // O(n) time complexity of obtaining the value
 // O(1) time complexity of adding at the beginning and the end
-export class Deque<E = any> extends DoublyLinkedList<E> {
-}
+export class Deque<E = any> extends DoublyLinkedList<E> {}
 
 // O(1) time complexity of obtaining the value
 // O(n) time complexity of adding at the beginning and the end
@@ -20,9 +19,9 @@ export class ObjectDeque<E = number> {
     if (capacity !== undefined) this._capacity = capacity;
   }
 
-  protected _nodes: { [key: number]: E } = {};
+  protected _nodes: {[key: number]: E} = {};
 
-  get nodes(): { [p: number]: E } {
+  get nodes(): {[p: number]: E} {
     return this._nodes;
   }
 

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

@@ -201,7 +201,7 @@ export class Queue<E = any> {
     return new Queue(this.nodes.slice(this.offset));
   }
 
-  * [Symbol.iterator]() {
+  *[Symbol.iterator]() {
     for (const item of this.nodes) {
       yield item;
     }

package/src/types/data-structures/matrix/navigator.ts

@@ -1,6 +1,6 @@
 export type Direction = 'up' | 'right' | 'down' | 'left';
 
-export type Turning = { [key in Direction]: Direction };
+export type Turning = {[key in Direction]: Direction};
 
 export type NavigatorParams<T = any> = {
   matrix: T[][];

package/src/types/utils/utils.ts

@@ -1,5 +1,5 @@
 export type ToThunkFn = () => ReturnType<TrlFn>;
-export type Thunk = () => ReturnType<ToThunkFn> & { __THUNK__: symbol };
+export type Thunk = () => ReturnType<ToThunkFn> & {__THUNK__: symbol};
 export type TrlFn = (...args: any[]) => any;
 export type TrlAsyncFn = (...args: any[]) => any;