add umd module support in dist

Gruntfile.js

@@ -96,6 +96,24 @@ module.exports = function (grunt) {
         files: {
           '<%= concat.bootstrap.dest %>' : '<%= concat.bootstrap.dest %>'
         }
+      },
+      umd: {
+        options: {
+          modules: 'umd'
+        },
+        files: {
+          'dist/js/umd/util.js'      : 'js/src/util.js',
+          'dist/js/umd/alert.js'     : 'js/src/alert.js',
+          'dist/js/umd/button.js'    : 'js/src/button.js',
+          'dist/js/umd/carousel.js'  : 'js/src/carousel.js',
+          'dist/js/umd/collapse.js'  : 'js/src/collapse.js',
+          'dist/js/umd/dropdown.js'  : 'js/src/dropdown.js',
+          'dist/js/umd/modal.js'     : 'js/src/modal.js',
+          'dist/js/umd/scrollspy.js' : 'js/src/scrollspy.js',
+          'dist/js/umd/tab.js'       : 'js/src/tab.js',
+          'dist/js/umd/tooltip.js'   : 'js/src/tooltip.js',
+          'dist/js/umd/popover.js'   : 'js/src/popover.js'
+        }
       }
     },
 
@@ -457,8 +475,12 @@ module.exports = function (grunt) {
   // This can be overzealous, so its changes should always be manually reviewed!
   grunt.registerTask('change-version-number', 'sed');
 
-  grunt.registerTask('commonjs', 'Generate CommonJS entrypoint module in dist dir.', function () {
-    var srcFiles = grunt.config.get('concat.bootstrap.src');
+  grunt.registerTask('commonjs', ['babel:umd', 'npm-js']);
+
+  grunt.registerTask('npm-js', 'Generate npm-js entrypoint module in dist dir.', function () {
+    var srcFiles = Object.keys(grunt.config.get('babel.umd.files')).map(function (filename) {
+      return './' + path.join('umd', path.basename(filename))
+    })
     var destFilepath = 'dist/js/npm.js';
     generateCommonJSModule(grunt, srcFiles, destFilepath);
   });

dist/js/bootstrap.js

@@ -618,7 +618,7 @@ var Carousel = (function ($) {
         }
 
         if (this._config.interval && !this._isPaused) {
-          this._interval = setInterval(this.next.bind(this), this._config.interval);
+          this._interval = setInterval($.proxy(this.next, this), this._config.interval);
         }
       }
     }, {
@@ -658,11 +658,11 @@ var Carousel = (function ($) {
 
       value: function _addEventListeners() {
         if (this._config.keyboard) {
-          $(this._element).on('keydown.bs.carousel', this._keydown.bind(this));
+          $(this._element).on('keydown.bs.carousel', $.proxy(this._keydown, this));
         }
 
         if (this._config.pause == 'hover' && !('ontouchstart' in document.documentElement)) {
-          $(this._element).on('mouseenter.bs.carousel', this.pause.bind(this)).on('mouseleave.bs.carousel', this.cycle.bind(this));
+          $(this._element).on('mouseenter.bs.carousel', $.proxy(this.pause, this)).on('mouseleave.bs.carousel', $.proxy(this.cycle, this));
         }
       }
     }, {
@@ -1609,7 +1609,7 @@ var Modal = (function ($) {
         this._setEscapeEvent();
         this._setResizeEvent();
 
-        $(this._element).on(Event.DISMISS, Selector.DATA_DISMISS, this.hide.bind(this));
+        $(this._element).on(Event.DISMISS, Selector.DATA_DISMISS, $.proxy(this.hide, this));
 
         $(this._dialog).on(Event.MOUSEDOWN, function () {
           $(_this7._element).one(Event.MOUSEUP, function (event) {
@@ -1619,7 +1619,7 @@ var Modal = (function ($) {
           });
         });
 
-        this._showBackdrop(this._showElement.bind(this, relatedTarget));
+        this._showBackdrop($.proxy(this._showElement, this, relatedTarget));
       }
     }, {
       key: 'hide',
@@ -1650,7 +1650,7 @@ var Modal = (function ($) {
 
         if (Util.supportsTransitionEnd() && $(this._element).hasClass(ClassName.FADE)) {
 
-          $(this._element).one(Util.TRANSITION_END, this._hideModal.bind(this)).emulateTransitionEnd(TRANSITION_DURATION);
+          $(this._element).one(Util.TRANSITION_END, $.proxy(this._hideModal, this)).emulateTransitionEnd(TRANSITION_DURATION);
         } else {
           this._hideModal();
         }
@@ -1727,7 +1727,7 @@ var Modal = (function ($) {
       key: '_setResizeEvent',
       value: function _setResizeEvent() {
         if (this._isShown) {
-          $(window).on(Event.RESIZE, this._handleUpdate.bind(this));
+          $(window).on(Event.RESIZE, $.proxy(this._handleUpdate, this));
         } else {
           $(window).off(Event.RESIZE);
         }
@@ -2045,7 +2045,7 @@ var ScrollSpy = (function ($) {
       this._activeTarget = null;
       this._scrollHeight = 0;
 
-      $(this._scrollElement).on(Event.SCROLL, this._process.bind(this));
+      $(this._scrollElement).on(Event.SCROLL, $.proxy(this._process, this));
 
       this.refresh();
       this._process();
@@ -2385,7 +2385,7 @@ var Tab = (function ($) {
         var active = $(container).find(Selector.ACTIVE_CHILD)[0];
         var isTransitioning = callback && Util.supportsTransitionEnd() && (active && $(active).hasClass(ClassName.FADE) || !!$(container).find(Selector.FADE_CHILD)[0]);
 
-        var complete = this._transitionComplete.bind(this, element, active, isTransitioning, callback);
+        var complete = $.proxy(this._transitionComplete, this, element, active, isTransitioning, callback);
 
         if (active && isTransitioning) {
           $(active).one(Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
@@ -2846,12 +2846,12 @@ var Tooltip = (function ($) {
 
         triggers.forEach(function (trigger) {
           if (trigger === 'click') {
-            $(_this19.element).on(_this19.constructor.Event.CLICK, _this19.config.selector, _this19.toggle.bind(_this19));
+            $(_this19.element).on(_this19.constructor.Event.CLICK, _this19.config.selector, $.proxy(_this19.toggle, _this19));
           } else if (trigger !== Trigger.MANUAL) {
             var eventIn = trigger == Trigger.HOVER ? _this19.constructor.Event.MOUSEENTER : _this19.constructor.Event.FOCUSIN;
             var eventOut = trigger == Trigger.HOVER ? _this19.constructor.Event.MOUSELEAVE : _this19.constructor.Event.FOCUSOUT;
 
-            $(_this19.element).on(eventIn, _this19.config.selector, _this19._enter.bind(_this19)).on(eventOut, _this19.config.selector, _this19._leave.bind(_this19));
+            $(_this19.element).on(eventIn, _this19.config.selector, $.proxy(_this19._enter, _this19)).on(eventOut, _this19.config.selector, $.proxy(_this19._leave, _this19));
           }
         });
 

dist/js/npm.js

 // This file is autogenerated via the `commonjs` Grunt task. You can require() this file in a CommonJS environment.
-require('../../js/src/util.js')
-require('../../js/src/alert.js')
-require('../../js/src/button.js')
-require('../../js/src/carousel.js')
-require('../../js/src/collapse.js')
-require('../../js/src/dropdown.js')
-require('../../js/src/modal.js')
-require('../../js/src/scrollspy.js')
-require('../../js/src/tab.js')
-require('../../js/src/tooltip.js')
-require('../../js/src/popover.js')
+require('./umd/util.js')
+require('./umd/alert.js')
+require('./umd/button.js')
+require('./umd/carousel.js')
+require('./umd/collapse.js')
+require('./umd/dropdown.js')
+require('./umd/modal.js')
+require('./umd/scrollspy.js')
+require('./umd/tab.js')
+require('./umd/tooltip.js')
+require('./umd/popover.js')
\ No newline at end of file

dist/js/umd/alert.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module', './util'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module, require('./util'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod, global.Util);
+    global.alert = mod.exports;
+  }
+})(this, function (exports, module, _util) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  var _Util = _interopRequire(_util);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): alert.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var Alert = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'alert';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.alert';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+    var TRANSITION_DURATION = 150;
+
+    var Selector = {
+      DISMISS: '[data-dismiss="alert"]'
+    };
+
+    var Event = {
+      CLOSE: 'close.bs.alert',
+      CLOSED: 'closed.bs.alert',
+      CLICK: 'click.bs.alert.data-api'
+    };
+
+    var ClassName = {
+      ALERT: 'alert',
+      FADE: 'fade',
+      IN: 'in'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var Alert = (function () {
+      function Alert(element) {
+        _classCallCheck(this, Alert);
+
+        this._element = element;
+      }
+
+      _createClass(Alert, [{
+        key: 'close',
+
+        // public
+
+        value: function close(element) {
+          element = element || this._element;
+
+          var rootElement = this._getRootElement(element);
+          var customEvent = this._triggerCloseEvent(rootElement);
+
+          if (customEvent.isDefaultPrevented()) {
+            return;
+          }
+
+          this._removeElement(rootElement);
+        }
+      }, {
+        key: '_getRootElement',
+
+        // private
+
+        value: function _getRootElement(element) {
+          var parent = false;
+          var selector = _Util.getSelectorFromElement(element);
+
+          if (selector) {
+            parent = $(selector)[0];
+          }
+
+          if (!parent) {
+            parent = $(element).closest('.' + ClassName.ALERT)[0];
+          }
+
+          return parent;
+        }
+      }, {
+        key: '_triggerCloseEvent',
+        value: function _triggerCloseEvent(element) {
+          var closeEvent = $.Event(Event.CLOSE);
+          $(element).trigger(closeEvent);
+          return closeEvent;
+        }
+      }, {
+        key: '_removeElement',
+        value: function _removeElement(element) {
+          $(element).removeClass(ClassName.IN);
+
+          if (!_Util.supportsTransitionEnd() || !$(element).hasClass(ClassName.FADE)) {
+            this._destroyElement(element);
+            return;
+          }
+
+          $(element).one(_Util.TRANSITION_END, this._destroyElement.bind(this, element)).emulateTransitionEnd(TRANSITION_DURATION);
+        }
+      }, {
+        key: '_destroyElement',
+        value: function _destroyElement(element) {
+          $(element).detach().trigger(Event.CLOSED).remove();
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var $element = $(this);
+            var data = $element.data(DATA_KEY);
+
+            if (!data) {
+              data = new Alert(this);
+              $element.data(DATA_KEY, data);
+            }
+
+            if (config === 'close') {
+              data[config](this);
+            }
+          });
+        }
+      }, {
+        key: '_handleDismiss',
+        value: function _handleDismiss(alertInstance) {
+          return function (event) {
+            if (event) {
+              event.preventDefault();
+            }
+
+            alertInstance.close(this);
+          };
+        }
+      }]);
+
+      return Alert;
+    })();
+
+    /**
+     * ------------------------------------------------------------------------
+     * Data Api implementation
+     * ------------------------------------------------------------------------
+     */
+
+    $(document).on(Event.CLICK, Selector.DISMISS, Alert._handleDismiss(new Alert()));
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = Alert._jQueryInterface;
+    $.fn[NAME].Constructor = Alert;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return Alert._jQueryInterface;
+    };
+
+    return Alert;
+  })(jQuery);
+
+  module.exports = Alert;
+});
\ No newline at end of file

dist/js/umd/button.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod);
+    global.button = mod.exports;
+  }
+})(this, function (exports, module) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): button.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var Button = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'button';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.button';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+    var TRANSITION_DURATION = 150;
+
+    var ClassName = {
+      ACTIVE: 'active',
+      BUTTON: 'btn',
+      FOCUS: 'focus'
+    };
+
+    var Selector = {
+      DATA_TOGGLE_CARROT: '[data-toggle^="button"]',
+      DATA_TOGGLE: '[data-toggle="buttons"]',
+      INPUT: 'input',
+      ACTIVE: '.active',
+      BUTTON: '.btn'
+    };
+
+    var Event = {
+      CLICK: 'click.bs.button.data-api',
+      FOCUS_BLUR: 'focus.bs.button.data-api blur.bs.button.data-api'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var Button = (function () {
+      function Button(element) {
+        _classCallCheck(this, Button);
+
+        this._element = element;
+      }
+
+      _createClass(Button, [{
+        key: 'toggle',
+
+        // public
+
+        value: function toggle() {
+          var triggerChangeEvent = true;
+          var rootElement = $(this._element).closest(Selector.DATA_TOGGLE)[0];
+
+          if (rootElement) {
+            var input = $(this._element).find(Selector.INPUT)[0];
+
+            if (input) {
+              if (input.type === 'radio') {
+                if (input.checked && $(this._element).hasClass(ClassName.ACTIVE)) {
+                  triggerChangeEvent = false;
+                } else {
+                  var activeElement = $(rootElement).find(Selector.ACTIVE)[0];
+
+                  if (activeElement) {
+                    $(activeElement).removeClass(ClassName.ACTIVE);
+                  }
+                }
+              }
+
+              if (triggerChangeEvent) {
+                input.checked = !$(this._element).hasClass(ClassName.ACTIVE);
+                $(this._element).trigger('change');
+              }
+            }
+          } else {
+            this._element.setAttribute('aria-pressed', !$(this._element).hasClass(ClassName.ACTIVE));
+          }
+
+          if (triggerChangeEvent) {
+            $(this._element).toggleClass(ClassName.ACTIVE);
+          }
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var data = $(this).data(DATA_KEY);
+
+            if (!data) {
+              data = new Button(this);
+              $(this).data(DATA_KEY, data);
+            }
+
+            if (config === 'toggle') {
+              data[config]();
+            }
+          });
+        }
+      }]);
+
+      return Button;
+    })();
+
+    /**
+     * ------------------------------------------------------------------------
+     * Data Api implementation
+     * ------------------------------------------------------------------------
+     */
+
+    $(document).on(Event.CLICK, Selector.DATA_TOGGLE_CARROT, function (event) {
+      event.preventDefault();
+
+      var button = event.target;
+
+      if (!$(button).hasClass(ClassName.BUTTON)) {
+        button = $(button).closest(Selector.BUTTON);
+      }
+
+      Button._jQueryInterface.call($(button), 'toggle');
+    }).on(Event.FOCUS_BLUR, Selector.DATA_TOGGLE_CARROT, function (event) {
+      var button = $(event.target).closest(Selector.BUTTON)[0];
+      $(button).toggleClass(ClassName.FOCUS, /^focus(in)?$/.test(event.type));
+    });
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = Button._jQueryInterface;
+    $.fn[NAME].Constructor = Button;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return Button._jQueryInterface;
+    };
+
+    return Button;
+  })(jQuery);
+
+  module.exports = Button;
+});
\ No newline at end of file

dist/js/umd/dropdown.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module', './util'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module, require('./util'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod, global.Util);
+    global.dropdown = mod.exports;
+  }
+})(this, function (exports, module, _util) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  var _Util = _interopRequire(_util);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): dropdown.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var Dropdown = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'dropdown';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.dropdown';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+
+    var Event = {
+      HIDE: 'hide.bs.dropdown',
+      HIDDEN: 'hidden.bs.dropdown',
+      SHOW: 'show.bs.dropdown',
+      SHOWN: 'shown.bs.dropdown',
+      CLICK: 'click.bs.dropdown',
+      KEYDOWN: 'keydown.bs.dropdown.data-api',
+      CLICK_DATA: 'click.bs.dropdown.data-api'
+    };
+
+    var ClassName = {
+      BACKDROP: 'dropdown-backdrop',
+      DISABLED: 'disabled',
+      OPEN: 'open'
+    };
+
+    var Selector = {
+      BACKDROP: '.dropdown-backdrop',
+      DATA_TOGGLE: '[data-toggle="dropdown"]',
+      FORM_CHILD: '.dropdown form',
+      ROLE_MENU: '[role="menu"]',
+      ROLE_LISTBOX: '[role="listbox"]',
+      NAVBAR_NAV: '.navbar-nav',
+      VISIBLE_ITEMS: '[role="menu"] li:not(.disabled) a, ' + '[role="listbox"] li:not(.disabled) a'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var Dropdown = (function () {
+      function Dropdown(element) {
+        _classCallCheck(this, Dropdown);
+
+        $(element).on(Event.CLICK, this.toggle);
+      }
+
+      _createClass(Dropdown, [{
+        key: 'toggle',
+
+        // public
+
+        value: function toggle() {
+          if (this.disabled || $(this).hasClass(ClassName.DISABLED)) {
+            return;
+          }
+
+          var parent = Dropdown._getParentFromElement(this);
+          var isActive = $(parent).hasClass(ClassName.OPEN);
+
+          Dropdown._clearMenus();
+
+          if (isActive) {
+            return false;
+          }
+
+          if ('ontouchstart' in document.documentElement && !$(parent).closest(Selector.NAVBAR_NAV).length) {
+
+            // if mobile we use a backdrop because click events don't delegate
+            var dropdown = document.createElement('div');
+            dropdown.className = ClassName.BACKDROP;
+            $(dropdown).insertBefore(this);
+            $(dropdown).on('click', Dropdown._clearMenus);
+          }
+
+          var relatedTarget = { relatedTarget: this };
+          var showEvent = $.Event(Event.SHOW, relatedTarget);
+
+          $(parent).trigger(showEvent);
+
+          if (showEvent.isDefaultPrevented()) {
+            return;
+          }
+
+          this.focus();
+          this.setAttribute('aria-expanded', 'true');
+
+          $(parent).toggleClass(ClassName.OPEN);
+          $(parent).trigger(Event.SHOWN, relatedTarget);
+
+          return false;
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var data = $(this).data(DATA_KEY);
+
+            if (!data) {
+              $(this).data(DATA_KEY, data = new Dropdown(this));
+            }
+
+            if (typeof config === 'string') {
+              data[config].call(this);
+            }
+          });
+        }
+      }, {
+        key: '_clearMenus',
+        value: function _clearMenus(event) {
+          if (event && event.which === 3) {
+            return;
+          }
+
+          var backdrop = $(Selector.BACKDROP)[0];
+          if (backdrop) {
+            backdrop.parentNode.removeChild(backdrop);
+          }
+
+          var toggles = $.makeArray($(Selector.DATA_TOGGLE));
+
+          for (var i = 0; i < toggles.length; i++) {
+            var _parent = Dropdown._getParentFromElement(toggles[i]);
+            var relatedTarget = { relatedTarget: toggles[i] };
+
+            if (!$(_parent).hasClass(ClassName.OPEN)) {
+              continue;
+            }
+
+            if (event && event.type === 'click' && /input|textarea/i.test(event.target.tagName) && $.contains(_parent, event.target)) {
+              continue;
+            }
+
+            var hideEvent = $.Event(Event.HIDE, relatedTarget);
+            $(_parent).trigger(hideEvent);
+            if (hideEvent.isDefaultPrevented()) {
+              continue;
+            }
+
+            toggles[i].setAttribute('aria-expanded', 'false');
+
+            $(_parent).removeClass(ClassName.OPEN).trigger(Event.HIDDEN, relatedTarget);
+          }
+        }
+      }, {
+        key: '_getParentFromElement',
+        value: function _getParentFromElement(element) {
+          var parent = undefined;
+          var selector = _Util.getSelectorFromElement(element);
+
+          if (selector) {
+            parent = $(selector)[0];
+          }
+
+          return parent || element.parentNode;
+        }
+      }, {
+        key: '_dataApiKeydownHandler',
+        value: function _dataApiKeydownHandler(event) {
+          if (!/(38|40|27|32)/.test(event.which) || /input|textarea/i.test(event.target.tagName)) {
+            return;
+          }
+
+          event.preventDefault();
+          event.stopPropagation();
+
+          if (this.disabled || $(this).hasClass(ClassName.DISABLED)) {
+            return;
+          }
+
+          var parent = Dropdown._getParentFromElement(this);
+          var isActive = $(parent).hasClass(ClassName.OPEN);
+
+          if (!isActive && event.which !== 27 || isActive && event.which === 27) {
+
+            if (event.which === 27) {
+              var toggle = $(parent).find(Selector.DATA_TOGGLE)[0];
+              $(toggle).trigger('focus');
+            }
+
+            $(this).trigger('click');
+            return;
+          }
+
+          var items = $.makeArray($(Selector.VISIBLE_ITEMS));
+
+          items = items.filter(function (item) {
+            return item.offsetWidth || item.offsetHeight;
+          });
+
+          if (!items.length) {
+            return;
+          }
+
+          var index = items.indexOf(event.target);
+
+          if (event.which === 38 && index > 0) index--; // up
+          if (event.which === 40 && index < items.length - 1) index++; // down
+          if (! ~index) index = 0;
+
+          items[index].focus();
+        }
+      }]);
+
+      return Dropdown;
+    })();
+
+    /**
+     * ------------------------------------------------------------------------
+     * Data Api implementation
+     * ------------------------------------------------------------------------
+     */
+
+    $(document).on(Event.KEYDOWN, Selector.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN, Selector.ROLE_MENU, Dropdown._dataApiKeydownHandler).on(Event.KEYDOWN, Selector.ROLE_LISTBOX, Dropdown._dataApiKeydownHandler).on(Event.CLICK_DATA, Dropdown._clearMenus).on(Event.CLICK_DATA, Selector.DATA_TOGGLE, Dropdown.prototype.toggle).on(Event.CLICK_DATA, Selector.FORM_CHILD, function (e) {
+      e.stopPropagation();
+    });
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = Dropdown._jQueryInterface;
+    $.fn[NAME].Constructor = Dropdown;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return Dropdown._jQueryInterface;
+    };
+
+    return Dropdown;
+  })(jQuery);
+
+  module.exports = Dropdown;
+});
\ No newline at end of file

