Note: The code below is functional only in the context of the complete JavaScript file.

In the @tooltip section:

      function createTooltip(trigger) {
        var tipText = trigger.getAttribute('data-deque-tooltip');
        var tipID = (0, _guidUtils.generateGuid)();

        /* wrap the element (trigger) in a container */
        var tipWrapper = document.createElement('span');
        tipWrapper.classList.add('deque-tooltip-wrapper');
        trigger.parentNode.insertBefore(tipWrapper, trigger);
        /* move element into the wrapper */
        tipWrapper.appendChild(trigger);

        /* create tooltip */
        var tip = document.createElement('span');
        tip.setAttribute('role', 'tooltip');
        tip.id = tipID;
        tip.classList.add('deque-tooltip');

        tip.innerHTML = '<span aria-label="Tooltip :"></span>' + tipText;
        /* move tooltip into the wrapper */
        tipWrapper.appendChild(tip);

        /* carry over CSS values */
        var triggerStyle = window.getComputedStyle(trigger);
        var triggerCSS = [];
        triggerCSS['display'] = triggerStyle.getPropertyValue('display');

        function getTriggerPosition() {
          /* get element's size and position */
          var triggerPosition = [];
          triggerPosition['width'] = trigger.offsetWidth;
          triggerPosition['height'] = trigger.offsetHeight;
          return triggerPosition;
        }

        function getTooltipPosition(triggerPosition) {
          /* get/set positioning preferences */
          var triggerPositionPref = trigger.getAttribute('data-deque-tooltip-position');

          /* get tooltip dimensions */
          var tipStyle = window.getComputedStyle(tip);
          var tipCSS = [];
          tipCSS['width'] = tipStyle.getPropertyValue('width');
          tipCSS['width'] = tipCSS['width'].replace('px', '');
          tipCSS['width'] = Number(tipCSS['width']);
          tipCSS['height'] = tipStyle.getPropertyValue('height');
          tipCSS['height'] = tipCSS['height'].replace('px', '');
          tipCSS['height'] = Number(tipCSS['height']);

          /*triggerPositionPref is currently not being used in the code,
          but the idea is that developers could specify where the 
          tooltip should be placed: top, right, bottom, left, or top-right */
          if (triggerPositionPref == 'right') {
            tip.style.left = '5px';
            // put other calculations here
          }
          if (triggerPositionPref == 'top') {
            // put calculations here
          } else {
            var newLeft = triggerPosition['width'] - 10;
            //var newTop = tipCSS['height'] + 5;
            tip.style.left = newLeft - 10 + 'px';
            //tip.style.top = '-' + (newTop) + 'px';
            tip.style.bottom = '120%';
          }
        }

        (0, _noclobberUtils.noClobber)(trigger, 'aria-describedby', tipID);

        var causes = {
          INITIAL: 'initial',
          FOCUS: 'focus',
          MOUSE: 'mouse',
          ESCAPE: 'escape'
        };

        var currentCause = causes.INITIAL;

        function showTip(cause) {
          if (currentCause === causes.FOCUS) {
            // prevents 'MOUSE' cause from replacing 'FOCUS' cause.
            return;
          }

          tip.classList.remove('deque-hidden');
          tip.setAttribute('aria-hidden', 'false');

          currentCause = cause;

          var p = getTriggerPosition();
          getTooltipPosition(p);
          /* For some reason, the position is incorrectly 
          calculated on inline elements the first time the
          getTooltipPosition function runs, so it has to run
          twice. Possible bug in the script's logic? */
          getTooltipPosition(p);
        }

        function hideTip(cause) {
          if (cause === causes.ESCAPE || currentCause === cause) {
            tip.classList.add('deque-hidden');
            tip.setAttribute('aria-hidden', 'true');
            currentCause = '';
          }
        }

        function escapeHandler() {
          hideTip(causes.ESCAPE);
        }

        var cancelElementEscape = (0, _keyboardUtils.onElementEscape)(document.body, escapeHandler);

        var focusHandler = showTip.bind(null, causes.FOCUS);
        var blurHandler = hideTip.bind(null, causes.FOCUS);
        var overHandler = showTip.bind(null, causes.MOUSE);
        var outHandler = hideTip.bind(null, causes.MOUSE);

        trigger.addEventListener('focus', focusHandler);
        trigger.addEventListener('blur', blurHandler);
        trigger.addEventListener('mouseover', overHandler);
        trigger.addEventListener('mouseout', outHandler);

        /*// eslint-disable-next-line no-console
        console.log(trigger);
        // eslint-disable-next-line no-console
        console.log(trigger.parentNode.querySelector('.deque-tooltip'));*/

        if (trigger.parentNode.querySelector('.deque-tooltip')) {
          trigger.parentNode.querySelector('.deque-tooltip').addEventListener('mouseover', overHandler);
          trigger.parentNode.querySelector('.deque-tooltip').addEventListener('mouseout', outHandler);
        }

        hideTip(causes.INITIAL);

        return function disableTooltip() {
          hideTip(causes.ESCAPE);

          cancelElementEscape();

          try {
            tip.remove();
          } catch (err) {
            /*no op*/
          }

          trigger.removeEventListener('focus', focusHandler);
          trigger.removeEventListener('blur', blurHandler);
          trigger.removeEventListener('mouseover', overHandler);
          trigger.removeEventListener('mouseout', outHandler);
          trigger.removeAttribute('aria-describedby');
        };
      }

      function initializeAllTooltips() {
        var itemsToTip = document.querySelectorAll('[data-deque-tooltip]');
        for (var i = 0; i < itemsToTip.length; i++) {
          createTooltip(itemsToTip[i]);
        }
      }

      initializeAllTooltips();
      

