KONTOLODON

/var/www/ojs-3.3.0-13/plugins/themes/material/vendor/mdb/src/js/bootstrap/dist/

/*!
 * Bootstrap carousel.js v5.0.1 (https://getbootstrap.com/)
 * Copyright 2011-2021 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('./dom/selector-engine.js'),
        require('./dom/data.js'),
        require('./dom/event-handler.js'),
        require('./dom/manipulator.js'),
        require('./base-component.js')
      ))
    : typeof define === 'function' && define.amd
    ? define([
        './dom/selector-engine',
        './dom/data',
        './dom/event-handler',
        './dom/manipulator',
        './base-component',
      ], factory)
    : ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
      (global.Carousel = factory(
        global.SelectorEngine,
        global.Data,
        global.EventHandler,
        global.Manipulator,
        global.Base
      )));
})(this, function (SelectorEngine, Data, EventHandler, Manipulator, BaseComponent) {
  'use strict';

function _interopDefaultLegacy(e) {
    return e && typeof e === 'object' && 'default' in e ? e : { default: e };
  }

var SelectorEngine__default = /*#__PURE__*/ _interopDefaultLegacy(SelectorEngine);
  var Data__default = /*#__PURE__*/ _interopDefaultLegacy(Data);
  var EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
  var Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
  var BaseComponent__default = /*#__PURE__*/ _interopDefaultLegacy(BaseComponent);

const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)

const toType = (obj) => {
    if (obj === null || obj === undefined) {
      return `${obj}`;
    }

return {}.toString
      .call(obj)
      .match(/\s([a-z]+)/i)[1]
      .toLowerCase();
  };

const getSelector = (element) => {
    let selector = element.getAttribute('data-bs-target');

if (!selector || selector === '#') {
      let hrefAttr = element.getAttribute('href'); // The only valid content that could double as a selector are IDs or classes,
      // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
      // `document.querySelector` will rightfully complain it is invalid.
      // See https://github.com/twbs/bootstrap/issues/32273

if (!hrefAttr || (!hrefAttr.includes('#') && !hrefAttr.startsWith('.'))) {
        return null;
      } // Just in case some CMS puts out a full URL with the anchor appended

if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
        hrefAttr = `#${hrefAttr.split('#')[1]}`;
      }

selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
    }

return selector;
  };

const getElementFromSelector = (element) => {
    const selector = getSelector(element);
    return selector ? document.querySelector(selector) : null;
  };

const triggerTransitionEnd = (element) => {
    element.dispatchEvent(new Event(TRANSITION_END));
  };

const isElement = (obj) => {
    if (!obj || typeof obj !== 'object') {
      return false;
    }

if (typeof obj.jquery !== 'undefined') {
      obj = obj[0];
    }

return typeof obj.nodeType !== 'undefined';
  };

const typeCheckConfig = (componentName, config, configTypes) => {
    Object.keys(configTypes).forEach((property) => {
      const expectedTypes = configTypes[property];
      const value = config[property];
      const valueType = value && isElement(value) ? 'element' : toType(value);

if (!new RegExp(expectedTypes).test(valueType)) {
        throw new TypeError(
          `${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`
        );
      }
    });
  };

const isVisible = (element) => {
    if (!element) {
      return false;
    }

if (element.style && element.parentNode && element.parentNode.style) {
      const elementStyle = getComputedStyle(element);
      const parentNodeStyle = getComputedStyle(element.parentNode);
      return (
        elementStyle.display !== 'none' &&
        parentNodeStyle.display !== 'none' &&
        elementStyle.visibility !== 'hidden'
      );
    }

return false;
  };

const reflow = (element) => element.offsetHeight;

const getjQuery = () => {
    const { jQuery } = window;

if (jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
      return jQuery;
    }

return null;
  };

const onDOMContentLoaded = (callback) => {
    if (document.readyState === 'loading') {
      document.addEventListener('DOMContentLoaded', callback);
    } else {
      callback();
    }
  };

const isRTL = () => document.documentElement.dir === 'rtl';

const defineJQueryPlugin = (plugin) => {
    onDOMContentLoaded(() => {
      const $ = getjQuery();
      /* istanbul ignore if */

if ($) {
        const name = plugin.NAME;
        const JQUERY_NO_CONFLICT = $.fn[name];
        $.fn[name] = plugin.jQueryInterface;
        $.fn[name].Constructor = plugin;

$.fn[name].noConflict = () => {
          $.fn[name] = JQUERY_NO_CONFLICT;
          return plugin.jQueryInterface;
        };
      }
    });
  };

/**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.0.1): carousel.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */

