     }
     
     // Private Helpers
-    private func _horizontalGridPosition(for absOffset: CGFloat) -> CGFloat {
-        return self._roundToSubdivision((absOffset / self.columnWidth) - self.gridInsetFactor)
-    }
-    
-    private func _verticalGridPosition(for absOffset: CGFloat) -> CGFloat {
-        return self._roundToSubdivision((absOffset / self.rowHeight) - self.gridInsetFactor)
-    }
-    
     private func _absOffset(nearestToAbsOffset absOffset: CGFloat, minAbsOffset: CGFloat, maxAbsOffset: CGFloat, absStepUnit: CGFloat) -> CGFloat {
         if absOffset <= minAbsOffset {
             return minAbsOffset

            return (round((absOffset - minAbsOffset) / absStepSize) * absStepSize) + minAbsOffset
        }
    }
    
    private func _roundToSubdivision(_ gridPosition: CGFloat) -> CGFloat {
        let invertedSubdivision: CGFloat = 1 / self.subdivision.rawValue
        return round(gridPosition * invertedSubdivision) / invertedSubdivision
    }
}

            maxAbsOffset: self._verticalAbsOffset(forGridPosition: CGFloat(self._zeroedNumOfRows)),
            absStepUnit: self.rowHeight
        )
        
        let nearestColumnAbsOffset: CGFloat = self._absOffset(
            nearestToAbsOffset: point.x,
            minAbsOffset: self._horizontalAbsOffset(forGridPosition: 0),
            maxAbsOffset: self._horizontalAbsOffset(forGridPosition: CGFloat(self._zeroedNumOfColumns)),
            absStepUnit: self.columnWidth
        )
        
        func roundToSubdiv(_ position: CGFloat) -> CGFloat {
            let invertedSubdivision: CGFloat = 1 / self.subdivision.rawValue
            return round(position * invertedSubdivision) / invertedSubdivision
        }
        
        let insetFactor: CGFloat = self.gridInsetFactor
        
        return (
            roundToSubdiv((nearestRowAbsOffset / self.rowHeight) - insetFactor),
            roundToSubdiv((nearestColumnAbsOffset / self.columnWidth) - insetFactor)
        )
    }
    
    // Helpers
