Merge branch 'bs5' into 'dev'

Update to bootstrap 5 and implement next generation app menu (work in progress)

See merge request hubzilla/core!1980

1 files changed, 204 insertions, 231 deletions

diff --git a/vendor/twbs/bootstrap/js/src/carousel.js b/vendor/twbs/bootstrap/js/src/carousel.js
index b63d406bd..fe43f53eb 100644
--- a/vendor/twbs/bootstrap/js/src/carousel.js
+++ b/vendor/twbs/bootstrap/js/src/carousel.js
@@ -1,12 +1,24 @@
 /**
  * --------------------------------------------------------------------------
- * Bootstrap (v4.6.0): carousel.js
+ * Bootstrap (v5.0.2): carousel.js
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
  * --------------------------------------------------------------------------
  */
 
-import $ from 'jquery'
-import Util from './util'
+import {
+  defineJQueryPlugin,
+  getElementFromSelector,
+  isRTL,
+  isVisible,
+  getNextActiveElement,
+  reflow,
+  triggerTransitionEnd,
+  typeCheckConfig
+} from './util/index'
+import EventHandler from './dom/event-handler'
+import Manipulator from './dom/manipulator'
+import SelectorEngine from './dom/selector-engine'
+import BaseComponent from './base-component'
 
 /**
  * ------------------------------------------------------------------------
@@ -15,13 +27,12 @@ import Util from './util'
  */
 
 const NAME = 'carousel'
-const VERSION = '4.6.0'
 const DATA_KEY = 'bs.carousel'
 const EVENT_KEY = `.${DATA_KEY}`
 const DATA_API_KEY = '.data-api'
-const JQUERY_NO_CONFLICT = $.fn[NAME]
-const ARROW_LEFT_KEYCODE = 37 // KeyboardEvent.which value for left arrow key
-const ARROW_RIGHT_KEYCODE = 39 // KeyboardEvent.which value for right arrow key
+
+const ARROW_LEFT_KEY = 'ArrowLeft'
+const ARROW_RIGHT_KEY = 'ArrowRight'
 const TOUCHEVENT_COMPAT_WAIT = 500 // Time for mouse compat events to fire after touch
 const SWIPE_THRESHOLD = 40
 
@@ -43,11 +54,16 @@ const DefaultType = {
   touch: 'boolean'
 }
 
-const DIRECTION_NEXT = 'next'
-const DIRECTION_PREV = 'prev'
+const ORDER_NEXT = 'next'
+const ORDER_PREV = 'prev'
 const DIRECTION_LEFT = 'left'
 const DIRECTION_RIGHT = 'right'
 
+const KEY_TO_DIRECTION = {
+  [ARROW_LEFT_KEY]: DIRECTION_RIGHT,
+  [ARROW_RIGHT_KEY]: DIRECTION_LEFT
+}
+
 const EVENT_SLIDE = `slide${EVENT_KEY}`
 const EVENT_SLID = `slid${EVENT_KEY}`
 const EVENT_KEYDOWN = `keydown${EVENT_KEY}`
@@ -65,8 +81,8 @@ const EVENT_CLICK_DATA_API = `click${EVENT_KEY}${DATA_API_KEY}`
 const CLASS_NAME_CAROUSEL = 'carousel'
 const CLASS_NAME_ACTIVE = 'active'
 const CLASS_NAME_SLIDE = 'slide'
-const CLASS_NAME_RIGHT = 'carousel-item-right'
-const CLASS_NAME_LEFT = 'carousel-item-left'
+const CLASS_NAME_END = 'carousel-item-end'
+const CLASS_NAME_START = 'carousel-item-start'
 const CLASS_NAME_NEXT = 'carousel-item-next'
 const CLASS_NAME_PREV = 'carousel-item-prev'
 const CLASS_NAME_POINTER_EVENT = 'pointer-event'
@@ -77,21 +93,22 @@ const SELECTOR_ITEM = '.carousel-item'
 const SELECTOR_ITEM_IMG = '.carousel-item img'
 const SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'
 const SELECTOR_INDICATORS = '.carousel-indicators'