const NAME = 'carousel';
  const DATA_KEY = 'bs.carousel';
  const EVENT_KEY = `.${DATA_KEY}`;
  const DATA_API_KEY = '.data-api';
  const ARROW_LEFT_KEY = 'ArrowLeft';
  const ARROW_RIGHT_KEY = 'ArrowRight';
  const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch

class Carousel extends BaseComponent__default['default'] {
    constructor(element, config) {
      super(element);
      this._items = null;
      this._interval = null;
      this._activeElement = null;
      this._isPaused = false;
      this._isSliding = false;
      this.touchTimeout = null;
      this.touchStartX = 0;
      this.touchDeltaX = 0;
      this._config = this._getConfig(config);
      this._indicatorsElement = SelectorEngine__default['default'].findOne(
        SELECTOR_INDICATORS,
        this._element
      );
      this._touchSupported =
        'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
      this._pointerEvent = Boolean(window.PointerEvent);

this._addEventListeners();
    } // Getters

static get Default() {
      return Default;
    }

static get NAME() {
      return NAME;
    } // Public

next() {
      if (!this._isSliding) {
        this._slide(ORDER_NEXT);
      }
    }

nextWhenVisible() {
      // Don't call next when the page isn't visible
      // or the carousel or its parent isn't visible
      if (!document.hidden && isVisible(this._element)) {
        this.next();
      }
    }

prev() {
      if (!this._isSliding) {
        this._slide(ORDER_PREV);
      }
    }

pause(event) {
      if (!event) {
        this._isPaused = true;
      }

if (SelectorEngine__default['default'].findOne(SELECTOR_NEXT_PREV, this._element)) {
        triggerTransitionEnd(this._element);
        this.cycle(true);
      }

clearInterval(this._interval);
      this._interval = null;
    }

cycle(event) {
      if (!event) {
        this._isPaused = false;
      }

if (this._interval) {
        clearInterval(this._interval);
        this._interval = null;
      }

if (this._config && this._config.interval && !this._isPaused) {
        this._updateInterval();

this._interval = setInterval(
          (document.visibilityState ? this.nextWhenVisible : this.next).bind(this),
          this._config.interval
        );
      }
    }

to(index) {
      this._activeElement = SelectorEngine__default['default'].findOne(
        SELECTOR_ACTIVE_ITEM,
        this._element
      );

const activeIndex = this._getItemIndex(this._activeElement);

if (index > this._items.length - 1 || index < 0) {
        return;
      }

if (this._isSliding) {
        EventHandler__default['default'].one(this._element, EVENT_SLID, () => this.to(index));
        return;
      }

if (activeIndex === index) {
        this.pause();
        this.cycle();
        return;
      }

const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;

this._slide(order, this._items[index]);
    } // Private

_getConfig(config) {
      config = { ...Default, ...config };
      typeCheckConfig(NAME, config, DefaultType);
      return config;
    }

_handleSwipe() {
      const absDeltax = Math.abs(this.touchDeltaX);

if (absDeltax <= SWIPE_THRESHOLD) {
        return;
      }

const direction = absDeltax / this.touchDeltaX;
      this.touchDeltaX = 0;

if (!direction) {
        return;
      }

this._slide(direction > 0 ? DIRECTION_RIGHT : DIRECTION_LEFT);
    }

_addEventListeners() {
      if (this._config.keyboard) {
        EventHandler__default['default'].on(this._element, EVENT_KEYDOWN, (event) =>
          this._keydown(event)
        );
      }

if (this._config.pause === 'hover') {
        EventHandler__default['default'].on(this._element, EVENT_MOUSEENTER, (event) =>
          this.pause(event)
        );
        EventHandler__default['default'].on(this._element, EVENT_MOUSELEAVE, (event) =>
          this.cycle(event)
        );
      }

if (this._config.touch && this._touchSupported) {
        this._addTouchEventListeners();
      }
    }

_addTouchEventListeners() {
      const start = (event) => {
        if (
          this._pointerEvent &&
          (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
        ) {
          this.touchStartX = event.clientX;
        } else if (!this._pointerEvent) {
          this.touchStartX = event.touches[0].clientX;
        }
      };

const move = (event) => {
        // ensure swiping with one touch and not pinching
        this.touchDeltaX =
          event.touches && event.touches.length > 1
            ? 0
            : event.touches[0].clientX - this.touchStartX;
      };

const end = (event) => {
        if (
          this._pointerEvent &&
          (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH)
        ) {
          this.touchDeltaX = event.clientX - this.touchStartX;
        }

this._handleSwipe();

if (this._config.pause === 'hover') {
          // 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
          // (as if it's the second time we tap on it, mouseenter compat event
          // 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(
            (event) => this.cycle(event),
            TOUCHEVENT_COMPAT_WAIT + this._config.interval
          );
        }
      };

SelectorEngine__default['default']
        .find(SELECTOR_ITEM_IMG, this._element)
        .forEach((itemImg) => {
          EventHandler__default['default'].on(itemImg, EVENT_DRAG_START, (e) => e.preventDefault());
        });

if (this._pointerEvent) {
        EventHandler__default['default'].on(this._element, EVENT_POINTERDOWN, (event) =>
          start(event)
        );
        EventHandler__default['default'].on(this._element, EVENT_POINTERUP, (event) => end(event));

this._element.classList.add(CLASS_NAME_POINTER_EVENT);
      } else {
        EventHandler__default['default'].on(this._element, EVENT_TOUCHSTART, (event) =>
          start(event)
        );
        EventHandler__default['default'].on(this._element, EVENT_TOUCHMOVE, (event) => move(event));
        EventHandler__default['default'].on(this._element, EVENT_TOUCHEND, (event) => end(event));
      }
    }

_keydown(event) {
      if (/input|textarea/i.test(event.target.tagName)) {
        return;
      }

if (event.key === ARROW_LEFT_KEY) {
        event.preventDefault();

this._slide(DIRECTION_RIGHT);
      } else if (event.key === ARROW_RIGHT_KEY) {
        event.preventDefault();

this._slide(DIRECTION_LEFT);
      }
    }

_getItemIndex(element) {
      this._items =
        element && element.parentNode
          ? SelectorEngine__default['default'].find(SELECTOR_ITEM, element.parentNode)
          : [];
      return this._items.indexOf(element);
    }

_getItemByOrder(order, activeElement) {
      const isNext = order === ORDER_NEXT;
      const isPrev = order === ORDER_PREV;

const activeIndex = this._getItemIndex(activeElement);

const lastItemIndex = this._items.length - 1;
      const isGoingToWrap =
        (isPrev && activeIndex === 0) || (isNext && activeIndex === lastItemIndex);

if (isGoingToWrap && !this._config.wrap) {
        return activeElement;
      }

const delta = isPrev ? -1 : 1;
      const itemIndex = (activeIndex + delta) % this._items.length;
      return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex];
    }

