UI scroll to selection - unityUIExtensions?

Has anyone here ever used the unity UI extensions?
https://bitbucket.org/UnityUIExtensions/unity-ui-extensions/src/88c43891c0bf44f136e3021ad6c89d704dfebc83/Scripts/Utilities/UIScrollToSelection.cs?at=master&fileviewer=file-view-default

I’m trying to use the UI scroll to selection script to scroll through an item list with keyboard controls only. These are the only instructions I’ve got.

Simply place the script on the ScrollRect that contains the selectable children we'll be scroling to
and drag'n'drop the RectTransform of the options "container" that we'll be scrolling.*/

I’ve tried to interpet that sentence for hours now, I’ve dragged the script on everything it seems and nothing is working. Either nothing happens when you test play it or it bugs out. Anyone ever used any of this or understand the instructions better than I do? Here is the script.
/// Credit zero3growlithe
/// sourced from: http://forum.unity3d.com/threads/scripts-useful-4-6-scripts-collection.264161/page-2#post-2011648

/*USAGE:
Simply place the script on the ScrollRect that contains the selectable children we'll be scroling to
and drag'n'drop the RectTransform of the options "container" that we'll be scrolling.*/

using System.Collections.Generic;
using UnityEngine.EventSystems;

namespace UnityEngine.UI.Extensions
{
    [RequireComponent(typeof(ScrollRect))]
    [AddComponentMenu("UI/Extensions/UIScrollToSelection")]
    public class UIScrollToSelection : MonoBehaviour
    {

        //*** ATTRIBUTES ***//
        [Header("[ Settings ]")]
        [SerializeField]
        private ScrollType scrollDirection;
        [SerializeField]
        private float scrollSpeed = 10f;

        [Header("[ Input ]")]
        [SerializeField]
        private bool cancelScrollOnInput = false;
        [SerializeField]
        private List<KeyCode> cancelScrollKeycodes = new List<KeyCode>();

        //*** PROPERTIES ***//
        // REFERENCES
        protected RectTransform LayoutListGroup
        {
            get { return TargetScrollRect != null ? TargetScrollRect.content : null; }
        }

        // SETTINGS
        protected ScrollType ScrollDirection
        {
            get { return scrollDirection; }
        }
        protected float ScrollSpeed
        {
            get { return scrollSpeed; }
        }

        // INPUT
        protected bool CancelScrollOnInput
        {
            get { return cancelScrollOnInput; }
        }
        protected List<KeyCode> CancelScrollKeycodes
        {
            get { return cancelScrollKeycodes; }
        }

        // CACHED REFERENCES
        protected RectTransform ScrollWindow { get; set; }
        protected ScrollRect TargetScrollRect { get; set; }

        // SCROLLING
        protected EventSystem CurrentEventSystem
        {
            get { return EventSystem.current; }
        }
        protected GameObject LastCheckedGameObject { get; set; }
        protected GameObject CurrentSelectedGameObject
        {
            get { return EventSystem.current.currentSelectedGameObject; }
        }
        protected RectTransform CurrentTargetRectTransform { get; set; }
        protected bool IsManualScrollingAvailable { get; set; }

        //*** METHODS - PUBLIC ***//


        //*** METHODS - PROTECTED ***//
        protected virtual void Awake()
        {
            TargetScrollRect = GetComponent<ScrollRect>();
            ScrollWindow = TargetScrollRect.GetComponent<RectTransform>();
        }

        protected virtual void Start()
        {

        }

        protected virtual void Update()
        {
            UpdateReferences();
            CheckIfScrollingShouldBeLocked();
            ScrollRectToLevelSelection();
        }

        //*** METHODS - PRIVATE ***//
        private void UpdateReferences()
        {
            // update current selected rect transform
            if (CurrentSelectedGameObject != LastCheckedGameObject)
            {
                CurrentTargetRectTransform = (CurrentSelectedGameObject != null) ?
                    CurrentSelectedGameObject.GetComponent<RectTransform>() :
                    null;

                // unlock automatic scrolling
                if (CurrentSelectedGameObject != null &&
                    CurrentSelectedGameObject.transform.parent == LayoutListGroup.transform)
                {
                    IsManualScrollingAvailable = false;
                }
            }

            LastCheckedGameObject = CurrentSelectedGameObject;
        }