dist/js/umd/popover.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module', './tooltip'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module, require('./tooltip'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod, global.Tooltip);
+    global.popover = mod.exports;
+  }
+})(this, function (exports, module, _tooltip) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) subClass.__proto__ = superClass; }
+
+  var _Tooltip2 = _interopRequire(_tooltip);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): popover.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var Popover = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'popover';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.popover';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+
+    var Default = $.extend({}, _Tooltip2.Default, {
+      placement: 'right',
+      trigger: 'click',
+      content: '',
+      template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-title"></h3>' + '<div class="popover-content"></div></div>'
+    });
+
+    var ClassName = {
+      FADE: 'fade',
+      IN: 'in'
+    };
+
+    var Selector = {
+      TITLE: '.popover-title',
+      CONTENT: '.popover-content',
+      ARROW: '.popover-arrow'
+    };
+
+    var Event = {
+      HIDE: 'hide.bs.popover',
+      HIDDEN: 'hidden.bs.popover',
+      SHOW: 'show.bs.popover',
+      SHOWN: 'shown.bs.popover',
+      INSERTED: 'inserted.bs.popover',
+      CLICK: 'click.bs.popover',
+      FOCUSIN: 'focusin.bs.popover',
+      FOCUSOUT: 'focusout.bs.popover',
+      MOUSEENTER: 'mouseenter.bs.popover',
+      MOUSELEAVE: 'mouseleave.bs.popover'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var Popover = (function (_Tooltip) {
+      function Popover() {
+        _classCallCheck(this, Popover);
+
+        if (_Tooltip != null) {
+          _Tooltip.apply(this, arguments);
+        }
+      }
+
+      _inherits(Popover, _Tooltip);
+
+      _createClass(Popover, [{
+        key: 'isWithContent',
+
+        // overrides
+
+        value: function isWithContent() {
+          return this.getTitle() || this._getContent();
+        }
+      }, {
+        key: 'getTipElement',
+        value: function getTipElement() {
+          return this.tip = this.tip || $(this.config.template)[0];
+        }
+      }, {
+        key: 'setContent',
+        value: function setContent() {
+          var tip = this.getTipElement();
+          var title = this.getTitle();
+          var content = this._getContent();
+          var titleElement = $(tip).find(Selector.TITLE)[0];
+
+          if (titleElement) {
+            titleElement[this.config.html ? 'innerHTML' : 'innerText'] = title;
+          }
+
+          // we use append for html objects to maintain js events
+          $(tip).find(Selector.CONTENT).children().detach().end()[this.config.html ? typeof content === 'string' ? 'html' : 'append' : 'text'](content);
+
+          $(tip).removeClass(ClassName.FADE).removeClass(ClassName.IN);
+
+          this.cleanupTether();
+        }
+      }, {
+        key: '_getContent',
+
+        // private
+
+        value: function _getContent() {
+          return this.element.getAttribute('data-content') || (typeof this.config.content == 'function' ? this.config.content.call(this.element) : this.config.content);
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: 'Default',
+        get: function () {
+          return Default;
+        }
+      }, {
+        key: 'NAME',
+        get: function () {
+          return NAME;
+        }
+      }, {
+        key: 'DATA_KEY',
+        get: function () {
+          return DATA_KEY;
+        }
+      }, {
+        key: 'Event',
+        get: function () {
+          return Event;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var data = $(this).data(DATA_KEY);
+            var _config = typeof config === 'object' ? config : null;
+
+            if (!data && /destroy|hide/.test(config)) {
+              return;
+            }
+
+            if (!data) {
+              data = new Popover(this, _config);
+              $(this).data(DATA_KEY, data);
+            }
+
+            if (typeof config === 'string') {
+              data[config]();
+            }
+          });
+        }
+      }]);
+
+      return Popover;
+    })(_Tooltip2);
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = Popover._jQueryInterface;
+    $.fn[NAME].Constructor = Popover;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return Popover._jQueryInterface;
+    };
+
+    return Popover;
+  })(jQuery);
+
+  module.exports = Popover;
+});
\ No newline at end of file

