data-structure-typed 0.8.17 → 0.9.16

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "data-structure-typed",
-  "version": "0.8.17",
+  "version": "0.9.16",
   "description": "Hash (CoordinateSet, CoordinateMap) Heap (MaxHeap, MinHeap) Binary Tree (AVL Tree, Binary Indexed Tree, Binary Search Tree, Segment Tree, Tree Multiset) Graph (Directed Graph, Undirected Graph) Linked List (Singly Linked List, Doubly Linked List) Matrix Priority Queue (Max Priority Queue, Min Priority Queue) Queue (Queue, Dequeue) Stack Trie",
   "main": "dist/index.js",
   "scripts": {
+    "build": "rm -rf dist && npx tsc",
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "repository": {
@@ -11,51 +12,27 @@
     "url": "git+https://github.com/zrwusa/data-structure-typed.git"
   },
   "keywords": [
+    "Binary Tree",
+    "AVL Tree",
+    "Binary Search Tree (BST)",
+    "Tree Multiset",
+    "Segment Tree",
+    "Binary Indexed Tree",
+    "Graph",
+    "Directed Graph",
+    "Undirected Graph",
+    "Singly Linked List",
     "Hash",
     "CoordinateSet",
     "CoordinateMap",
     "Heap",
-    "MaxHeap",
-    "MinHeap",
-    "Binary",
-    "Tree",
-    "AVL",
-    "Tree",
-    "Binary",
-    "Indexed",
-    "Tree",
-    "Binary",
-    "Search",
-    "Tree",
-    "Segment",
-    "Tree",
-    "Tree",
-    "Multiset",
-    "Graph",
-    "Directed",
-    "Graph",
-    "Undirected",
-    "Graph",
-    "Linked",
-    "List",
-    "Singly",
-    "Linked",
-    "List",
-    "Doubly",
-    "Linked",
-    "List",
-    "Matrix",
-    "Priority",
-    "Queue",
-    "Max",
-    "Priority",
-    "Queue",
-    "Min",
-    "Priority",
-    "Queue",
-    "Queue",
+    "Doubly Linked List",
+    "Priority Queue",
+    "Max Priority Queue",
+    "Min Priority Queue",
     "Queue",
-    "Dequeue",
+    "ObjectDeque",
+    "ArrayDeque",
     "Stack",
     "Trie"
   ],
@@ -67,7 +44,8 @@
   "homepage": "https://github.com/zrwusa/data-structure-typed#readme",
   "types": "dist/index.d.ts",
   "devDependencies": {
-    "@types/lodash": "^4.14.178",
+    "@types/lodash": "^4.14.197",
+    "@types/node": "^20.4.9",
     "typescript": "^4.6.2"
   },
   "dependencies": {

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

@@ -1,10 +1,5 @@
 import {BST, BSTNode} from './bst';
-import {BinaryTreeNodeId} from './binary-tree';
-
-export interface AVLTreeDeleted<T> {
-    deleted: AVLTreeNode<T> | null;
-    needBalanced: AVLTreeNode<T> | null;
-}
+import type {AVLTreeDeleted, BinaryTreeNodeId} from '../types';
 
 export class AVLTreeNode<T> extends BSTNode<T> {
     override clone(): AVLTreeNode<T> {

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

@@ -5,6 +5,10 @@ export class BinaryIndexedTree {
         this._sumTree = new Array<number>(n + 1).fill(0);
     }
 
+    static lowBit(x: number) {
+        return x & (-x);
+    }
+
     update(i: number, delta: number) {
         while (i < this._sumTree.length) {
             this._sumTree[i] += delta;
@@ -26,8 +30,4 @@ export class BinaryIndexedTree {
             throw 'Index out of bounds';
         return this.getPrefixSum(end) - this.getPrefixSum(start);
     }
-
-    static lowBit(x: number) {
-        return x & (-x);
-    }
 }

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

@@ -1,25 +1,25 @@
-import {ThunkOrValue, trampoline} from '../trampoline';
-
-export type BinaryTreeNodePropertyName = 'id' | 'val' | 'count';
-export type NodeOrPropertyName = 'node' | BinaryTreeNodePropertyName;
-export type DFSOrderPattern = 'in' | 'pre' | 'post';
-export type BinaryTreeNodeId = number;
-export type BinaryTreeDeleted<T> = { deleted: BinaryTreeNode<T> | null | undefined, needBalanced: BinaryTreeNode<T> | null };
-export type ResultByProperty<T> = T | BinaryTreeNode<T> | number | BinaryTreeNodeId;
-export type ResultsByProperty<T> = ResultByProperty<T>[];
-
-export interface BinaryTreeNodeObj<T> {
-    id: BinaryTreeNodeId;
-    val: T;
-    count?: number;
-}
+import {trampoline} from '../trampoline';
+import type {
+    BinaryTreeDeleted,
+    BinaryTreeNodeId,
+    BinaryTreeNodePropertyName, DFSOrderPattern,
+    NodeOrPropertyName, ResultByProperty,
+    ResultsByProperty
+} from '../types';
 
 export enum FamilyPosition {root, left, right}
 
 export enum LoopType { iterative = 1, recursive = 2}
 
 export class BinaryTreeNode<T> {
+    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
+        this._id = id;
+        this._val = val;
+        this._count = count ?? 1;
+    }
+
     protected _id: BinaryTreeNodeId;
+
     get id(): BinaryTreeNodeId {
         return this._id;
     }
@@ -29,6 +29,7 @@ export class BinaryTreeNode<T> {
     }
 
     protected _val: T;
+
     get val(): T {
         return this._val;
     }
@@ -38,6 +39,7 @@ export class BinaryTreeNode<T> {
     }
 
     protected _left?: BinaryTreeNode<T> | null;
+
     get left(): BinaryTreeNode<T> | null | undefined {
         return this._left;
     }
@@ -51,6 +53,7 @@ export class BinaryTreeNode<T> {
     }
 
     protected _right?: BinaryTreeNode<T> | null;
+
     get right(): BinaryTreeNode<T> | null | undefined {
         return this._right;
     }
@@ -63,7 +66,8 @@ export class BinaryTreeNode<T> {
         this._right = v;
     }
 
-    protected _parent: BinaryTreeNode<T> | null | undefined = undefined;
+    protected _parent: BinaryTreeNode<T> | null | undefined;
+
     get parent(): BinaryTreeNode<T> | null | undefined {
         return this._parent;
     }
@@ -73,6 +77,7 @@ export class BinaryTreeNode<T> {
     }
 
     protected _familyPosition: FamilyPosition = FamilyPosition.root;
+
     get familyPosition(): FamilyPosition {
         return this._familyPosition;
     }
@@ -82,6 +87,7 @@ export class BinaryTreeNode<T> {
     }
 
     protected _count = 1;
+
     get count(): number {
         return this._count;
     }
@@ -100,12 +106,6 @@ export class BinaryTreeNode<T> {
         this._height = v;
     }
 
-    constructor(id: BinaryTreeNodeId, val: T, count?: number) {
-        this._id = id;
-        this._val = val;
-        this._count = count ?? 1;
-    }
-
     swapLocation(swapNode: BinaryTreeNode<T>): BinaryTreeNode<T> {
         const {val, count, height} = swapNode;
         const tempNode = new BinaryTreeNode<T>(swapNode.id, val);
@@ -131,8 +131,36 @@ export class BinaryTreeNode<T> {
 }
 
 export class BinaryTree<T> {
+    protected _loopType: LoopType = LoopType.iterative;
+    protected _visitedId: BinaryTreeNodeId[] = [];
+    protected _visitedVal: Array<T> = [];
+    protected _visitedNode: BinaryTreeNode<T>[] = [];
+    protected _visitedCount: number[] = [];
+    protected _visitedLeftSum: number[] = [];
+    private readonly _autoIncrementId: boolean = false;
+    private _maxId: number = -1;
+    private readonly _isDuplicatedVal: boolean = false;
+
+    constructor(options?: {
+        loopType?: LoopType,
+        autoIncrementId?: boolean,
+        isDuplicatedVal?: boolean
+    }) {
+        if (options !== undefined) {
+            const {
+                loopType = LoopType.iterative,
+                autoIncrementId = false,
+                isDuplicatedVal = false
+            } = options;
+            this._isDuplicatedVal = isDuplicatedVal;
+            this._autoIncrementId = autoIncrementId;
+            this._loopType = loopType;
+        }
+    }
+
     protected _root: BinaryTreeNode<T> | null = null;
-    public get root(): BinaryTreeNode<T> | null {
+
+    protected get root(): BinaryTreeNode<T> | null {
         return this._root;
     }
 
@@ -145,7 +173,8 @@ export class BinaryTree<T> {
     }
 
     protected _size = 0;
-    get size(): number {
+
+    protected get size(): number {
         return this._size;
     }
 
@@ -154,7 +183,8 @@ export class BinaryTree<T> {
     }
 
     protected _count = 0;
-    get count(): number {
+
+    protected get count(): number {
         return this._count;
     }
 
@@ -162,40 +192,8 @@ export class BinaryTree<T> {
         this._count = v;
     }
 
-    private readonly _autoIncrementId: boolean = false;
-    private _maxId: number = -1;
-    private readonly _isDuplicatedVal: boolean = false;
-
-    protected _loopType: LoopType = LoopType.iterative;
-    protected _visitedId: BinaryTreeNodeId[] = [];
-    protected _visitedVal: Array<T> = [];
-    protected _visitedNode: BinaryTreeNode<T>[] = [];
-    protected _visitedCount: number[] = [];
-    protected _visitedLeftSum: number[] = [];
-
-    protected _resetResults() {
-        this._visitedId = [];
-        this._visitedVal = [];
-        this._visitedNode = [];
-        this._visitedCount = [];
-        this._visitedLeftSum = [];
-    }
-
-    constructor(options?: {
-        loopType?: LoopType,
-        autoIncrementId?: boolean,
-        isDuplicatedVal?: boolean
-    }) {
-        if (options !== undefined) {
-            const {
-                loopType = LoopType.iterative,
-                autoIncrementId = false,
-                isDuplicatedVal = false
-            } = options;
-            this._isDuplicatedVal = isDuplicatedVal;
-            this._autoIncrementId = autoIncrementId;
-            this._loopType = loopType;
-        }
+    getCount(): number {
+        return this._count;
     }
 
     createNode(id: BinaryTreeNodeId, val: T | null, count?: number): BinaryTreeNode<T> | null {
@@ -393,8 +391,8 @@ export class BinaryTree<T> {
             return _getMaxHeight(beginRoot);
         } else {
             const stack: BinaryTreeNode<T>[] = [];
-            let node: BinaryTreeNode<T> | null | undefined = beginRoot, last: BinaryTreeNode<T> | null = null,
-                depths: Map<BinaryTreeNode<T>, number> = new Map();
+            let node: BinaryTreeNode<T> | null | undefined = beginRoot, last: BinaryTreeNode<T> | null = null;
+            const depths: Map<BinaryTreeNode<T>, number> = new Map();
 
             while (stack.length > 0 || node) {
                 if (node) {
@@ -405,8 +403,8 @@ export class BinaryTree<T> {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let leftHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-                            let rightHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+                            const leftHeight = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const rightHeight = node.right ? depths.get(node.right) ?? -1 : -1;
                             depths.set(node, 1 + Math.max(leftHeight, rightHeight));
                             last = node;
                             node = null;
@@ -435,8 +433,8 @@ export class BinaryTree<T> {
             return _getMinHeight(beginRoot);
         } else {
             const stack: BinaryTreeNode<T>[] = [];
-            let node: BinaryTreeNode<T> | null | undefined = beginRoot, last: BinaryTreeNode<T> | null = null,
-                depths: Map<BinaryTreeNode<T>, number> = new Map();
+            let node: BinaryTreeNode<T> | null | undefined = beginRoot, last: BinaryTreeNode<T> | null = null;
+            const depths: Map<BinaryTreeNode<T>, number> = new Map();
 
             while (stack.length > 0 || node) {
                 if (node) {
@@ -447,8 +445,8 @@ export class BinaryTree<T> {
                     if (!node.right || last === node.right) {
                         node = stack.pop();
                         if (node) {
-                            let leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
-                            let rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
+                            const leftMinHeight = node.left ? depths.get(node.left) ?? -1 : -1;
+                            const rightMinHeight = node.right ? depths.get(node.right) ?? -1 : -1;
                             depths.set(node, 1 + Math.min(leftMinHeight, rightMinHeight));
                             last = node;
                             node = null;
@@ -514,76 +512,14 @@ export class BinaryTree<T> {
         return result;
     }
 
-    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean) {
-        switch (propertyName) {
-            case 'id':
-                if (cur.id === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            case 'count':
-                if (cur.count === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            case 'val':
-                if (cur.val === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-            default:
-                if (cur.id === nodeProperty) {
-                    result.push(cur);
-                    return !!onlyOne;
-                }
-                break;
-        }
-    }
-
-    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName ?: NodeOrPropertyName) {
-        nodeOrPropertyName = nodeOrPropertyName ?? 'id';
-
-        switch (nodeOrPropertyName) {
-            case 'id':
-                this._visitedId.push(node.id);
-                break;
-            case 'val':
-                this._visitedVal.push(node.val);
-                break;
-            case 'node':
-                this._visitedNode.push(node);
-                break;
-            case 'count':
-                this._visitedCount.push(node.count);
-                break;
-            default:
-                this._visitedId.push(node.id);
-                break;
-        }
-    }
-
-    protected _getResultByPropertyName(nodeOrPropertyName ?: NodeOrPropertyName): ResultsByProperty<T> {
-        nodeOrPropertyName = nodeOrPropertyName ?? 'id';
-
-        switch (nodeOrPropertyName) {
-            case 'id':
-                return this._visitedId;
-            case 'val':
-                return this._visitedVal;
-            case 'node':
-                return this._visitedNode;
-            case 'count':
-                return this._visitedCount;
-            default:
-                return this._visitedId;
-        }
+    getRoot(): BinaryTreeNode<T> | null {
+        return this.root;
     }
 
     getLeftMost(): BinaryTreeNode<T> | null;
+
     getLeftMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+
     getLeftMost(node?: BinaryTreeNode<T> | null): BinaryTreeNode<T> | null {
         node = node ?? this.root;
         if (!node) return node;
@@ -598,7 +534,7 @@ export class BinaryTree<T> {
             return _traverse(node);
         } else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur: BinaryTreeNode<T>): ThunkOrValue<BinaryTreeNode<T> | null> => {
+            const _traverse = trampoline((cur: BinaryTreeNode<T>) => {
                 if (!cur.left) return cur;
                 return _traverse.cont(cur.left);
             });
@@ -608,7 +544,9 @@ export class BinaryTree<T> {
     }
 
     getRightMost(): BinaryTreeNode<T> | null;
+
     getRightMost(node: BinaryTreeNode<T>): BinaryTreeNode<T>;
+
     getRightMost(node?: BinaryTreeNode<T> | null): BinaryTreeNode<T> | null {
         node = node ?? this.root;
         if (!node) return node;
@@ -622,7 +560,7 @@ export class BinaryTree<T> {
             return _traverse(node);
         } else {
             // Indirect implementation of iteration using tail recursion optimization
-            const _traverse = trampoline((cur: BinaryTreeNode<T>): ThunkOrValue<BinaryTreeNode<T> | null> => {
+            const _traverse = trampoline((cur: BinaryTreeNode<T>) => {
                 if (!cur.right) return cur;
                 return _traverse.cont(cur.right);
             });
@@ -653,7 +591,7 @@ export class BinaryTree<T> {
                     curr = curr.left;
                 }
                 curr = stack.pop()!;
-                if (prev >= curr.id) return false;
+                if (!(curr) || prev >= curr.id) return false;
                 prev = curr.id;
                 curr = curr.right;
             }
@@ -779,10 +717,15 @@ export class BinaryTree<T> {
     }
 
     BFS(): BinaryTreeNodeId[];
+
     BFS(nodeOrPropertyName: 'id'): BinaryTreeNodeId[];
+
     BFS(nodeOrPropertyName: 'val'): T[];
+
     BFS(nodeOrPropertyName: 'node'): BinaryTreeNode<T>[];
+
     BFS(nodeOrPropertyName: 'count'): number[];
+
     BFS(nodeOrPropertyName ?: NodeOrPropertyName): ResultsByProperty<T> {
         nodeOrPropertyName = nodeOrPropertyName ?? 'id';
         this._resetResults();
@@ -801,10 +744,15 @@ export class BinaryTree<T> {
     }
 
     DFS(): BinaryTreeNodeId[];
+
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+
     DFS(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+
     DFS(pattern ?: 'in' | 'pre' | 'post', nodeOrPropertyName ?: NodeOrPropertyName): ResultsByProperty<T> {
         pattern = pattern ?? 'in';
         nodeOrPropertyName = nodeOrPropertyName ?? 'id';
@@ -834,9 +782,13 @@ export class BinaryTree<T> {
     }
 
     DFSIterative(): BinaryTreeNodeId[];
+
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+
     DFSIterative(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
 
     /**
@@ -889,10 +841,15 @@ export class BinaryTree<T> {
     }
 
     levelIterative(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[];
+
     levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
     levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[];
+
     levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+
     levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[];
+
     levelIterative(node: BinaryTreeNode<T> | null, nodeOrPropertyName ?: NodeOrPropertyName): ResultsByProperty<T> {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         node = node || this.root;
@@ -918,10 +875,15 @@ export class BinaryTree<T> {
     }
 
     listLevels(node: BinaryTreeNode<T> | null): BinaryTreeNodeId[][];
+
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[][];
+
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'val'): T[][];
+
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[][];
+
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: 'count'): number[][];
+
     listLevels(node: BinaryTreeNode<T> | null, nodeOrPropertyName?: NodeOrPropertyName): ResultByProperty<T>[][] {
         nodeOrPropertyName = nodeOrPropertyName || 'id';
         node = node || this.root;
@@ -977,9 +939,11 @@ export class BinaryTree<T> {
 
     getPredecessor(node: BinaryTreeNode<T>): BinaryTreeNode<T> {
         if (node.left) {
-            let predecessor: BinaryTreeNode<T> | null = node.left;
-            while (predecessor.right && predecessor.right !== node) {
-                predecessor = predecessor.right;
+            let predecessor: BinaryTreeNode<T> | null | undefined = node.left;
+            while (!(predecessor) || predecessor.right && predecessor.right !== node) {
+                if (predecessor) {
+                    predecessor = predecessor.right;
+                }
             }
             return predecessor;
         } else {
@@ -988,10 +952,15 @@ export class BinaryTree<T> {
     }
 
     morris(): BinaryTreeNodeId[];
+
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'id'): BinaryTreeNodeId[];
+
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'val'): T[];
+
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'node'): BinaryTreeNode<T>[];
+
     morris(pattern?: DFSOrderPattern, nodeOrPropertyName?: 'count'): number[];
+
     /**
      * The time complexity of Morris traversal is O(n), it's may slower than others
      * The space complexity  Morris traversal is O(1) because no using stack
@@ -1084,5 +1053,81 @@ export class BinaryTree<T> {
         return this._getResultByPropertyName(nodeOrPropertyName);
     }
 
+    protected _resetResults() {
+        this._visitedId = [];
+        this._visitedVal = [];
+        this._visitedNode = [];
+        this._visitedCount = [];
+        this._visitedLeftSum = [];
+    }
+
+    protected _pushByPropertyNameStopOrNot(cur: BinaryTreeNode<T>, result: (BinaryTreeNode<T> | null | undefined)[], nodeProperty: BinaryTreeNodeId | T, propertyName ?: BinaryTreeNodePropertyName, onlyOne ?: boolean) {
+        switch (propertyName) {
+            case 'id':
+                if (cur.id === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            case 'count':
+                if (cur.count === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            case 'val':
+                if (cur.val === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+            default:
+                if (cur.id === nodeProperty) {
+                    result.push(cur);
+                    return !!onlyOne;
+                }
+                break;
+        }
+    }
+
+    protected _accumulatedByPropertyName(node: BinaryTreeNode<T>, nodeOrPropertyName ?: NodeOrPropertyName) {
+        nodeOrPropertyName = nodeOrPropertyName ?? 'id';
+
+        switch (nodeOrPropertyName) {
+            case 'id':
+                this._visitedId.push(node.id);
+                break;
+            case 'val':
+                this._visitedVal.push(node.val);
+                break;
+            case 'node':
+                this._visitedNode.push(node);
+                break;
+            case 'count':
+                this._visitedCount.push(node.count);
+                break;
+            default:
+                this._visitedId.push(node.id);
+                break;
+        }
+    }
+
+    protected _getResultByPropertyName(nodeOrPropertyName ?: NodeOrPropertyName): ResultsByProperty<T> {
+        nodeOrPropertyName = nodeOrPropertyName ?? 'id';
+
+        switch (nodeOrPropertyName) {
+            case 'id':
+                return this._visitedId;
+            case 'val':
+                return this._visitedVal;
+            case 'node':
+                return this._visitedNode;
+            case 'count':
+                return this._visitedCount;
+            default:
+                return this._visitedId;
+        }
+    }
+
     // --- end additional methods ---
 }