        private void CheckIfScrollingShouldBeLocked()
        {
            if (CancelScrollOnInput == false || IsManualScrollingAvailable == true)
            {
                return;
            }

            for (int i = 0; i < CancelScrollKeycodes.Count; i++)
            {
                if (Input.GetKeyDown(CancelScrollKeycodes*) == true)*

{
IsManualScrollingAvailable = true;

break;
}
}
}

private void ScrollRectToLevelSelection()
{
// check main references
bool referencesAreIncorrect = (TargetScrollRect == null || LayoutListGroup == null || ScrollWindow == null);

if (referencesAreIncorrect == true || IsManualScrollingAvailable == true)
{
return;
}

RectTransform selection = CurrentTargetRectTransform;

// check if scrolling is possible
if (selection == null || selection.transform.parent != LayoutListGroup.transform)
{
return;
}

// depending on selected scroll direction move the scroll rect to selection
switch (ScrollDirection)
{
case ScrollType.VERTICAL:
UpdateVerticalScrollPosition(selection);
break;
case ScrollType.HORIZONTAL:
UpdateHorizontalScrollPosition(selection);
break;
case ScrollType.BOTH:
UpdateVerticalScrollPosition(selection);
UpdateHorizontalScrollPosition(selection);
break;
}
}

private void UpdateVerticalScrollPosition(RectTransform selection)
{
// move the current scroll rect to correct position
float selectionPosition = -selection.anchoredPosition.y - (selection.rect.height * (1 - selection.pivot.y));

float elementHeight = selection.rect.height;
float maskHeight = ScrollWindow.rect.height;
float listAnchorPosition = LayoutListGroup.anchoredPosition.y;

// get the element offset value depending on the cursor move direction
float offlimitsValue = GetScrollOffset(selectionPosition, listAnchorPosition, elementHeight, maskHeight);

// move the target scroll rect
TargetScrollRect.verticalNormalizedPosition +=
(offlimitsValue / LayoutListGroup.rect.height) * Time.unscaledDeltaTime * scrollSpeed;
}

private void UpdateHorizontalScrollPosition(RectTransform selection)
{
// move the current scroll rect to correct position
float selectionPosition = -selection.anchoredPosition.x - (selection.rect.width * (1 - selection.pivot.x));

float elementWidth = selection.rect.width;
float maskWidth = ScrollWindow.rect.width;
float listAnchorPosition = -LayoutListGroup.anchoredPosition.x;

// get the element offset value depending on the cursor move direction
float offlimitsValue = -GetScrollOffset(selectionPosition, listAnchorPosition, elementWidth, maskWidth);

// move the target scroll rect
TargetScrollRect.horizontalNormalizedPosition +=
(offlimitsValue / LayoutListGroup.rect.width) * Time.unscaledDeltaTime * scrollSpeed;
}

private float GetScrollOffset(float position, float listAnchorPosition, float targetLength, float maskLength)
{
if (position < listAnchorPosition + (targetLength / 2))
{
return (listAnchorPosition + maskLength) - (position - targetLength);
}
else if (position + targetLength > listAnchorPosition + maskLength)
{
return (listAnchorPosition + maskLength) - (position + targetLength);
}

return 0;
}

//*** ENUMS ***//
public enum ScrollType
{
VERTICAL,
HORIZONTAL,
BOTH
}
}
}

@djordr
I’m using the script from Bitbucket with Unity 2017.3. The “drag’n’drop” part is probably from the old version, now you only have to drag the script into the Inspector of your ScrollView.
If you want to use your keyboard, you also have to set up 2 (3) more things:

  1. “First Selected” in your EventSystem (drag’n’drop a button there)
  2. The “Horizontal Axis” and “Vertical Axis” are already set in the EventSystem but you also have to set both input values to the keys you want to use to scroll up/down/left/right in the InputManager (there are loads of tutorials on how to create new input sets).

What exactly

or it bugs out

?