Find the largest Perfect Subtree in a given Binary Tree

<script>

    // JavaScript program to print postorder
    // traversal iteratively
    
    // Node structure of the tree
    class node
    {
        constructor(data) {
           this.left = null;
           this.right = null;
           this.data = data;
        }
    }
    
    // To create a new node
    function newNode(data)
    {
        let Node = new node(data);
        return Node;
    }
    
    // Structure for return type of
    // function findPerfectBinaryTree
    class returnType 
    {
        constructor(data) {
           this.isPerfect;
           this.height;
           this.rootTree;
        }
    }

    // Function to return the biggest
    // perfect binary sub-tree
    function findPerfectBinaryTree(root)
    {

        // Declaring returnType that
        // needs to be returned
        let rt = new returnType();

        // If root is null then it is considered as
        // perfect binary tree of height 0
        if (root == null)
        {
            rt.isPerfect = true;
            rt.height = 0;
            rt.rootTree = null;
            return rt;
        }

        // Recursive call for left and right child
        let lv = findPerfectBinaryTree(root.left);
        let rv = findPerfectBinaryTree(root.right);

        // If both left and right sub-trees are perfect and
        // there height is also same then sub-tree root
        // is also perfect binary subtree with height
        // plus one of its child sub-trees
        if (lv.isPerfect && rv.isPerfect && 
            lv.height == rv.height)
        {
            rt.height = lv.height + 1;
            rt.isPerfect = true;
            rt.rootTree = root;
            return rt;
        }

        // Else this sub-tree cannot be a perfect binary tree
        // and simply return the biggest sized perfect sub-tree
        // found till now in the left or right sub-trees
        rt.isPerfect = false;
        rt.height = Math.max(lv.height, rv.height);
        rt.rootTree = (lv.height > rv.height ? 
                                 lv.rootTree : rv.rootTree);
        return rt;
    }

    // Function to print the 
    // inorder traversal of the tree
    function inorderPrint(root)
    {
        if (root != null)
        {
            inorderPrint(root.left);
            document.write(root.data + " ");
            inorderPrint(root.right);
        }
    }
    
    // Create tree
    let root = newNode(1);
    root.left = newNode(2);
    root.right = newNode(3);
    root.left.left = newNode(4);
    root.left.right = newNode(5);
    root.right.left = newNode(6);
  
    // Get the biggest sizes perfect binary sub-tree
    let ans = findPerfectBinaryTree(root);
  
    // Height of the found sub-tree
    let h = ans.height;
  
    document.write("Size : " + (Math.pow(2, h) - 1) + "</br>");
  
    // Print the inorder traversal of the found sub-tree
    document.write("Inorder Traversal : ");
    inorderPrint(ans.rootTree);

</script>