In the @guidUtils section:

      /*
        note - not a true guid. I prepend 'g' because 
        the ID of an element cannot start with a numeral
      */

      function generateGuid() {
        var S4 = function S4() {
          return ((1 + Math.random()) * 0x10000 | 0).toString(16).substring(1);
        };
        return 'g' + (S4() + S4() + '-' + S4() + '-' + S4() + '-' + S4() + '-' + S4() + S4() + S4());
      }
      

In the @keyboardUtils section:

      var KEYS = exports.KEYS = {
        BACKSPACE: 8,
        TAB: 9,
        ENTER: 13,
        SHIFT: 16,
        CTRL: 17,
        ALT: 18,
        ESCAPE: 27,
        SPACE: 32,
        LEFT: 37,
        RIGHT: 39,
        UP: 38,
        DOWN: 40,
        F10: 121,
        HOME: 36,
        END: 35,
        PAGE_UP: 33,
        PAGE_DOWN: 34
      };

      function bindElementToEventValue(element, eventName, testValue, handler) {
        function localHandler(e) {
          if (e.which === testValue) {
            handler(e);
          }
        }

        element.addEventListener(eventName, localHandler);
        return function () {
          element.removeEventListener(eventName, localHandler);
        };
      }

      function bindElementToKeypressValue(element, testValue, handler) {
        return bindElementToEventValue(element, 'keypress', testValue, handler);
      }

      function bindElementToKeydownValue(element, testValue, handler) {
        return bindElementToEventValue(element, 'keydown', testValue, handler);
      }

      function onElementEnter(element, handler) {
        return bindElementToKeydownValue(element, KEYS.ENTER, handler);
      }

      function onElementEscape(element, handler) {
        return bindElementToKeydownValue(element, KEYS.ESCAPE, handler);
      }

      function onElementSpace(element, handler) {
        return bindElementToKeypressValue(element, KEYS.SPACE, handler);
      }

      function onElementLeft(element, handler) {
        return bindElementToKeydownValue(element, KEYS.LEFT, handler);
      }

      function onElementRight(element, handler) {
        return bindElementToKeydownValue(element, KEYS.RIGHT, handler);
      }

      function onElementUp(element, handler) {
        return bindElementToKeydownValue(element, KEYS.UP, handler);
      }

      function onElementDown(element, handler) {
        return bindElementToKeydownValue(element, KEYS.DOWN, handler);
      }

      function onElementHome(element, handler) {
        return bindElementToKeydownValue(element, KEYS.HOME, handler);
      }

      function onElementEnd(element, handler) {
        return bindElementToKeydownValue(element, KEYS.END, handler);
      }

      function onElementPageUp(element, handler) {
        return bindElementToKeydownValue(element, KEYS.PAGE_UP, handler);
      }

      function onElementPageDown(element, handler) {
        return bindElementToKeydownValue(element, KEYS.PAGE_DOWN, handler);
      }

      function onElementF10(element, handler) {
        return bindElementToKeydownValue(element, KEYS.F10, handler);
      }

      function isAlphaNumeric(charCode) {
        return charCode >= 48 && charCode <= 90 /* numbers, uppercase letters */
          || charCode >= 97 && charCode <= 122 /* lowercase letters */;
      }

      function onElementCharacter(element, handler) {
        function localHandler(e) {
          var charCode = e.which;
          if (isAlphaNumeric(charCode)) {
            handler(e);
          }
        }

        element.addEventListener('keypress', localHandler);
        return function () {
          element.removeEventListener('keypress', localHandler);
        };
      }

      function trapEnter(element) {
        onElementEnter(element, function (e) {
          e.stopPropagation();
          e.preventDefault();
        });
      }
      

In the @noclobberUtils section:

      /* Whitespace RegExp. */

      var whitespace = /\s+/;

      /**
       * Add `attr=val` without clobbering an existing value.
       * @param  {Element}  element [Element object]
       * @param  {String}   attr    [Attribute to update]
       * @param  {Array}    ids     [rest parameters of ids to add]
       */
      function noClobber(element, attr) {
        var current = element.getAttribute(attr);
        // if there is no value, just add the new one

        for (var _len = arguments.length, ids = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
          ids[_key - 2] = arguments[_key];
        }

        if (!current) {
          return element.setAttribute(attr, ids.join(' '));
        }

        // remove "extra" whitespace, then split by any whitespace
        var parts = current.trim().split(whitespace);

        ids.map(function (val) {
          if (!~parts.indexOf(val)) {
            parts.push(val);
          }
        });

        // set new val
        return element.setAttribute(attr, parts.join(' '));
      }