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

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

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