graph-typed 1.53.5 → 1.53.7

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

@@ -74,13 +74,100 @@ exports.TrieNode = TrieNode;
  * 9. Spell Check: Checking the spelling of words.
  * 10. IP Routing: Used in certain types of IP routing algorithms.
  * 11. Text Word Frequency Count: Counting and storing the frequency of words in a large amount of text data.
+ * @example
+ * // Autocomplete: Prefix validation and checking
+ *     const autocomplete = new Trie<string>(['gmail.com', 'gmail.co.nz', 'gmail.co.jp', 'yahoo.com', 'outlook.com']);
+ *
+ *     // Get all completions for a prefix
+ *     const gmailCompletions = autocomplete.getWords('gmail');
+ *     console.log(gmailCompletions); // ['gmail.com', 'gmail.co.nz', 'gmail.co.jp']
+ * @example
+ * // File System Path Operations
+ *     const fileSystem = new Trie<string>([
+ *       '/home/user/documents/file1.txt',
+ *       '/home/user/documents/file2.txt',
+ *       '/home/user/pictures/photo.jpg',
+ *       '/home/user/pictures/vacation/',
+ *       '/home/user/downloads'
+ *     ]);
+ *
+ *     // Find common directory prefix
+ *     console.log(fileSystem.getLongestCommonPrefix()); // '/home/user/'
+ *
+ *     // List all files in a directory
+ *     const documentsFiles = fileSystem.getWords('/home/user/documents/');
+ *     console.log(documentsFiles); // ['/home/user/documents/file1.txt', '/home/user/documents/file2.txt']
+ * @example
+ * // Autocomplete: Basic word suggestions
+ *     // Create a trie for autocomplete
+ *     const autocomplete = new Trie<string>([
+ *       'function',
+ *       'functional',
+ *       'functions',
+ *       'class',
+ *       'classes',
+ *       'classical',
+ *       'closure',
+ *       'const',
+ *       'constructor'
+ *     ]);
+ *
+ *     // Test autocomplete with different prefixes
+ *     console.log(autocomplete.getWords('fun')); // ['functional', 'functions', 'function']
+ *     console.log(autocomplete.getWords('cla')); // ['classes', 'classical', 'class']
+ *     console.log(autocomplete.getWords('con')); // ['constructor', 'const']
+ *
+ *     // Test with non-matching prefix
+ *     console.log(autocomplete.getWords('xyz')); // []
+ * @example
+ * // Dictionary: Case-insensitive word lookup
+ *     // Create a case-insensitive dictionary
+ *     const dictionary = new Trie<string>([], { caseSensitive: false });
+ *
+ *     // Add words with mixed casing
+ *     dictionary.add('Hello');
+ *     dictionary.add('WORLD');
+ *     dictionary.add('JavaScript');
+ *
+ *     // Test lookups with different casings
+ *     console.log(dictionary.has('hello')); // true
+ *     console.log(dictionary.has('HELLO')); // true
+ *     console.log(dictionary.has('Hello')); // true
+ *     console.log(dictionary.has('javascript')); // true
+ *     console.log(dictionary.has('JAVASCRIPT')); // true
+ * @example
+ * // IP Address Routing Table
+ *     // Add IP address prefixes and their corresponding routes
+ *     const routes = {
+ *       '192.168.1': 'LAN_SUBNET_1',
+ *       '192.168.2': 'LAN_SUBNET_2',
+ *       '10.0.0': 'PRIVATE_NETWORK_1',
+ *       '10.0.1': 'PRIVATE_NETWORK_2'
+ *     };
+ *
+ *     const ipRoutingTable = new Trie<string>(Object.keys(routes));
+ *
+ *     // Check IP address prefix matching
+ *     console.log(ipRoutingTable.hasPrefix('192.168.1')); // true
+ *     console.log(ipRoutingTable.hasPrefix('192.168.2')); // true
+ *
+ *     // Validate IP address belongs to subnet
+ *     const ip = '192.168.1.100';
+ *     const subnet = ip.split('.').slice(0, 3).join('.');
+ *     console.log(ipRoutingTable.hasPrefix(subnet)); // true
  */
 class Trie extends base_1.IterableElementBase {
     /**
-     * The constructor function for the Trie class.
-     * @param words: Iterable string Initialize the trie with a set of words
-     * @param options?: TrieOptions Allow the user to pass in options for the trie
-     * @return This
+     * The constructor initializes a Trie data structure with optional options and words provided as
+     * input.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the constructor is an
+     * iterable containing either strings or elements of type `R`. It is used to initialize the Trie with
+     * a list of words or elements. If no `words` are provided, an empty iterable is used as the default
+     * value.
+     * @param [options] - The `options` parameter in the constructor is an optional object that can
+     * contain configuration options for the Trie data structure. One of the options it can have is
+     * `caseSensitive`, which is a boolean value indicating whether the Trie should be case-sensitive or
+     * not. If `caseSensitive` is set to `
      */
     constructor(words = [], options) {
         super(options);
@@ -93,14 +180,7 @@ class Trie extends base_1.IterableElementBase {
                 this._caseSensitive = caseSensitive;
         }
         if (words) {
-            for (const word of words) {
-                if (this.toElementFn) {
-                    this.add(this.toElementFn(word));
-                }
-                else {
-                    this.add(word);
-                }
-            }
+            this.addMany(words);
         }
     }
     /**
@@ -151,6 +231,30 @@ class Trie extends base_1.IterableElementBase {
         }
         return isNewWord;
     }
+    /**
+     * Time Complexity: O(n * l)
+     * Space Complexity: O(1)
+     *
+     * The `addMany` function in TypeScript takes an iterable of strings or elements of type R, converts
+     * them using a provided function if available, and adds them to a data structure while returning an
+     * array of boolean values indicating success.
+     * @param {Iterable<string> | Iterable<R>} words - The `words` parameter in the `addMany` function is
+     * an iterable that contains either strings or elements of type `R`.
+     * @returns The `addMany` method returns an array of boolean values indicating whether each word in
+     * the input iterable was successfully added to the data structure.
+     */
+    addMany(words = []) {
+        const ans = [];
+        for (const word of words) {
+            if (this.toElementFn) {
+                ans.push(this.add(this.toElementFn(word)));
+            }
+            else {
+                ans.push(this.add(word));
+            }
+        }
+        return ans;
+    }
     /**
      * Time Complexity: O(l), where l is the length of the input word.
      * Space Complexity: O(1) - Constant space.

package/dist/index.d.ts

@@ -8,4 +8,5 @@
 export * from './data-structures/graph';
 export * from './types/data-structures/graph';
 export * from './types/common';
-export * from './constants';
+export * from './types/utils';
+export * from './common';

package/dist/index.js

@@ -38,4 +38,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./data-structures/graph"), exports);
 __exportStar(require("./types/data-structures/graph"), exports);
 __exportStar(require("./types/common"), exports);
-__exportStar(require("./constants"), exports);
+__exportStar(require("./types/utils"), exports);
+__exportStar(require("./common"), exports);

package/dist/types/data-structures/binary-tree/binary-tree.d.ts

@@ -1,6 +1,6 @@
 import { BinaryTree, BinaryTreeNode } from '../../../data-structures';
 import { IterationType, OptValue } from '../../common';
-import { DFSOperation } from '../../../constants';
+import { DFSOperation } from '../../../common';
 export type BinaryTreeNodeNested<K, V> = BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, BinaryTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BinaryTreeNested<K, V, R, NODE extends BinaryTreeNode<K, V, NODE>> = BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, BinaryTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type ToEntryFn<K, V, R> = (rawElement: R) => BTNEntry<K, V>;

package/dist/types/data-structures/binary-tree/bst.d.ts

@@ -1,10 +1,11 @@
 import { BST, BSTNode } from '../../../data-structures';
 import type { BinaryTreeOptions } from './binary-tree';
-import { Comparator } from '../../common';
+import { Comparable } from '../../utils';
 export type BSTNodeNested<K, V> = BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, BSTNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTNested<K, V, R, NODE extends BSTNode<K, V, NODE>> = BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, BST<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type BSTOptions<K, V, R> = BinaryTreeOptions<K, V, R> & {
-    comparator?: Comparator<K>;
+    extractComparable?: (key: K) => Comparable;
+    isReverse?: boolean;
 };
 export type BSTNOptKey<K> = K | undefined;
 export type OptNode<NODE> = NODE | undefined;

package/dist/types/data-structures/binary-tree/rb-tree.d.ts

@@ -3,4 +3,4 @@ import type { BSTOptions } from "./bst";
 export type RBTNColor = 'RED' | 'BLACK';
 export type RedBlackTreeNodeNested<K, V> = RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, RedBlackTreeNode<K, V, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RedBlackTreeNested<K, V, R, NODE extends RedBlackTreeNode<K, V, NODE>> = RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, RedBlackTree<K, V, R, NODE, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
-export type RBTreeOptions<K, V, R> = BSTOptions<K, V, R> & {};
+export type RBTreeOptions<K, V, R> = Omit<BSTOptions<K, V, R>, 'isReverse'> & {};

package/dist/types/utils/utils.d.ts

@@ -6,13 +6,17 @@ export type TrlFn<A extends any[] = any[], R = any> = (...args: A) => R;
 export type TrlAsyncFn = (...args: any[]) => any;
 export type SpecifyOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export type Any = string | number | bigint | boolean | symbol | undefined | object;
+export type Arithmetic = number | bigint;
 export type ComparablePrimitive = number | bigint | string | boolean;
-export type ComparableObject = {
-    [key in string]: any;
-} & ({
-    valueOf: () => ComparablePrimitive | ComparableObject;
+export interface BaseComparableObject {
+    [key: string]: unknown;
+}
+export interface ValueComparableObject extends BaseComparableObject {
+    valueOf: () => ComparablePrimitive | ValueComparableObject;
     toString?: () => string;
-} | {
+}
+export interface StringComparableObject extends BaseComparableObject {
     toString: () => string;
-});
+}
+export type ComparableObject = ValueComparableObject | StringComparableObject;
 export type Comparable = ComparablePrimitive | Date | ComparableObject;

package/dist/utils/utils.js

@@ -213,7 +213,8 @@ exports.roundFixed = roundFixed;
 function isPrimitiveComparable(value) {
     const valueType = typeof value;
     if (valueType === 'number')
-        return !Number.isNaN(value);
+        return true;
+    // if (valueType === 'number') return !Number.isNaN(value);
     return valueType === 'bigint' || valueType === 'string' || valueType === 'boolean';
 }
 /**
@@ -265,7 +266,8 @@ function isComparable(value, isForceObjectComparable = false) {
     if (typeof value !== 'object')
         return false;
     if (value instanceof Date)
-        return !Number.isNaN(value.getTime());
+        return true;
+    // if (value instanceof Date) return !Number.isNaN(value.getTime());
     if (isForceObjectComparable)
         return true;
     const comparableValue = tryObjectToPrimitive(value);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-typed",
-  "version": "1.53.5",
+  "version": "1.53.7",
   "description": "Graph. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -136,6 +136,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.53.5"
+    "data-structure-typed": "^1.53.7"
   }
 }

package/src/common/index.ts

@@ -0,0 +1,19 @@
+export enum DFSOperation {
+  VISIT = 0,
+  PROCESS = 1
+}
+export class Range<K> {
+  constructor(
+    public low: K,
+    public high: K,
+    public includeLow: boolean = true,
+    public includeHigh: boolean = true
+  ) {}
+
+  // Determine whether a key is within the range
+  isInRange(key: K, comparator: (a: K, b: K) => number): boolean {
+    const lowCheck = this.includeLow ? comparator(key, this.low) >= 0 : comparator(key, this.low) > 0;
+    const highCheck = this.includeHigh ? comparator(key, this.high) <= 0 : comparator(key, this.high) < 0;
+    return lowCheck && highCheck;
+  }
+}

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

@@ -143,8 +143,9 @@ export class AVLTreeMultiMap<
     return new AVLTreeMultiMap<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
+      isReverse: this._isReverse,
       ...options
     }) as TREE;
   }
@@ -187,17 +188,14 @@ export class AVLTreeMultiMap<
       return [this.createNode(key, finalValue, count), finalValue];
     }
 
-    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
-
     if (this.isRaw(keyNodeEntryOrRaw)) {
-      if (this._toEntryFn) {
-        const [key, entryValue] = this._toEntryFn(keyNodeEntryOrRaw as R);
-        const finalValue = value ?? entryValue;
-        if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
-      }
-      return [undefined, undefined];
+      const [key, entryValue] = this._toEntryFn!(keyNodeEntryOrRaw);
+      const finalValue = value ?? entryValue;
+      if (this.isKey(key)) return [this.createNode(key, finalValue, count), finalValue];
     }
 
+    if (this.isKey(keyNodeEntryOrRaw)) return [this.createNode(keyNodeEntryOrRaw, value, count), value];
+
     return [undefined, undefined];
   }
 

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

@@ -113,8 +113,9 @@ export class AVLTree<
     return new AVLTree<K, V, R, NODE, TREE>([], {
       iterationType: this.iterationType,
       isMapMode: this._isMapMode,
-      comparator: this._comparator,
+      extractComparable: this._extractComparable,
       toEntryFn: this._toEntryFn,
+      isReverse: this._isReverse,
       ...options
     }) as TREE;
   }
@@ -434,7 +435,7 @@ export class AVLTree<
    */
   protected _balancePath(node: BTNRep<K, V, NODE> | R): void {
     node = this.ensureNode(node);
-    const path = this.getPathToRoot(node => node, node, false); // first O(log n) + O(log n)
+    const path = this.getPathToRoot(node, node => node, false); // first O(log n) + O(log n)
     for (let i = 0; i < path.length; i++) {
       // second O(log n)
       const A = path[i];