dist/js/umd/scrollspy.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module', './util'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module, require('./util'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod, global.Util);
+    global.scrollspy = mod.exports;
+  }
+})(this, function (exports, module, _util) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  var _Util = _interopRequire(_util);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): scrollspy.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var ScrollSpy = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'scrollspy';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.scrollspy';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+
+    var Default = {
+      offset: 10
+    };
+
+    var Event = {
+      ACTIVATE: 'activate.bs.scrollspy',
+      SCROLL: 'scroll.bs.scrollspy',
+      LOAD: 'load.bs.scrollspy.data-api'
+    };
+
+    var ClassName = {
+      DROPDOWN_MENU: 'dropdown-menu',
+      ACTIVE: 'active'
+    };
+
+    var Selector = {
+      DATA_SPY: '[data-spy="scroll"]',
+      ACTIVE: '.active',
+      LI_DROPDOWN: 'li.dropdown',
+      LI: 'li'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var ScrollSpy = (function () {
+      function ScrollSpy(element, config) {
+        _classCallCheck(this, ScrollSpy);
+
+        this._scrollElement = element.tagName === 'BODY' ? window : element;
+        this._config = $.extend({}, Default, config);
+        this._selector = '' + (this._config.target || '') + ' .nav li > a';
+        this._offsets = [];
+        this._targets = [];
+        this._activeTarget = null;
+        this._scrollHeight = 0;
+
+        $(this._scrollElement).on(Event.SCROLL, $.proxy(this._process, this));
+
+        this.refresh();
+        this._process();
+      }
+
+      _createClass(ScrollSpy, [{
+        key: 'refresh',
+
+        // public
+
+        value: function refresh() {
+          var _this = this;
+
+          var offsetMethod = 'offset';
+          var offsetBase = 0;
+
+          if (this._scrollElement !== this._scrollElement.window) {
+            offsetMethod = 'position';
+            offsetBase = this._getScrollTop();
+          }
+
+          this._offsets = [];
+          this._targets = [];
+
+          this._scrollHeight = this._getScrollHeight();
+
+          var targets = $.makeArray($(this._selector));
+
+          targets.map(function (element) {
+            var target = undefined;
+            var targetSelector = _Util.getSelectorFromElement(element);
+
+            if (targetSelector) {
+              target = $(targetSelector)[0];
+            }
+
+            if (target && (target.offsetWidth || target.offsetHeight)) {
+              // todo (fat): remove sketch reliance on jQuery position/offset
+              return [$(target)[offsetMethod]().top + offsetBase, targetSelector];
+            }
+          }).filter(function (item) {
+            return item;
+          }).sort(function (a, b) {
+            return a[0] - b[0];
+          }).forEach(function (item) {
+            _this._offsets.push(item[0]);
+            _this._targets.push(item[1]);
+          });
+        }
+      }, {
+        key: '_getScrollTop',
+
+        // private
+
+        value: function _getScrollTop() {
+          return this._scrollElement === window ? this._scrollElement.scrollY : this._scrollElement.scrollTop;
+        }
+      }, {
+        key: '_getScrollHeight',
+        value: function _getScrollHeight() {
+          return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight);
+        }
+      }, {
+        key: '_process',
+        value: function _process() {
+          var scrollTop = this._getScrollTop() + this._config.offset;
+          var scrollHeight = this._getScrollHeight();
+          var maxScroll = this._config.offset + scrollHeight - this._scrollElement.offsetHeight;
+
+          if (this._scrollHeight !== scrollHeight) {
+            this.refresh();
+          }
+
+          if (scrollTop >= maxScroll) {
+            var target = this._targets[this._targets.length - 1];
+
+            if (this._activeTarget !== target) {
+              this._activate(target);
+            }
+          }
+
+          if (this._activeTarget && scrollTop < this._offsets[0]) {
+            this._activeTarget = null;
+            this._clear();
+            return;
+          }
+
+          for (var i = this._offsets.length; i--;) {
+            var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (this._offsets[i + 1] === undefined || scrollTop < this._offsets[i + 1]);
+
+            if (isActiveTarget) {
+              this._activate(this._targets[i]);
+            }
+          }
+        }
+      }, {
+        key: '_activate',
+        value: function _activate(target) {
+          this._activeTarget = target;
+
+          this._clear();
+
+          var selector = '' + this._selector + '[data-target="' + target + '"],' + ('' + this._selector + '[href="' + target + '"]');
+
+          // todo (fat): getting all the raw li's up the tree is not great.
+          var parentListItems = $(selector).parents(Selector.LI);
+
+          for (var i = parentListItems.length; i--;) {
+            $(parentListItems[i]).addClass(ClassName.ACTIVE);
+
+            var itemParent = parentListItems[i].parentNode;
+
+            if (itemParent && $(itemParent).hasClass(ClassName.DROPDOWN_MENU)) {
+              var closestDropdown = $(itemParent).closest(Selector.LI_DROPDOWN)[0];
+              $(closestDropdown).addClass(ClassName.ACTIVE);
+            }
+          }
+
+          $(this._scrollElement).trigger(Event.ACTIVATE, {
+            relatedTarget: target
+          });
+        }
+      }, {
+        key: '_clear',
+        value: function _clear() {
+          var activeParents = $(this._selector).parentsUntil(this._config.target, Selector.ACTIVE);
+
+          for (var i = activeParents.length; i--;) {
+            $(activeParents[i]).removeClass(ClassName.ACTIVE);
+          }
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: 'Default',
+        get: function () {
+          return Default;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var data = $(this).data(DATA_KEY);
+            var _config = typeof config === 'object' && config || null;
+
+            if (!data) {
+              data = new ScrollSpy(this, _config);
+              $(this).data(DATA_KEY, data);
+            }
+
+            if (typeof config === 'string') {
+              data[config]();
+            }
+          });
+        }
+      }]);
+
+      return ScrollSpy;
+    })();
+
+    /**
+     * ------------------------------------------------------------------------
+     * Data Api implementation
+     * ------------------------------------------------------------------------
+     */
+
+    $(window).on(Event.LOAD, function () {
+      var scrollSpys = $.makeArray($(Selector.DATA_SPY));
+
+      for (var i = scrollSpys.length; i--;) {
+        var $spy = $(scrollSpys[i]);
+        ScrollSpy._jQueryInterface.call($spy, $spy.data());
+      }
+    });
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = ScrollSpy._jQueryInterface;
+    $.fn[NAME].Constructor = ScrollSpy;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return ScrollSpy._jQueryInterface;
+    };
+
+    return ScrollSpy;
+  })(jQuery);
+
+  module.exports = ScrollSpy;
+});
\ No newline at end of file

