             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
-    }
-}
+}

// MARK: Point <-> Location <-> SlotIndex Calculation
private extension GridLayer {
    func _point(for location: GridLayer.Location) -> CGPoint {
        let x: CGFloat = self._horizontalAbsOffset(forGridPosition: location.column)
        let y: CGFloat = self._verticalAbsOffset(forGridPosition: location.row)
        return CGPoint(x: x, y: y)
    }
    
    func _location(nearestTo point: CGPoint) -> GridLayer.Location {

            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
