bootstrap 5.2.3 → 5.3.1

data/assets/javascripts/bootstrap/carousel.js

@@ -1,28 +1,22 @@
 /*!
-  * Bootstrap carousel.js v5.2.3 (https://getbootstrap.com/)
-  * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
+  * Bootstrap carousel.js v5.3.1 (https://getbootstrap.com/)
+  * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   */
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('./util/index'), require('./dom/event-handler'), require('./dom/manipulator'), require('./dom/selector-engine'), require('./util/swipe'), require('./base-component')) :
-  typeof define === 'function' && define.amd ? define(['./util/index', './dom/event-handler', './dom/manipulator', './dom/selector-engine', './util/swipe', './base-component'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Carousel = factory(global.Index, global.EventHandler, global.Manipulator, global.SelectorEngine, global.Swipe, global.BaseComponent));
-})(this, (function (index, EventHandler, Manipulator, SelectorEngine, Swipe, BaseComponent) { 'use strict';
-
-  const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e };
-
-  const EventHandler__default = /*#__PURE__*/_interopDefaultLegacy(EventHandler);
-  const Manipulator__default = /*#__PURE__*/_interopDefaultLegacy(Manipulator);
-  const SelectorEngine__default = /*#__PURE__*/_interopDefaultLegacy(SelectorEngine);
-  const Swipe__default = /*#__PURE__*/_interopDefaultLegacy(Swipe);
-  const BaseComponent__default = /*#__PURE__*/_interopDefaultLegacy(BaseComponent);
+  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('./base-component.js'), require('./dom/event-handler.js'), require('./dom/manipulator.js'), require('./dom/selector-engine.js'), require('./util/index.js'), require('./util/swipe.js')) :
+  typeof define === 'function' && define.amd ? define(['./base-component', './dom/event-handler', './dom/manipulator', './dom/selector-engine', './util/index', './util/swipe'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Carousel = factory(global.BaseComponent, global.EventHandler, global.Manipulator, global.SelectorEngine, global.Index, global.Swipe));
+})(this, (function (BaseComponent, EventHandler, Manipulator, SelectorEngine, index_js, Swipe) { 'use strict';
 
   /**
    * --------------------------------------------------------------------------
-   * Bootstrap (v5.2.3): carousel.js
+   * Bootstrap carousel.js
    * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
    * --------------------------------------------------------------------------
    */
+
+
   /**
    * Constants
    */
@@ -82,11 +76,12 @@
     touch: 'boolean',
     wrap: 'boolean'
   };
+
   /**
    * Class definition
    */
 
-  class Carousel extends BaseComponent__default.default {
+  class Carousel extends BaseComponent {
     constructor(element, config) {
       super(element, config);
       this._interval = null;
@@ -94,136 +89,110 @@
       this._isSliding = false;
       this.touchTimeout = null;
       this._swipeHelper = null;
-      this._indicatorsElement = SelectorEngine__default.default.findOne(SELECTOR_INDICATORS, this._element);
-
+      this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
       this._addEventListeners();
-
       if (this._config.ride === CLASS_NAME_CAROUSEL) {
         this.cycle();
       }
-    } // Getters
-
+    }
 
+    // Getters
     static get Default() {
       return Default;
     }
-
     static get DefaultType() {
       return DefaultType;
     }
-
     static get NAME() {
       return NAME;
-    } // Public
-
+    }
 
+    // Public
     next() {
       this._slide(ORDER_NEXT);
     }
-
     nextWhenVisible() {
       // FIXME TODO use `document.visibilityState`
       // Don't call next when the page isn't visible
       // or the carousel or its parent isn't visible
-      if (!document.hidden && index.isVisible(this._element)) {
+      if (!document.hidden && index_js.isVisible(this._element)) {
         this.next();
       }
     }
-
     prev() {
       this._slide(ORDER_PREV);
     }
-
     pause() {
       if (this._isSliding) {
-        index.triggerTransitionEnd(this._element);
+        index_js.triggerTransitionEnd(this._element);
       }
-
       this._clearInterval();
     }
-
     cycle() {
       this._clearInterval();
-
       this._updateInterval();
-
       this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
     }
-
     _maybeEnableCycle() {
       if (!this._config.ride) {
         return;
       }
-
       if (this._isSliding) {
-        EventHandler__default.default.one(this._element, EVENT_SLID, () => this.cycle());
+        EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
         return;
       }
-
       this.cycle();
     }
-
     to(index) {
       const items = this._getItems();
-
       if (index > items.length - 1 || index < 0) {
         return;
       }
-
       if (this._isSliding) {
-        EventHandler__default.default.one(this._element, EVENT_SLID, () => this.to(index));
+        EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
         return;
       }
-
       const activeIndex = this._getItemIndex(this._getActive());
-
       if (activeIndex === index) {
         return;
       }
-
       const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
-
       this._slide(order, items[index]);
     }
-
     dispose() {
       if (this._swipeHelper) {
         this._swipeHelper.dispose();
       }
-
       super.dispose();
-    } // Private
-
+    }
 
+    // Private
     _configAfterMerge(config) {
       config.defaultInterval = config.interval;
       return config;
     }
-
     _addEventListeners() {
       if (this._config.keyboard) {
-        EventHandler__default.default.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
+        EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
       }
-
       if (this._config.pause === 'hover') {
-        EventHandler__default.default.on(this._element, EVENT_MOUSEENTER, () => this.pause());
-        EventHandler__default.default.on(this._element, EVENT_MOUSELEAVE, () => this._maybeEnableCycle());
+        EventHandler.on(this._element, EVENT_MOUSEENTER, () => this.pause());
+        EventHandler.on(this._element, EVENT_MOUSELEAVE, () => this._maybeEnableCycle());
       }
-
-      if (this._config.touch && Swipe__default.default.isSupported()) {
+      if (this._config.touch && Swipe.isSupported()) {
         this._addTouchEventListeners();
       }
     }
-
     _addTouchEventListeners() {
-      for (const img of SelectorEngine__default.default.find(SELECTOR_ITEM_IMG, this._element)) {
-        EventHandler__default.default.on(img, EVENT_DRAG_START, event => event.preventDefault());
+      for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
+        EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
       }
-
       const endCallBack = () => {
         if (this._config.pause !== 'hover') {
           return;
-        } // If it's a touch-enabled device, mouseenter/leave are fired as
+        }
+
+        // If it's a touch-enabled device, mouseenter/leave are fired as
         // part of the mouse compatibility events on first tap - the carousel
         // would stop cycling until user tapped out of it;
         // here, we listen for touchend, explicitly pause the carousel
@@ -231,120 +200,92 @@
         // is NOT fired) and after a timeout (to allow for mouse compatibility
         // events to fire) we explicitly restart cycling
 
-
         this.pause();
-
         if (this.touchTimeout) {
           clearTimeout(this.touchTimeout);
         }
-
         this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
       };
-
       const swipeConfig = {
         leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
         rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
         endCallback: endCallBack
       };
-      this._swipeHelper = new Swipe__default.default(this._element, swipeConfig);
+      this._swipeHelper = new Swipe(this._element, swipeConfig);
     }
-
     _keydown(event) {
       if (/input|textarea/i.test(event.target.tagName)) {
         return;
       }
-
       const direction = KEY_TO_DIRECTION[event.key];
-
       if (direction) {
         event.preventDefault();
-
         this._slide(this._directionToOrder(direction));
       }
     }
-
     _getItemIndex(element) {
       return this._getItems().indexOf(element);
     }
-
     _setActiveIndicatorElement(index) {
       if (!this._indicatorsElement) {
         return;
       }
-
-      const activeIndicator = SelectorEngine__default.default.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
+      const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
       activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
       activeIndicator.removeAttribute('aria-current');
-      const newActiveIndicator = SelectorEngine__default.default.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
-
+      const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
       if (newActiveIndicator) {
         newActiveIndicator.classList.add(CLASS_NAME_ACTIVE);
         newActiveIndicator.setAttribute('aria-current', 'true');
       }
     }
-
     _updateInterval() {
       const element = this._activeElement || this._getActive();
-
       if (!element) {
         return;
       }
-
       const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
       this._config.interval = elementInterval || this._config.defaultInterval;
     }
-
     _slide(order, element = null) {
       if (this._isSliding) {
         return;
       }
-
       const activeElement = this._getActive();
-
       const isNext = order === ORDER_NEXT;
-      const nextElement = element || index.getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
-
+      const nextElement = element || index_js.getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
       if (nextElement === activeElement) {
         return;
       }
-
       const nextElementIndex = this._getItemIndex(nextElement);
-
       const triggerEvent = eventName => {
-        return EventHandler__default.default.trigger(this._element, eventName, {
+        return EventHandler.trigger(this._element, eventName, {
           relatedTarget: nextElement,
           direction: this._orderToDirection(order),
           from: this._getItemIndex(activeElement),
           to: nextElementIndex
         });
       };
-
       const slideEvent = triggerEvent(EVENT_SLIDE);
-
       if (slideEvent.defaultPrevented) {
         return;
       }
-
       if (!activeElement || !nextElement) {
         // Some weirdness is happening, so we bail
-        // todo: change tests that use empty divs to avoid this check
+        // TODO: change tests that use empty divs to avoid this check
         return;
       }
-
       const isCycling = Boolean(this._interval);
       this.pause();
       this._isSliding = true;
-
       this._setActiveIndicatorElement(nextElementIndex);
-
       this._activeElement = nextElement;
       const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
       const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
       nextElement.classList.add(orderClassName);
-      index.reflow(nextElement);
+      index_js.reflow(nextElement);
       activeElement.classList.add(directionalClassName);
       nextElement.classList.add(directionalClassName);
-
       const completeCallBack = () => {
         nextElement.classList.remove(directionalClassName, orderClassName);
         nextElement.classList.add(CLASS_NAME_ACTIVE);
@@ -352,118 +293,94 @@
         this._isSliding = false;
         triggerEvent(EVENT_SLID);
       };
-
       this._queueCallback(completeCallBack, activeElement, this._isAnimated());
-
       if (isCycling) {
         this.cycle();
       }
     }
-
     _isAnimated() {
       return this._element.classList.contains(CLASS_NAME_SLIDE);
     }
-
     _getActive() {
-      return SelectorEngine__default.default.findOne(SELECTOR_ACTIVE_ITEM, this._element);
+      return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
     }
-
     _getItems() {
-      return SelectorEngine__default.default.find(SELECTOR_ITEM, this._element);
+      return SelectorEngine.find(SELECTOR_ITEM, this._element);
     }
-
     _clearInterval() {
       if (this._interval) {
         clearInterval(this._interval);
         this._interval = null;
       }
     }
-
     _directionToOrder(direction) {
-      if (index.isRTL()) {
+      if (index_js.isRTL()) {
         return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
       }
-
       return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
     }
-
     _orderToDirection(order) {
-      if (index.isRTL()) {
+      if (index_js.isRTL()) {
         return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
       }
-
       return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
-    } // Static
-
+    }
 
+    // Static
     static jQueryInterface(config) {
       return this.each(function () {
         const data = Carousel.getOrCreateInstance(this, config);
-
         if (typeof config === 'number') {
           data.to(config);
           return;
         }
-
         if (typeof config === 'string') {
           if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
             throw new TypeError(`No method named "${config}"`);
           }
-
           data[config]();
         }
       });
     }
-
   }
+
   /**
    * Data API implementation
    */
 
-
-  EventHandler__default.default.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (event) {
-    const target = index.getElementFromSelector(this);
-
+  EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, function (event) {
+    const target = SelectorEngine.getElementFromSelector(this);
     if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
       return;
     }
-
     event.preventDefault();
     const carousel = Carousel.getOrCreateInstance(target);
     const slideIndex = this.getAttribute('data-bs-slide-to');
-
     if (slideIndex) {
       carousel.to(slideIndex);
-
       carousel._maybeEnableCycle();
-
       return;
     }
-
-    if (Manipulator__default.default.getDataAttribute(this, 'slide') === 'next') {
+    if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
       carousel.next();
-
       carousel._maybeEnableCycle();
-
       return;
     }
-
     carousel.prev();
-
     carousel._maybeEnableCycle();
   });
-  EventHandler__default.default.on(window, EVENT_LOAD_DATA_API, () => {
-    const carousels = SelectorEngine__default.default.find(SELECTOR_DATA_RIDE);
-
+  EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+    const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
     for (const carousel of carousels) {
       Carousel.getOrCreateInstance(carousel);
     }
   });
+
   /**
    * jQuery
    */
 
-  index.defineJQueryPlugin(Carousel);
+  index_js.defineJQueryPlugin(Carousel);
 
   return Carousel;