dist/js/umd/tab.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module', './util'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module, require('./util'));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod, global.Util);
+    global.tab = mod.exports;
+  }
+})(this, function (exports, module, _util) {
+  'use strict';
+
+  var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
+
+  function _interopRequire(obj) { return obj && obj.__esModule ? obj['default'] : obj; }
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
+
+  var _Util = _interopRequire(_util);
+
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): tab.js
+   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+   * --------------------------------------------------------------------------
+   */
+
+  var Tab = (function ($) {
+
+    /**
+     * ------------------------------------------------------------------------
+     * Constants
+     * ------------------------------------------------------------------------
+     */
+
+    var NAME = 'tab';
+    var VERSION = '4.0.0';
+    var DATA_KEY = 'bs.tab';
+    var JQUERY_NO_CONFLICT = $.fn[NAME];
+    var TRANSITION_DURATION = 150;
+
+    var Event = {
+      HIDE: 'hide.bs.tab',
+      HIDDEN: 'hidden.bs.tab',
+      SHOW: 'show.bs.tab',
+      SHOWN: 'shown.bs.tab',
+      CLICK: 'click.bs.tab.data-api'
+    };
+
+    var ClassName = {
+      DROPDOWN_MENU: 'dropdown-menu',
+      ACTIVE: 'active',
+      FADE: 'fade',
+      IN: 'in'
+    };
+
+    var Selector = {
+      A: 'a',
+      LI: 'li',
+      LI_DROPDOWN: 'li.dropdown',
+      UL: 'ul:not(.dropdown-menu)',
+      FADE_CHILD: '> .fade',
+      ACTIVE: '.active',
+      ACTIVE_CHILD: '> .active',
+      DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"]',
+      DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu > .active'
+    };
+
+    /**
+     * ------------------------------------------------------------------------
+     * Class Definition
+     * ------------------------------------------------------------------------
+     */
+
+    var Tab = (function () {
+      function Tab(element) {
+        _classCallCheck(this, Tab);
+
+        this._element = element;
+      }
+
+      _createClass(Tab, [{
+        key: 'show',
+
+        // public
+
+        value: function show() {
+          var _this = this;
+
+          if (this._element.parentNode && this._element.parentNode.nodeType == Node.ELEMENT_NODE && $(this._element).parent().hasClass(ClassName.ACTIVE)) {
+            return;
+          }
+
+          var target = undefined;
+          var previous = undefined;
+          var ulElement = $(this._element).closest(Selector.UL)[0];
+          var selector = _Util.getSelectorFromElement(this._element);
+
+          if (ulElement) {
+            previous = $.makeArray($(ulElement).find(Selector.ACTIVE));
+            previous = previous[previous.length - 1];
+
+            if (previous) {
+              previous = $(previous).find(Selector.A)[0];
+            }
+          }
+
+          var hideEvent = $.Event(Event.HIDE, {
+            relatedTarget: this._element
+          });
+
+          var showEvent = $.Event(Event.SHOW, {
+            relatedTarget: previous
+          });
+
+          if (previous) {
+            $(previous).trigger(hideEvent);
+          }
+
+          $(this._element).trigger(showEvent);
+
+          if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) {
+            return;
+          }
+
+          if (selector) {
+            target = $(selector)[0];
+          }
+
+          this._activate($(this._element).closest(Selector.LI)[0], ulElement);
+
+          var complete = function complete() {
+            var hiddenEvent = $.Event(Event.HIDDEN, {
+              relatedTarget: _this._element
+            });
+
+            var shownEvent = $.Event(Event.SHOWN, {
+              relatedTarget: previous
+            });
+
+            $(previous).trigger(hiddenEvent);
+            $(_this._element).trigger(shownEvent);
+          };
+
+          if (target) {
+            this._activate(target, target.parentNode, complete);
+          } else {
+            complete();
+          }
+        }
+      }, {
+        key: '_activate',
+
+        // private
+
+        value: function _activate(element, container, callback) {
+          var active = $(container).find(Selector.ACTIVE_CHILD)[0];
+          var isTransitioning = callback && _Util.supportsTransitionEnd() && (active && $(active).hasClass(ClassName.FADE) || !!$(container).find(Selector.FADE_CHILD)[0]);
+
+          var complete = $.proxy(this._transitionComplete, this, element, active, isTransitioning, callback);
+
+          if (active && isTransitioning) {
+            $(active).one(_Util.TRANSITION_END, complete).emulateTransitionEnd(TRANSITION_DURATION);
+          } else {
+            complete();
+          }
+
+          if (active) {
+            $(active).removeClass(ClassName.IN);
+          }
+        }
+      }, {
+        key: '_transitionComplete',
+        value: function _transitionComplete(element, active, isTransitioning, callback) {
+          if (active) {
+            $(active).removeClass(ClassName.ACTIVE);
+
+            var dropdownChild = $(active).find(Selector.DROPDOWN_ACTIVE_CHILD)[0];
+            if (dropdownChild) {
+              $(dropdownChild).removeClass(ClassName.ACTIVE);
+            }
+
+            var activeToggle = $(active).find(Selector.DATA_TOGGLE)[0];
+            if (activeToggle) {
+              activeToggle.setAttribute('aria-expanded', false);
+            }
+          }
+
+          $(element).addClass(ClassName.ACTIVE);
+
+          var elementToggle = $(element).find(Selector.DATA_TOGGLE)[0];
+          if (elementToggle) {
+            elementToggle.setAttribute('aria-expanded', true);
+          }
+
+          if (isTransitioning) {
+            _Util.reflow(element);
+            $(element).addClass(ClassName.IN);
+          } else {
+            $(element).removeClass(ClassName.FADE);
+          }
+
+          if (element.parentNode && $(element.parentNode).hasClass(ClassName.DROPDOWN_MENU)) {
+
+            var dropdownElement = $(element).closest(Selector.LI_DROPDOWN)[0];
+            if (dropdownElement) {
+              $(dropdownElement).addClass(ClassName.ACTIVE);
+            }
+
+            elementToggle = $(element).find(Selector.DATA_TOGGLE)[0];
+            if (elementToggle) {
+              elementToggle.setAttribute('aria-expanded', true);
+            }
+          }
+
+          if (callback) {
+            callback();
+          }
+        }
+      }], [{
+        key: 'VERSION',
+
+        // getters
+
+        get: function () {
+          return VERSION;
+        }
+      }, {
+        key: 'Default',
+        get: function () {
+          return Default;
+        }
+      }, {
+        key: '_jQueryInterface',
+
+        // static
+
+        value: function _jQueryInterface(config) {
+          return this.each(function () {
+            var $this = $(this);
+            var data = $this.data(DATA_KEY);
+
+            if (!data) {
+              data = data = new Tab(this);
+              $this.data(DATA_KEY, data);
+            }
+
+            if (typeof config === 'string') {
+              data[config]();
+            }
+          });
+        }
+      }]);
+
+      return Tab;
+    })();
+
+    /**
+     * ------------------------------------------------------------------------
+     * Data Api implementation
+     * ------------------------------------------------------------------------
+     */
+
+    $(document).on(Event.CLICK, Selector.DATA_TOGGLE, function (event) {
+      event.preventDefault();
+      Tab._jQueryInterface.call($(this), 'show');
+    });
+
+    /**
+     * ------------------------------------------------------------------------
+     * jQuery
+     * ------------------------------------------------------------------------
+     */
+
+    $.fn[NAME] = Tab._jQueryInterface;
+    $.fn[NAME].Constructor = Tab;
+    $.fn[NAME].noConflict = function () {
+      $.fn[NAME] = JQUERY_NO_CONFLICT;
+      return Tab._jQueryInterface;
+    };
+
+    return Tab;
+  })(jQuery);
+
+  module.exports = Tab;
+});
\ No newline at end of file