_triggerSlideEvent(relatedTarget, eventDirectionName) {
      const targetIndex = this._getItemIndex(relatedTarget);

const fromIndex = this._getItemIndex(
        SelectorEngine__default['default'].findOne(SELECTOR_ACTIVE_ITEM, this._element)
      );

return EventHandler__default['default'].trigger(this._element, EVENT_SLIDE, {
        relatedTarget,
        direction: eventDirectionName,
        from: fromIndex,
        to: targetIndex,
      });
    }

_setActiveIndicatorElement(element) {
      if (this._indicatorsElement) {
        const activeIndicator = SelectorEngine__default['default'].findOne(
          SELECTOR_ACTIVE,
          this._indicatorsElement
        );
        activeIndicator.classList.remove(CLASS_NAME_ACTIVE);
        activeIndicator.removeAttribute('aria-current');
        const indicators = SelectorEngine__default['default'].find(
          SELECTOR_INDICATOR,
          this._indicatorsElement
        );

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 ||
        SelectorEngine__default['default'].findOne(SELECTOR_ACTIVE_ITEM, this._element);

if (!element) {
        return;
      }

const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);

if (elementInterval) {
        this._config.defaultInterval = this._config.defaultInterval || this._config.interval;
        this._config.interval = elementInterval;
      } else {
        this._config.interval = this._config.defaultInterval || this._config.interval;
      }
    }

_slide(directionOrOrder, element) {
      const order = this._directionToOrder(directionOrOrder);

const activeElement = SelectorEngine__default['default'].findOne(
        SELECTOR_ACTIVE_ITEM,
        this._element
      );

const activeElementIndex = this._getItemIndex(activeElement);

const nextElement = element || this._getItemByOrder(order, activeElement);

const nextElementIndex = this._getItemIndex(nextElement);

const isCycling = Boolean(this._interval);
      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 (nextElement && nextElement.classList.contains(CLASS_NAME_ACTIVE)) {
        this._isSliding = false;
        return;
      }

const slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName);

if (slideEvent.defaultPrevented) {
        return;
      }

if (!activeElement || !nextElement) {
        // Some weirdness is happening, so we bail
        return;
      }

this._isSliding = true;

if (isCycling) {
        this.pause();
      }

this._setActiveIndicatorElement(nextElement);

