text: /**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.2.0-beta1): scrollspy.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  
  import { defineJQueryPlugin, getElement, isDisabled, isVisible } from './util/index'
  import EventHandler from './dom/event-handler'
  import SelectorEngine from './dom/selector-engine'
  import BaseComponent from './base-component'
  
  /**
   * Constants
   */
  
  const NAME = 'scrollspy'
  const DATA_KEY = 'bs.scrollspy'
  const EVENT_KEY = `.${DATA_KEY}`
  const DATA_API_KEY = '.data-api'
  
  const EVENT_ACTIVATE = `activate${EVENT_KEY}`
  const EVENT_CLICK = `click${EVENT_KEY}`
  const EVENT_LOAD_DATA_API = `load${EVENT_KEY}${DATA_API_KEY}`
  
  const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'
  const CLASS_NAME_ACTIVE = 'active'
  
  const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'
  const SELECTOR_TARGET_LINKS = '[href]'
  const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'
  const SELECTOR_NAV_LINKS = '.nav-link'
  const SELECTOR_NAV_ITEMS = '.nav-item'
  const SELECTOR_LIST_ITEMS = '.list-group-item'
  const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`
  const SELECTOR_DROPDOWN = '.dropdown'
  const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'
  
  const Default = {
    offset: null, // TODO: v6 @deprecated, keep it for backwards compatibility reasons
    rootMargin: '0px 0px -25%',
    smoothScroll: false,
    target: null
  }
  
  const DefaultType = {
    offset: '(number|null)', // TODO v6 @deprecated, keep it for backwards compatibility reasons
    rootMargin: 'string',
    smoothScroll: 'boolean',
    target: 'element'
  }
  
  /**
   * Class definition
   */
  
  class ScrollSpy extends BaseComponent {
    constructor(element, config) {
      super(element, config)
  
      // this._element is the observablesContainer and config.target the menu links wrapper
      this._targetLinks = new Map()
      this._observableSections = new Map()
      this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element
      this._activeTarget = null
      this._observer = null
      this._previousScrollData = {
        visibleEntryTop: 0,
        parentScrollTop: 0
      }
      this.refresh() // initialize
    }
  
    // Getters
    static get Default() {
      return Default
    }
  
    static get DefaultType() {
      return DefaultType
    }
  
    static get NAME() {
      return NAME
    }
  
    // Public
    refresh() {
      this._initializeTargetsAndObservables()
      this._maybeEnableSmoothScroll()
  
      if (this._observer) {
        this._observer.disconnect()
      } else {
        this._observer = this._getNewObserver()
      }
  
      for (const section of this._observableSections.values()) {
        this._observer.observe(section)
      }
    }
  
    dispose() {
      this._observer.disconnect()
      super.dispose()
    }
  
    // Private
    _configAfterMerge(config) {
      // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
      config.target = getElement(config.target) || document.body
  
      return config
    }
  
    _maybeEnableSmoothScroll() {
      if (!this._config.smoothScroll) {
        return
      }
  
      // unregister any previous listeners
      EventHandler.off(this._config.target, EVENT_CLICK)
  
      EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {
        const observableSection = this._observableSections.get(event.target.hash)
        if (observableSection) {
          event.preventDefault()
          const root = this._rootElement || window
          const height = observableSection.offsetTop - this._element.offsetTop
          if (root.scrollTo) {
            root.scrollTo({ top: height, behavior: 'smooth' })
            return
          }
  
          // Chrome 60 doesn't support `scrollTo`
          root.scrollTop = height
        }
      })
    }
  
    _getNewObserver() {
      const options = {
        root: this._rootElement,
        threshold: [0.1, 0.5, 1],
        rootMargin: this._getRootMargin()
      }
  
      return new IntersectionObserver(entries => this._observerCallback(entries), options)
    }
  
    // The logic of selection
    _observerCallback(entries) {
      const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`)
      const activate = entry => {
        this._previousScrollData.visibleEntryTop = entry.target.offsetTop
        this._process(targetElement(entry))
      }
  
      const parentScrollTop = (this._rootElement || document.documentElement).scrollTop
      const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop
      this._previousScrollData.parentScrollTop = parentScrollTop
  
      for (const entry of entries) {
        if (!entry.isIntersecting) {
          this._activeTarget = null
          this._clearActiveClass(targetElement(entry))
  
          continue
        }
  
        const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop
        // if we are scrolling down, pick the bigger offsetTop
        if (userScrollsDown && entryIsLowerThanPrevious) {
          activate(entry)
          // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
          if (!parentScrollTop) {
            return
          }
  
          continue
        }
  
        // if we are scrolling up, pick the smallest offsetTop
        if (!userScrollsDown && !entryIsLowerThanPrevious) {
          activate(entry)
        }
      }
    }
  
    // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
    _getRootMargin() {
      return this._config.offset ? `${this._config.offset}px 0px -30%` : this._config.rootMargin
    }
  
    _initializeTargetsAndObservables() {
      this._targetLinks = new Map()
      this._observableSections = new Map()
  
      const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target)
  
      for (const anchor of targetLinks) {
        // ensure that the anchor has an id and is not disabled
        if (!anchor.hash || isDisabled(anchor)) {
          continue
        }
  
        const observableSection = SelectorEngine.findOne(anchor.hash, this._element)
  
        // ensure that the observableSection exists & is visible
        if (isVisible(observableSection)) {
          this._targetLinks.set(anchor.hash, anchor)
          this._observableSections.set(anchor.hash, observableSection)
        }
      }
    }
  
    _process(target) {
      if (this._activeTarget === target) {
        return
      }
  
      this._clearActiveClass(this._config.target)
      this._activeTarget = target
      target.classList.add(CLASS_NAME_ACTIVE)
      this._activateParents(target)
  
      EventHandler.trigger(this._element, EVENT_ACTIVATE, { relatedTarget: target })
    }
  
    _activateParents(target) {
      // Activate dropdown parents
      if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
        SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE, target.closest(SELECTOR_DROPDOWN))
          .classList.add(CLASS_NAME_ACTIVE)
        return
      }
  
      for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
        // Set triggered links parents as active
        // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
        for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
          item.classList.add(CLASS_NAME_ACTIVE)
        }
      }
    }
  
    _clearActiveClass(parent) {
      parent.classList.remove(CLASS_NAME_ACTIVE)
  
      const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE}`, parent)
      for (const node of activeNodes) {
        node.classList.remove(CLASS_NAME_ACTIVE)
      }
    }
  
    // Static
    static jQueryInterface(config) {
      return this.each(function () {
        const data = ScrollSpy.getOrCreateInstance(this, config)
  
        if (typeof config !== 'string') {
          return
        }
  
        if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
          throw new TypeError(`No method named "${config}"`)
        }
  
        data[config]()
      })
    }
  }
  
  /**
   * Data API implementation
   */
  
  EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
    for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
      ScrollSpy.getOrCreateInstance(spy)
    }
  })
  
  /**
   * jQuery
   */
  
  defineJQueryPlugin(ScrollSpy)
  
  export default ScrollSpy
  