dist/js/umd/util.js

+(function (global, factory) {
+  if (typeof define === 'function' && define.amd) {
+    define(['exports', 'module'], factory);
+  } else if (typeof exports !== 'undefined' && typeof module !== 'undefined') {
+    factory(exports, module);
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, mod);
+    global.util = mod.exports;
+  }
+})(this, function (exports, module) {
+  /**
+   * --------------------------------------------------------------------------
+   * Bootstrap (v4.0.0): 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 TransitionEndEvent = {
+      WebkitTransition: 'webkitTransitionEnd',
+      MozTransition: 'transitionend',
+      OTransition: 'oTransitionEnd otransitionend',
+      transition: 'transitionend'
+    };
+
+    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);
+          }
+        }
+      };
+    }
+
+    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 prefix += ~ ~(Math.random() * 1000000); 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 !!transition;
+      }
+
+    };
+
+    setTransitionEndSupport();
+
+    return Util;
+  })(jQuery);
+
+  module.exports = Util;
+});
\ No newline at end of file

grunt/bs-commonjs-generator.js

@@ -9,8 +9,7 @@ module.exports = function generateCommonJSModule(grunt, srcFiles, destFilepath)
   var destDir = path.dirname(destFilepath);
 
   function srcPathToDestRequire(srcFilepath) {
-    var requirePath = path.relative(destDir, srcFilepath).replace(/\\/g, '/');
-    return 'require(\'' + requirePath + '\')';
+    return 'require(\'' + srcFilepath + '\')';
   }
 
   var moduleOutputJs = COMMONJS_BANNER + srcFiles.map(srcPathToDestRequire).join('\n');