heap-typed 1.50.7 → 1.50.9

package/dist/types/common.js

@@ -1,42 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CRUD = exports.FamilyPosition = exports.IterationType = exports.CP = exports.BSTVariant = void 0;
-var BSTVariant;
-(function (BSTVariant) {
-    BSTVariant["STANDARD"] = "STANDARD";
-    BSTVariant["INVERSE"] = "INVERSE";
-})(BSTVariant = exports.BSTVariant || (exports.BSTVariant = {}));
-var CP;
-(function (CP) {
-    CP["lt"] = "lt";
-    CP["eq"] = "eq";
-    CP["gt"] = "gt";
-})(CP = exports.CP || (exports.CP = {}));
-/**
- * Enum representing different loop types.
- *
- * - `iterative`: Indicates the iterative loop type (with loops that use iterations).
- * - `recursive`: Indicates the recursive loop type (with loops that call themselves).
- */
-var IterationType;
-(function (IterationType) {
-    IterationType["ITERATIVE"] = "ITERATIVE";
-    IterationType["RECURSIVE"] = "RECURSIVE";
-})(IterationType = exports.IterationType || (exports.IterationType = {}));
-var FamilyPosition;
-(function (FamilyPosition) {
-    FamilyPosition["ROOT"] = "ROOT";
-    FamilyPosition["LEFT"] = "LEFT";
-    FamilyPosition["RIGHT"] = "RIGHT";
-    FamilyPosition["ROOT_LEFT"] = "ROOT_LEFT";
-    FamilyPosition["ROOT_RIGHT"] = "ROOT_RIGHT";
-    FamilyPosition["ISOLATED"] = "ISOLATED";
-    FamilyPosition["MAL_NODE"] = "MAL_NODE";
-})(FamilyPosition = exports.FamilyPosition || (exports.FamilyPosition = {}));
-var CRUD;
-(function (CRUD) {
-    CRUD["CREATED"] = "CREATED";
-    CRUD["READ"] = "READ";
-    CRUD["UPDATED"] = "UPDATED";
-    CRUD["DELETED"] = "DELETED";
-})(CRUD = exports.CRUD || (exports.CRUD = {}));

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

@@ -1,9 +1,6 @@
 import { RedBlackTree, RedBlackTreeNode } from '../../../data-structures';
 import type { BSTOptions } from "./bst";
-export declare enum RBTNColor {
-    RED = 1,
-    BLACK = 0
-}
+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, N extends RedBlackTreeNode<K, V, N>> = RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, RedBlackTree<K, V, N, any>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>;
 export type RBTreeOptions<K> = Omit<BSTOptions<K>, 'variant'> & {};

package/dist/types/data-structures/binary-tree/rb-tree.js

@@ -1,8 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RBTNColor = void 0;
-var RBTNColor;
-(function (RBTNColor) {
-    RBTNColor[RBTNColor["RED"] = 1] = "RED";
-    RBTNColor[RBTNColor["BLACK"] = 0] = "BLACK";
-})(RBTNColor = exports.RBTNColor || (exports.RBTNColor = {}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heap-typed",
-  "version": "1.50.7",
+  "version": "1.50.9",
   "description": "Heap. Javascript & Typescript Data Structure.",
   "main": "dist/index.js",
   "scripts": {
@@ -131,6 +131,6 @@
     "typescript": "^4.9.5"
   },
   "dependencies": {
-    "data-structure-typed": "^1.50.7"
+    "data-structure-typed": "^1.50.9"
   }
 }

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

@@ -12,9 +12,9 @@ import type {
   BinaryTreeDeleteResult,
   BSTNKeyOrNode,
   BTNCallback,
+  IterationType,
   KeyOrNodeOrEntry
 } from '../../types';
-import { FamilyPosition, IterationType } from '../../types';
 import { IBinaryTree } from '../../interfaces';
 import { AVLTree, AVLTreeNode } from './avl-tree';
 
@@ -86,7 +86,20 @@ export class AVLTreeMultiMap<
     return this._count;
   }
 