this._activeElement = nextElement;

const triggerSlidEvent = () => {
        EventHandler__default['default'].trigger(this._element, EVENT_SLID, {
          relatedTarget: nextElement,
          direction: eventDirectionName,
          from: activeElementIndex,
          to: nextElementIndex,
        });
      };

if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
        nextElement.classList.add(orderClassName);
        reflow(nextElement);
        activeElement.classList.add(directionalClassName);
        nextElement.classList.add(directionalClassName);

const completeCallBack = () => {
          nextElement.classList.remove(directionalClassName, orderClassName);
          nextElement.classList.add(CLASS_NAME_ACTIVE);
          activeElement.classList.remove(CLASS_NAME_ACTIVE, orderClassName, directionalClassName);
          this._isSliding = false;
          setTimeout(triggerSlidEvent, 0);
        };

this._queueCallback(completeCallBack, activeElement, true);
      } else {
        activeElement.classList.remove(CLASS_NAME_ACTIVE);
        nextElement.classList.add(CLASS_NAME_ACTIVE);
        this._isSliding = false;
        triggerSlidEvent();
      }

if (isCycling) {
        this.cycle();
      }
    }

_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 carouselInterface(element, config) {
      let data = Data__default['default'].get(element, DATA_KEY);
      let _config = { ...Default, ...Manipulator__default['default'].getDataAttributes(element) };

if (typeof config === 'object') {
        _config = { ..._config, ...config };
      }

const action = typeof config === 'string' ? config : _config.slide;

if (!data) {
        data = new Carousel(element, _config);
      }

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();
      }
    }

static jQueryInterface(config) {
      return this.each(function () {
        Carousel.carouselInterface(this, config);
      });
    }

static dataApiClickHandler(event) {
      const target = getElementFromSelector(this);

if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
        return;
      }

const config = {
        ...Manipulator__default['default'].getDataAttributes(target),
        ...Manipulator__default['default'].getDataAttributes(this),
      };
      const slideIndex = this.getAttribute('data-bs-slide-to');

if (slideIndex) {
        config.interval = false;
      }

Carousel.carouselInterface(target, config);

if (slideIndex) {
        Data__default['default'].get(target, DATA_KEY).to(slideIndex);
      }

event.preventDefault();
    }
  }
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */

EventHandler__default['default'].on(
    document,
    EVENT_CLICK_DATA_API,
    SELECTOR_DATA_SLIDE,
    Carousel.dataApiClickHandler
  );
  EventHandler__default['default'].on(window, EVENT_LOAD_DATA_API, () => {
    const carousels = SelectorEngine__default['default'].find(SELECTOR_DATA_RIDE);

for (let i = 0, len = carousels.length; i < len; i++) {
      Carousel.carouselInterface(
        carousels[i],
        Data__default['default'].get(carousels[i], DATA_KEY)
      );
    }
  });
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Carousel to jQuery only if jQuery is present
   */

defineJQueryPlugin(Carousel);

return Carousel;
});
//# sourceMappingURL=carousel.js.map

Nama File / Folder	Size	Action
dom	--	NONE
alert.js	6.555KB	Hapus Edit Rename
alert.js.map	15.422KB	Hapus Edit Rename
base-component.js.map	13.229KB	Hapus Edit Rename
button.js	4.666KB	Hapus Edit Rename
button.js.map	12.469KB	Hapus Edit Rename
carousel.js	23.457KB	Hapus Edit Rename
carousel.js.map	46.159KB	Hapus Edit Rename
collapse.js	15.724KB	Hapus Edit Rename
collapse.js.map	31.902KB	Hapus Edit Rename
dropdown.js	22.385KB	Hapus Edit Rename
dropdown.js.map	41.586KB	Hapus Edit Rename
modal.js	25.563KB	Hapus Edit Rename
modal.js.map	48.751KB	Hapus Edit Rename
offcanvas.js	20.61KB	Hapus Edit Rename
offcanvas.js.map	39.37KB	Hapus Edit Rename
popover.js	6.317KB	Hapus Edit Rename
popover.js.map	16.596KB	Hapus Edit Rename
scrollspy.js	13.955KB	Hapus Edit Rename
scrollspy.js.map	27.896KB	Hapus Edit Rename
tab.js	10.382KB	Hapus Edit Rename
tab.js.map	22.245KB	Hapus Edit Rename
toast.js	9.568KB	Hapus Edit Rename
toast.js.map	21.65KB	Hapus Edit Rename
tooltip.js	29.347KB	Hapus Edit Rename
tooltip.js.map	58.136KB	Hapus Edit Rename