-const SELECTOR_DATA_SLIDE = '[data-slide], [data-slide-to]'
-const SELECTOR_DATA_RIDE = '[data-ride="carousel"]'
+const SELECTOR_INDICATOR = '[data-bs-target]'
+const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'
+const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'
 
-const PointerType = {
-  TOUCH: 'touch',
-  PEN: 'pen'
-}
+const POINTER_TYPE_TOUCH = 'touch'
+const POINTER_TYPE_PEN = 'pen'
 
 /**
  * ------------------------------------------------------------------------
  * Class Definition
  * ------------------------------------------------------------------------
  */
-class Carousel {
+class Carousel extends BaseComponent {
   constructor(element, config) {
+    super(element)
+
     this._items = null
     this._interval = null
     this._activeElement = null
@@ -102,46 +119,39 @@ class Carousel {
     this.touchDeltaX = 0
 
     this._config = this._getConfig(config)
-    this._element = element
-    this._indicatorsElement = this._element.querySelector(SELECTOR_INDICATORS)
+    this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element)
     this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0
-    this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent)
+    this._pointerEvent = Boolean(window.PointerEvent)
 
     this._addEventListeners()
   }
 
   // Getters
 
-  static get VERSION() {
-    return VERSION
-  }
-
   static get Default() {
     return Default
   }
 
+  static get NAME() {
+    return NAME
+  }
+
   // Public
 
   next() {
-    if (!this._isSliding) {
-      this._slide(DIRECTION_NEXT)
-    }
+    this._slide(ORDER_NEXT)
   }
 
   nextWhenVisible() {
-    const $element = $(this._element)
     // Don't call next when the page isn't visible
     // or the carousel or its parent isn't visible
-    if (!document.hidden &&
-      ($element.is(':visible') && $element.css('visibility') !== 'hidden')) {
+    if (!document.hidden && isVisible(this._element)) {
       this.next()
     }
   }
 
   prev() {
-    if (!this._isSliding) {
-      this._slide(DIRECTION_PREV)
-    }
+    this._slide(ORDER_PREV)
   }
 
   pause(event) {
@@ -149,8 +159,8 @@ class Carousel {
       this._isPaused = true
     }
 
-    if (this._element.querySelector(SELECTOR_NEXT_PREV)) {
-      Util.triggerTransitionEnd(this._element)
+    if (SelectorEngine.findOne(SELECTOR_NEXT_PREV, this._element)) {
+      triggerTransitionEnd(this._element)
       this.cycle(true)
     }
 
@@ -168,7 +178,7 @@ class Carousel {
       this._interval = null
     }
 
-    if (this._config.interval && !this._isPaused) {
+    if (this._config && this._config.interval && !this._isPaused) {
       this._updateInterval()
 
       this._interval = setInterval(
@@ -179,8 +189,7 @@ class Carousel {
   }
 
   to(index) {
-    this._activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM)
-
+    this._activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
     const activeIndex = this._getItemIndex(this._activeElement)
 
     if (index > this._items.length - 1 || index < 0) {
@@ -188,7 +197,7 @@ class Carousel {
     }
 
     if (this._isSliding) {
-      $(this._element).one(EVENT_SLID, () => this.to(index))
+      EventHandler.one(this._element, EVENT_SLID, () => this.to(index))
       return
     }
 
@@ -198,25 +207,11 @@ class Carousel {
       return
     }
 
-    const direction = index > activeIndex ?
-      DIRECTION_NEXT :
-      DIRECTION_PREV
+    const order = index > activeIndex ?
+      ORDER_NEXT :
+      ORDER_PREV
 
-    this._slide(direction, this._items[index])
-  }
-
-  dispose() {
-    $(this._element).off(EVENT_KEY)
-    $.removeData(this._element, DATA_KEY)
-
-    this._items = null
-    this._config = null
-    this._element = null
-    this._interval = null
-    this._isPaused = null
-    this._isSliding = null
-    this._activeElement = null
-    this._indicatorsElement = null
+    this._slide(order, this._items[index])
   }
 
   // Private
@@ -224,9 +219,10 @@ class Carousel {
   _getConfig(config) {
     config = {
       ...Default,
-      ...config
+      ...Manipulator.getDataAttributes(this._element),
+      ...(typeof config === 'object' ? config : {})
     }
-    Util.typeCheckConfig(NAME, config, DefaultType)
+    typeCheckConfig(NAME, config, DefaultType)
     return config
   }
 
@@ -241,58 +237,47 @@ class Carousel {
 
     this.touchDeltaX = 0
 
-    // swipe left
-    if (direction > 0) {
-      this.prev()
+    if (!direction) {
+      return
     }
 
-    // swipe right
-    if (direction < 0) {
-      this.next()
-    }
+    this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT)
   }
 
   _addEventListeners() {
     if (this._config.keyboard) {
-      $(this._element).on(EVENT_KEYDOWN, event => this._keydown(event))
+      EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event))
     }
 
     if (this._config.pause === 'hover') {
-      $(this._element)
-        .on(EVENT_MOUSEENTER, event => this.pause(event))
-        .on(EVENT_MOUSELEAVE, event => this.cycle(event))
+      EventHandler.on(this._element, EVENT_MOUSEENTER, event => this.pause(event))
+      EventHandler.on(this._element, EVENT_MOUSELEAVE, event => this.cycle(event))
     }
 
-    if (this._config.touch) {
+    if (this._config.touch && this._touchSupported) {
       this._addTouchEventListeners()
     }
   }
 
   _addTouchEventListeners() {
-    if (!this._touchSupported) {
-      return
-    }
-
     const start = event => {
-      if (this._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
-        this.touchStartX = event.originalEvent.clientX
+      if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+        this.touchStartX = event.clientX
       } else if (!this._pointerEvent) {
-        this.touchStartX = event.originalEvent.touches[0].clientX
+        this.touchStartX = event.touches[0].clientX
       }
     }
 
     const move = event => {
       // ensure swiping with one touch and not pinching
-      if (event.originalEvent.touches && event.originalEvent.touches.length > 1) {
-        this.touchDeltaX = 0
-      } else {
-        this.touchDeltaX = event.originalEvent.touches[0].clientX - this.touchStartX
-      }
+      this.touchDeltaX = event.touches && event.touches.length > 1 ?
+        0 :
+        event.touches[0].clientX - this.touchStartX
     }
 
     const end = event => {
-      if (this._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) {
-        this.touchDeltaX = event.originalEvent.clientX - this.touchStartX
+      if (this._pointerEvent && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)) {
+        this.touchDeltaX = event.clientX - this.touchStartX
       }
 
       this._handleSwipe()
@@ -314,18 +299,19 @@ class Carousel {
       }
     }
 
-    $(this._element.querySelectorAll(SELECTOR_ITEM_IMG))
-      .on(EVENT_DRAG_START, e => e.preventDefault())
+    SelectorEngine.find(SELECTOR_ITEM_IMG, this._element).forEach(itemImg => {
+      EventHandler.on(itemImg, EVENT_DRAG_START, e => e.preventDefault())
+    })
 
     if (this._pointerEvent) {
-      $(this._element).on(EVENT_POINTERDOWN, event => start(event))
-      $(this._element).on(EVENT_POINTERUP, event => end(event))
+      EventHandler.on(this._element, EVENT_POINTERDOWN, event => start(event))
+      EventHandler.on(this._element, EVENT_POINTERUP, event => end(event))
 
       this._element.classList.add(CLASS_NAME_POINTER_EVENT)
     } else {
-      $(this._element).on(EVENT_TOUCHSTART, event => start(event))
-      $(this._element).on(EVENT_TOUCHMOVE, event => move(event))
-      $(this._element).on(EVENT_TOUCHEND, event => end(event))
+      EventHandler.on(this._element, EVENT_TOUCHSTART, event => start(event))
+      EventHandler.on(this._element, EVENT_TOUCHMOVE, event => move(event))
+      EventHandler.on(this._element, EVENT_TOUCHEND, event => end(event))
     }
   }
 
@@ -334,83 +320,65 @@ class Carousel {
       return
     }
 
-    switch (event.which) {
-      case ARROW_LEFT_KEYCODE:
-        event.preventDefault()
-        this.prev()
-        break
-      case ARROW_RIGHT_KEYCODE:
-        event.preventDefault()
-        this.next()
-        break
-      default:
+    const direction = KEY_TO_DIRECTION[event.key]
+    if (direction) {
+      event.preventDefault()
+      this._slide(direction)
     }
   }
 
   _getItemIndex(element) {
     this._items = element && element.parentNode ?
-      [].slice.call(element.parentNode.querySelectorAll(SELECTOR_ITEM)) :
+      SelectorEngine.find(SELECTOR_ITEM, element.parentNode) :
       []
+
     return this._items.indexOf(element)
   }
 
-  _getItemByDirection(direction, activeElement) {
-    const isNextDirection = direction === DIRECTION_NEXT
-    const isPrevDirection = direction === DIRECTION_PREV
-    const activeIndex = this._getItemIndex(activeElement)
-    const lastItemIndex = this._items.length - 1
-    const isGoingToWrap = isPrevDirection && activeIndex === 0 ||
-                            isNextDirection && activeIndex === lastItemIndex
-
-    if (isGoingToWrap && !this._config.wrap) {
-      return activeElement
-    }
-
-    const delta = direction === DIRECTION_PREV ? -1 : 1
-    const itemIndex = (activeIndex + delta) % this._items.length
-
-    return itemIndex === -1 ?
-      this._items[this._items.length - 1] : this._items[itemIndex]
+  _getItemByOrder(order, activeElement) {
+    const isNext = order === ORDER_NEXT
+    return getNextActiveElement(this._items, activeElement, isNext, this._config.wrap)
   }
 
   _triggerSlideEvent(relatedTarget, eventDirectionName) {
     const targetIndex = this._getItemIndex(relatedTarget)
-    const fromIndex = this._getItemIndex(this._element.querySelector(SELECTOR_ACTIVE_ITEM))
-    const slideEvent = $.Event(EVENT_SLIDE, {
+    const fromIndex = this._getItemIndex(SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element))
+
+    return EventHandler.trigger(this._element, EVENT_SLIDE, {
       relatedTarget,
       direction: eventDirectionName,
       from: fromIndex,
       to: targetIndex
     })
-
-    $(this._element).trigger(slideEvent)
-
-    return slideEvent
   }
 
   _setActiveIndicatorElement(element) {
     if (this._indicatorsElement) {
-      const indicators = [].slice.call(this._indicatorsElement.querySelectorAll(SELECTOR_ACTIVE))
-      $(indicators).removeClass(CLASS_NAME_ACTIVE)
+      const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement)
+
+      activeIndicator.classList.remove(CLASS_NAME_ACTIVE)
+      activeIndicator.removeAttribute('aria-current')
 
-      const nextIndicator = this._indicatorsElement.children[
-        this._getItemIndex(element)
-      ]
+      const indicators = SelectorEngine.find(SELECTOR_INDICATOR, this._indicatorsElement)
 
-      if (nextIndicator) {
-        $(nextIndicator).addClass(CLASS_NAME_ACTIVE)
+      for (let i = 0; i < indicators.length; i++) {
+        if (Number.parseInt(indicators[i].getAttribute('data-bs-slide-to'), 10) === this._getItemIndex(element)) {
+          indicators[i].classList.add(CLASS_NAME_ACTIVE)
+          indicators[i].setAttribute('aria-current', 'true')
+          break
+        }
       }
     }
   }
 
   _updateInterval() {
-    const element = this._activeElement || this._element.querySelector(SELECTOR_ACTIVE_ITEM)
+    const element = this._activeElement || SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
 
     if (!element) {
       return
     }
 
-    const elementInterval = parseInt(element.getAttribute('data-interval'), 10)
+    const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10)
 
     if (elementInterval) {
       this._config.defaultInterval = this._config.defaultInterval || this._config.interval
@@ -420,35 +388,31 @@ class Carousel {
     }
   }
 
-  _slide(direction, element) {
-    const activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM)
+  _slide(directionOrOrder, element) {
+    const order = this._directionToOrder(directionOrOrder)
+    const activeElement = SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element)
     const activeElementIndex = this._getItemIndex(activeElement)
-    const nextElement = element || activeElement &&
-      this._getItemByDirection(direction, activeElement)
+    const nextElement = element || this._getItemByOrder(order, activeElement)
+
     const nextElementIndex = this._getItemIndex(nextElement)
     const isCycling = Boolean(this._interval)
 
-    let directionalClassName
-    let orderClassName
-    let eventDirectionName
+    const isNext = order === ORDER_NEXT
+    const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END
+    const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV
+    const eventDirectionName = this._orderToDirection(order)
 
-    if (direction === DIRECTION_NEXT) {
-      directionalClassName = CLASS_NAME_LEFT
-      orderClassName = CLASS_NAME_NEXT
-      eventDirectionName = DIRECTION_LEFT
-    } else {
-      directionalClassName = CLASS_NAME_RIGHT
-      orderClassName = CLASS_NAME_PREV
-      eventDirectionName = DIRECTION_RIGHT
+    if (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) {
+      this._isSliding = false
+      return
     }
 
-    if (nextElement && $(nextElement).hasClass(CLASS_NAME_ACTIVE)) {
-      this._isSliding = false
+    if (this._isSliding) {
       return
     }
 
     const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName)
-    if (slideEvent.isDefaultPrevented()) {
+    if (slideEvent.defaultPrevented) {
       return
     }
 
@@ -466,42 +430,41 @@ class Carousel {
     this._setActiveIndicatorElement(nextElement)
     this._activeElement = nextElement
 
-    const slidEvent = $.Event(EVENT_SLID, {
-      relatedTarget: nextElement,
-      direction: eventDirectionName,
-      from: activeElementIndex,
-      to: nextElementIndex
-    })
+    const triggerSlidEvent = () => {
+      EventHandler.trigger(this._element, EVENT_SLID, {
+        relatedTarget: nextElement,
+        direction: eventDirectionName,
+        from: activeElementIndex,
+        to: nextElementIndex
+      })
+    }
 
-    if ($(this._element).hasClass(CLASS_NAME_SLIDE)) {
-      $(nextElement).addClass(orderClassName)
+    if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
+      nextElement.classList.add(orderClassName)
 
-      Util.reflow(nextElement)
+      reflow(nextElement)
 
-      $(activeElement).addClass(directionalClassName)
-      $(nextElement).addClass(directionalClassName)
+      activeElement.classList.add(directionalClassName)
+      nextElement.classList.add(directionalClassName)
 
-      const transitionDuration = Util.getTransitionDurationFromElement(activeElement)
+      const completeCallBack = () => {
+        nextElement.classList.remove(directionalClassName, orderClassName)
+        nextElement.classList.add(CLASS_NAME_ACTIVE)
 
-      $(activeElement)
-        .one(Util.TRANSITION_END, () => {
-          $(nextElement)
-            .removeClass(`${directionalClassName} ${orderClassName}`)
-            .addClass(CLASS_NAME_ACTIVE)
+        activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName)
 
-          $(activeElement).removeClass(`${CLASS_NAME_ACTIVE} ${orderClassName} ${directionalClassName}`)
+        this._isSliding = false
 
-          this._isSliding = false
+        setTimeout(triggerSlidEvent, 0)
+      }
 
-          setTimeout(() => $(this._element).trigger(slidEvent), 0)
-        })
-        .emulateTransitionEnd(transitionDuration)
+      this._queueCallback(completeCallBack, activeElement, true)
     } else {
-      $(activeElement).removeClass(CLASS_NAME_ACTIVE)
-      $(nextElement).addClass(CLASS_NAME_ACTIVE)
+      activeElement.classList.remove(CLASS_NAME_ACTIVE)
+      nextElement.classList.add(CLASS_NAME_ACTIVE)
 
       this._isSliding = false
-      $(this._element).trigger(slidEvent)
+      triggerSlidEvent()
     }
 
     if (isCycling) {
@@ -509,72 +472,86 @@ class Carousel {
     }
   }
 
+  _directionToOrder(direction) {
+    if (![DIRECTION_RIGHT, DIRECTION_LEFT].includes(direction)) {
+      return direction
+    }
+
+    if (isRTL()) {
+      return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT
+    }
+
+    return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV
+  }
+
+  _orderToDirection(order) {
+    if (![ORDER_NEXT, ORDER_PREV].includes(order)) {
+      return order
+    }
+
+    if (isRTL()) {
+      return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT
+    }
+
+    return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT
+  }
+
   // Static
 
-  static _jQueryInterface(config) {
-    return this.each(function () {
-      let data = $(this).data(DATA_KEY)
-      let _config = {
-        ...Default,
-        ...$(this).data()
-      }
+  static carouselInterface(element, config) {
+    const data = Carousel.getOrCreateInstance(element, config)
 
-      if (typeof config === 'object') {
-        _config = {
-          ..._config,
-          ...config
-        }
+    let { _config } = data
+    if (typeof config === 'object') {
+      _config = {
+        ..._config,
+        ...config
       }
+    }
 
-      const action = typeof config === 'string' ? config : _config.slide
+    const action = typeof config === 'string' ? config : _config.slide
 
-      if (!data) {
-        data = new Carousel(this, _config)
-        $(this).data(DATA_KEY, data)
+    if (typeof config === 'number') {
+      data.to(config)
+    } else if (typeof action === 'string') {
+      if (typeof data[action] === 'undefined') {
+        throw new TypeError(`No method named "${action}"`)
       }
 
-      if (typeof config === 'number') {
-        data.to(config)
-      } else if (typeof action === 'string') {
-        if (typeof data[action] === 'undefined') {
-          throw new TypeError(`No method named "${action}"`)
-        }
+      data[action]()
+    } else if (_config.interval && _config.ride) {
+      data.pause()
+      data.cycle()
+    }
+  }
 
-        data[action]()
-      } else if (_config.interval && _config.ride) {
-        data.pause()
-        data.cycle()
-      }
+  static jQueryInterface(config) {
+    return this.each(function () {
+      Carousel.carouselInterface(this, config)
     })
   }
 
-  static _dataApiClickHandler(event) {
-    const selector = Util.getSelectorFromElement(this)
+  static dataApiClickHandler(event) {
+    const target = getElementFromSelector(this)
 
-    if (!selector) {
-      return
-    }
-
-    const target = $(selector)[0]
-
-    if (!target || !$(target).hasClass(CLASS_NAME_CAROUSEL)) {
+    if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
       return
     }
 
     const config = {
-      ...$(target).data(),
-      ...$(this).data()
+      ...Manipulator.getDataAttributes(target),
+      ...Manipulator.getDataAttributes(this)
     }
-    const slideIndex = this.getAttribute('data-slide-to')
+    const slideIndex = this.getAttribute('data-bs-slide-to')
 
     if (slideIndex) {
       config.interval = false
     }
 
-    Carousel._jQueryInterface.call($(target), config)
+    Carousel.carouselInterface(target, config)
 
     if (slideIndex) {
-      $(target).data(DATA_KEY).to(slideIndex)
+      Carousel.getInstance(target).to(slideIndex)
     }
 
     event.preventDefault()
@@ -587,13 +564,13 @@ class Carousel {
  * ------------------------------------------------------------------------
  */
 
-$(document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel._dataApiClickHandler)
+EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_SLIDE, Carousel.dataApiClickHandler)
+
+EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
+  const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE)
 
-$(window).on(EVENT_LOAD_DATA_API, () => {
-  const carousels = [].slice.call(document.querySelectorAll(SELECTOR_DATA_RIDE))
   for (let i = 0, len = carousels.length; i < len; i++) {
-    const $carousel = $(carousels[i])
-    Carousel._jQueryInterface.call($carousel, $carousel.data())
+    Carousel.carouselInterface(carousels[i], Carousel.getInstance(carousels[i]))
   }
 })
 
@@ -601,13 +578,9 @@ $(window).on(EVENT_LOAD_DATA_API, () => {
  * ------------------------------------------------------------------------
  * jQuery
  * ------------------------------------------------------------------------
+ * add .Carousel to jQuery only if jQuery is present
  */
 
-$.fn[NAME] = Carousel._jQueryInterface
-$.fn[NAME].Constructor = Carousel
-$.fn[NAME].noConflict = () => {
-  $.fn[NAME] = JQUERY_NO_CONFLICT
-  return Carousel._jQueryInterface
-}
+defineJQueryPlugin(Carousel)
 
 export default Carousel