-  getMutableCount(): number {
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   */
+
+  /**
+   * Time Complexity: O(n)
+   * Space Complexity: O(1)
+   *
+   * The function calculates the sum of the count property of all nodes in a tree using depth-first
+   * search.
+   * @returns the sum of the count property of all nodes in the tree.
+   */
+  getComputedCount(): number {
     let sum = 0;
     this.dfs(node => (sum += node.count));
     return sum;
@@ -249,9 +262,9 @@ export class AVLTreeMultiMap<
           if (curr.right !== undefined) this._setRoot(curr.right);
         } else {
           const { familyPosition: fp } = curr;
-          if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+          if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
             parent.left = curr.right;
-          } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+          } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
             parent.right = curr.right;
           }
           needBalanced = parent;
@@ -317,14 +330,14 @@ export class AVLTreeMultiMap<
    * values:
    * @returns a boolean value.
    */
-  override perfectlyBalance(iterationType = this.iterationType): boolean {
-    const sorted = this.dfs(node => node, 'in'),
+  override perfectlyBalance(iterationType: IterationType = this.iterationType): boolean {
+    const sorted = this.dfs(node => node, 'IN'),
       n = sorted.length;
     if (sorted.length < 1) return false;
 
     this.clear();
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const buildBalanceBST = (l: number, r: number) => {
         if (l > r) return;
         const m = l + Math.floor((r - l) / 2);

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

@@ -107,16 +107,16 @@ export class BinaryTreeNode<
   get familyPosition(): FamilyPosition {
     const that = this as unknown as NODE;
     if (!this.parent) {
-      return this.left || this.right ? FamilyPosition.ROOT : FamilyPosition.ISOLATED;
+      return this.left || this.right ? 'ROOT' : 'ISOLATED';
     }
 
     if (this.parent.left === that) {
-      return this.left || this.right ? FamilyPosition.ROOT_LEFT : FamilyPosition.LEFT;
+      return this.left || this.right ? 'ROOT_LEFT' : 'LEFT';
     } else if (this.parent.right === that) {
-      return this.left || this.right ? FamilyPosition.ROOT_RIGHT : FamilyPosition.RIGHT;
+      return this.left || this.right ? 'ROOT_RIGHT' : 'RIGHT';
     }
 
-    return FamilyPosition.MAL_NODE;
+    return 'MAL_NODE';
   }
 }
 
@@ -136,7 +136,7 @@ export class BinaryTree<
 >
   extends IterableEntryBase<K, V | undefined>
   implements IBinaryTree<K, V, NODE, TREE> {
-  iterationType = IterationType.ITERATIVE;
+  iterationType: IterationType = 'ITERATIVE';
 
   /**
    * The constructor function initializes a binary tree object with optional keysOrNodesOrEntries and options.
@@ -160,7 +160,7 @@ export class BinaryTree<
     if (keysOrNodesOrEntries) this.addMany(keysOrNodesOrEntries);
   }
 
-  protected _extractor = (key: K) => Number(key);
+  protected _extractor = (key: K) => (typeof key === 'number' ? key : Number(key));
 
   /**
    * The function returns the value of the `_extractor` property.
@@ -260,13 +260,13 @@ export class BinaryTree<
    * `null`, or `undefined`. It represents a key used to identify a node in a binary tree.
    * @param iterationType - The `iterationType` parameter is an optional parameter that specifies the
    * type of iteration to be used when searching for a node by key. It has a default value of
-   * `IterationType.ITERATIVE`.
+   * `'ITERATIVE'`.
    * @returns either the node corresponding to the given key if it is a valid node key, or the key
    * itself if it is not a valid node key.
    */
   ensureNode(
     keyOrNodeOrEntry: KeyOrNodeOrEntry<K, V, NODE>,
-    iterationType = IterationType.ITERATIVE
+    iterationType: IterationType = 'ITERATIVE'
   ): NODE | null | undefined {
     let res: NODE | null | undefined;
     if (this.isRealNode(keyOrNodeOrEntry)) {
@@ -521,9 +521,9 @@ export class BinaryTree<
       }
     } else if (parent) {
       const { familyPosition: fp } = curr;
-      if (fp === FamilyPosition.LEFT || fp === FamilyPosition.ROOT_LEFT) {
+      if (fp === 'LEFT' || fp === 'ROOT_LEFT') {
         parent.left = curr.right;
-      } else if (fp === FamilyPosition.RIGHT || fp === FamilyPosition.ROOT_RIGHT) {
+      } else if (fp === 'RIGHT' || fp === 'ROOT_RIGHT') {
         parent.right = curr.right;
       }
       needBalanced = parent;
@@ -597,7 +597,7 @@ export class BinaryTree<
     callback: C = this._defaultOneParamCallback as C,
     onlyOne = false,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE[] {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -606,7 +606,7 @@ export class BinaryTree<
 
     const ans: NODE[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE) => {
         if (callback(cur) === identifier) {
           ans.push(cur);
@@ -687,7 +687,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -714,9 +714,9 @@ export class BinaryTree<
    * @returns The function `getNodeByKey` returns a node (`NODE`) if a node with the specified key is
    * found in the binary tree. If no node is found, it returns `undefined`.
    */
-  getNodeByKey(key: K, iterationType = IterationType.ITERATIVE): NODE | undefined {
+  getNodeByKey(key: K, iterationType: IterationType = 'ITERATIVE'): NODE | undefined {
     if (!this.root) return undefined;
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _dfs = (cur: NODE): NODE | undefined => {
         if (cur.key === key) return cur;
 
@@ -791,7 +791,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): V | undefined {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -850,7 +850,7 @@ export class BinaryTree<
     identifier: ReturnType<C> | null | undefined,
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): boolean {
     if ((!callback || callback === this._defaultOneParamCallback) && (identifier as any) instanceof BinaryTreeNode)
       callback = (node => node) as C;
@@ -927,12 +927,15 @@ export class BinaryTree<
    * possible values:
    * @returns a boolean value.
    */
-  isBST(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): boolean {
+  isBST(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): boolean {
     // TODO there is a bug
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return true;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const dfs = (cur: NODE | null | undefined, min: number, max: number): boolean => {
         if (!this.isRealNode(cur)) return true;
         const numKey = this.extractor(cur.key);
@@ -1019,11 +1022,14 @@ export class BinaryTree<
    * values:
    * @returns the height of the binary tree.
    */
-  getHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!this.isRealNode(beginRoot)) return -1;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _getMaxHeight = (cur: NODE | null | undefined): number => {
         if (!this.isRealNode(cur)) return -1;
         const leftHeight = _getMaxHeight(cur.left);
@@ -1067,11 +1073,14 @@ export class BinaryTree<
    * to calculate the minimum height of a binary tree. It can have two possible values:
    * @returns The function `getMinHeight` returns the minimum height of a binary tree.
    */
-  getMinHeight(beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root, iterationType = this.iterationType): number {
+  getMinHeight(
+    beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
+    iterationType: IterationType = this.iterationType
+  ): number {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return -1;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _getMinHeight = (cur: NODE | null | undefined): number => {
         if (!this.isRealNode(cur)) return 0;
         if (!this.isRealNode(cur.left) && !this.isRealNode(cur.right)) return 0;
@@ -1167,14 +1176,14 @@ export class BinaryTree<
    */
   getLeftMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     beginRoot = this.ensureNode(beginRoot);
 
     if (!this.isRealNode(beginRoot)) return beginRoot;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.left)) return cur;
         return _traverse(cur.left);
@@ -1214,14 +1223,14 @@ export class BinaryTree<
    */
   getRightMost(
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType
+    iterationType: IterationType = this.iterationType
   ): NODE | null | undefined {
     if (this.isNIL(beginRoot)) return beginRoot as NODE;
     // TODO support get right most by passing key in
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return beginRoot;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (cur: NODE): NODE => {
         if (!this.isRealNode(cur.right)) return cur;
         return _traverse(cur.right);
@@ -1343,18 +1352,18 @@ export class BinaryTree<
    */
   dfs<C extends BTNCallback<NODE | null | undefined>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType: IterationType = IterationType.ITERATIVE,
+    iterationType: IterationType = 'ITERATIVE',
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
     if (!beginRoot) return [];
     const ans: ReturnType<C>[] = [];
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _traverse = (node: NODE | null | undefined) => {
         switch (pattern) {
-          case 'in':
+          case 'IN':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               this.isNodeOrNull(node) && ans.push(callback(node));
@@ -1365,7 +1374,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'pre':
+          case 'PRE':
             if (includeNull) {
               this.isNodeOrNull(node) && ans.push(callback(node));
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
@@ -1376,7 +1385,7 @@ export class BinaryTree<
               if (this.isRealNode(node) && this.isRealNode(node.right)) _traverse(node.right);
             }
             break;
-          case 'post':
+          case 'POST':
             if (includeNull) {
               if (this.isRealNode(node) && this.isNodeOrNull(node.left)) _traverse(node.left);
               if (this.isRealNode(node) && this.isNodeOrNull(node.right)) _traverse(node.right);
@@ -1408,17 +1417,17 @@ export class BinaryTree<
           ans.push(callback(cur.node));
         } else {
           switch (pattern) {
-            case 'in':
+            case 'IN':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               break;
-            case 'pre':
+            case 'PRE':
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
               stack.push({ opt: 1, node: cur.node });
               break;
-            case 'post':
+            case 'POST':
               stack.push({ opt: 1, node: cur.node });
               cur.node && stack.push({ opt: 0, node: cur.node.right });
               cur.node && stack.push({ opt: 0, node: cur.node.left });
@@ -1479,7 +1488,7 @@ export class BinaryTree<
   bfs<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1487,7 +1496,7 @@ export class BinaryTree<
 
     const ans: ReturnType<BTNCallback<NODE>>[] = [];
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const queue: Queue<NODE | null | undefined> = new Queue<NODE | null | undefined>([beginRoot]);
 
       const traverse = (level: number) => {
@@ -1573,14 +1582,14 @@ export class BinaryTree<
   listLevels<C extends BTNCallback<NODE | null>>(
     callback: C = this._defaultOneParamCallback as C,
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root,
-    iterationType = this.iterationType,
+    iterationType: IterationType = this.iterationType,
     includeNull = false
   ): ReturnType<C>[][] {
     beginRoot = this.ensureNode(beginRoot);
     const levelsNodes: ReturnType<C>[][] = [];
     if (!beginRoot) return levelsNodes;
 
-    if (iterationType === IterationType.RECURSIVE) {
+    if (iterationType === 'RECURSIVE') {
       const _recursive = (node: NODE | null, level: number) => {
         if (!levelsNodes[level]) levelsNodes[level] = [];
         levelsNodes[level].push(callback(node));
@@ -1643,7 +1652,7 @@ export class BinaryTree<
    */
   morris<C extends BTNCallback<NODE>>(
     callback: C = this._defaultOneParamCallback as C,
-    pattern: DFSOrderPattern = 'in',
+    pattern: DFSOrderPattern = 'IN',
     beginRoot: KeyOrNodeOrEntry<K, V, NODE> = this.root
   ): ReturnType<C>[] {
     beginRoot = this.ensureNode(beginRoot);
@@ -1672,7 +1681,7 @@ export class BinaryTree<
       _reverseEdge(tail);
     };
     switch (pattern) {
-      case 'in':
+      case 'IN':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1688,7 +1697,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'pre':
+      case 'PRE':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1706,7 +1715,7 @@ export class BinaryTree<
           cur = cur.right;
         }
         break;
-      case 'post':
+      case 'POST':
         while (cur) {
           if (cur.left) {
             const predecessor = this.getPredecessor(cur);
@@ -1876,7 +1885,7 @@ export class BinaryTree<
   protected* _getIterator(node = this.root): IterableIterator<[K, V | undefined]> {
     if (!node) return;
 
-    if (this.iterationType === IterationType.ITERATIVE) {
+    if (this.iterationType === 'ITERATIVE') {
       const stack: (NODE | null | undefined)[] = [];
       let current: NODE | null | undefined = node;