Wrong height proportions. about d3-funnel HOT 4 CLOSED

key: '_makePaths',
            value: function _makePaths() {
                var paths = [];

                // Initialize velocity
                var dx = this.dx;
                var dy = this.dy;

                // Initialize starting positions
                var prevLeftX = 0;
                var prevRightX = this.width;
                var prevHeight = 0;

                // Start from the bottom for inverted
                if (this.isInverted) {
                    prevLeftX = this.bottomLeftX;
                    prevRightX = this.width - this.bottomLeftX;
                }

                // Initialize next positions
                var nextLeftX = 0;
                var nextRightX = 0;
                var nextHeight = 0;

                var middle = this.width / 2;

                // Move down if there is an initial curve
                if (this.isCurved) {
                    prevHeight = 10;
                }

                var topBase = this.width;
                var bottomBase = 0;

                var totalArea = this.height * (this.width + this.bottomWidth) / 2;
                var slope = 2 * this.height / (this.width - this.bottomWidth);

                // This is greedy in that the block will have a guaranteed height
                // and the remaining is shared among the ratio, instead of being
                // shared according to the remaining minus the guaranteed

                if (this.minHeight !== false) {
                    var height = this.height - this.minHeight * this.data.length;
                    totalArea = height * (this.width + this.bottomWidth) / 2;
                }

                var totalCount = 0;
                var count = 0;

                // Harvest total count
                var sum = 0;
                for (var i = 0; i < this.data.length; i++) {
                    totalCount += isArray(this.data[i][1]) ? this.data[i][1][0] : this.data[i][1];
                    sum += this.data[i][1][0]; //starting edits
                }

                // Create the path definition for each funnel block
                // Remember to loop back to the beginning point for a closed path

                //starting edits
                var exceptionValueCount = 0;

                for (var i = 0; i < this.data.length; i++) {
                    if (this.data[i][1][0] === 0 || Math.round((this.data[i][1][0] * this.height) / sum) <= this.minHeight)
                        exceptionValueCount++;
                }

                sum = (Math.round(sum * 100) / 100);
                //ending edits
                for (var i = 0; i < this.data.length; i++) {
                    count = isArray(this.data[i][1]) ? this.data[i][1][0] : this.data[i][1];

                    // Calculate dynamic shapes based on area
                    if (this.dynamicArea) {
                        var ratio = count / totalCount;
                        var area = ratio * totalArea;

                        if (this.minHeight !== false) {
                            area += this.minHeight * (this.width + this.bottomWidth) / 2;
                        }

                        bottomBase = Math.sqrt((slope * topBase * topBase - 4 * area) / slope);
                        dx = topBase / 2 - bottomBase / 2;
                        //starting edits
                        //dy = area * 2 / (topBase + bottomBase);
                        var y = (sum === 0 || ((this.data[i][1][0] * this.height) / sum) < this.minHeight) ? this.minHeight : (this.data[i][1][0] * (this.height - (exceptionValueCount * this.minHeight))) / sum;

                        dy = y;
                        //ending edits

                        if (this.isCurved) {
                            dy = dy - this.curveHeight / this.data.length;
                        }

                        topBase = bottomBase;
                    }

                    // Stop velocity for pinched blocks
                    if (this.bottomPinch > 0) {
                        // Check if we've reached the bottom of the pinch
                        // If so, stop changing on x
                        if (!this.isInverted) {
                            if (i >= this.data.length - this.bottomPinch) {
                                dx = 0;
                            }
                            // Pinch at the first blocks relating to the bottom pinch
                            // Revert back to normal velocity after pinch
                        } else {
                                // Revert velocity back to the initial if we are using
                                // static area's (prevents zero velocity if isInverted
                                // and bottomPinch are non trivial and dynamicArea is
                                // false)
                                if (!this.dynamicArea) {
                                    dx = this.dx;
                                }

                                dx = i < this.bottomPinch ? 0 : dx;
                            }
                    }

                    // Calculate the position of next block
                    nextLeftX = prevLeftX + dx;
                    nextRightX = prevRightX - dx;
                    nextHeight = prevHeight + dy;

                    // Expand outward if inverted
                    if (this.isInverted) {
                        nextLeftX = prevLeftX - dx;
                        nextRightX = prevRightX + dx;
                    }

                    // Plot curved lines
                    if (this.isCurved) {
                        paths.push([
                        // Top Bezier curve
                        [prevLeftX, prevHeight, 'M'], [middle, prevHeight + (this.curveHeight - 10), 'Q'], [prevRightX, prevHeight, ''],
                        // Right line
                        [nextRightX, nextHeight, 'L'],
                        // Bottom Bezier curve
                        [nextRightX, nextHeight, 'M'], [middle, nextHeight + this.curveHeight, 'Q'], [nextLeftX, nextHeight, ''],
                        // Left line
                        [prevLeftX, prevHeight, 'L']]);
                        // Plot straight lines
                    } else {
                            paths.push([
                            // Start position
                            [prevLeftX, prevHeight, 'M'],
                            // Move to right
                            [prevRightX, prevHeight, 'L'],
                            // Move down
                            [nextRightX, nextHeight, 'L'],
                            // Move to left
                            [nextLeftX, nextHeight, 'L'],
                            // Wrap back to top
                            [prevLeftX, prevHeight, 'L']]);
                        }

                    // Set the next block's previous position
                    prevLeftX = nextLeftX;
                    prevRightX = nextRightX;
                    prevHeight = nextHeight;
                }

                return paths;
            }