text: /**
   * --------------------------------------------------------------------------
   * Bootstrap (v4.0.0-alpha.2): util.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  'use strict';
  
  var Util = (function ($) {
  
    /**
     * ------------------------------------------------------------------------
     * Private TransitionEnd Helpers
     * ------------------------------------------------------------------------
     */
  
    var transition = false;
  
    var MAX_UID = 1000000;
  
    var TransitionEndEvent = {
      WebkitTransition: 'webkitTransitionEnd',
      MozTransition: 'transitionend',
      OTransition: 'oTransitionEnd otransitionend',
      transition: 'transitionend'
    };
  
    // shoutout AngusCroll (https://goo.gl/pxwQGp)
    function toType(obj) {
      return ({}).toString.call(obj).match(/\s([a-zA-Z]+)/)[1].toLowerCase();
    }
  
    function isElement(obj) {
      return (obj[0] || obj).nodeType;
    }
  
    function getSpecialTransitionEndEvent() {
      return {
        bindType: transition.end,
        delegateType: transition.end,
        handle: function handle(event) {
          if ($(event.target).is(this)) {
            return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params
          }
          return undefined;
        }
      };
    }
  
    function transitionEndTest() {
      if (window.QUnit) {
        return false;
      }
  
      var el = document.createElement('bootstrap');
  
      for (var _name in TransitionEndEvent) {
        if (el.style[_name] !== undefined) {
          return { end: TransitionEndEvent[_name] };
        }
      }
  
      return false;
    }
  
    function transitionEndEmulator(duration) {
      var _this = this;
  
      var called = false;
  
      $(this).one(Util.TRANSITION_END, function () {
        called = true;
      });
  
      setTimeout(function () {
        if (!called) {
          Util.triggerTransitionEnd(_this);
        }
      }, duration);
  
      return this;
    }
  
    function setTransitionEndSupport() {
      transition = transitionEndTest();
  
      $.fn.emulateTransitionEnd = transitionEndEmulator;
  
      if (Util.supportsTransitionEnd()) {
        $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent();
      }
    }
  
    /**
     * --------------------------------------------------------------------------
     * Public Util Api
     * --------------------------------------------------------------------------
     */
  
    var Util = {
  
      TRANSITION_END: 'bsTransitionEnd',
  
      getUID: function getUID(prefix) {
        do {
          /* eslint-disable no-bitwise */
          prefix += ~ ~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here
          /* eslint-enable no-bitwise */
        } while (document.getElementById(prefix));
        return prefix;
      },
  
      getSelectorFromElement: function getSelectorFromElement(element) {
        var selector = element.getAttribute('data-target');
  
        if (!selector) {
          selector = element.getAttribute('href') || '';
          selector = /^#[a-z]/i.test(selector) ? selector : null;
        }
  
        return selector;
      },
  
      reflow: function reflow(element) {
        new Function('bs', 'return bs')(element.offsetHeight);
      },
  
      triggerTransitionEnd: function triggerTransitionEnd(element) {
        $(element).trigger(transition.end);
      },
  
      supportsTransitionEnd: function supportsTransitionEnd() {
        return Boolean(transition);
      },
  
      typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) {
        for (var property in configTypes) {
          if (configTypes.hasOwnProperty(property)) {
            var expectedTypes = configTypes[property];
            var value = config[property];
            var valueType = undefined;
  
            if (value && isElement(value)) {
              valueType = 'element';
            } else {
              valueType = toType(value);
            }
  
            if (!new RegExp(expectedTypes).test(valueType)) {
              throw new Error(componentName.toUpperCase() + ': ' + ('Option "' + property + '" provided type "' + valueType + '" ') + ('but expected type "' + expectedTypes + '".'));
            }
          }
        }
      }
    };
  
    setTransitionEndSupport();
  
    return Util;
  })(jQuery);
  //# sourceMappingURL=util.js.map
  