KONTOLODON

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

/*!
 * Bootstrap modal.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/event-handler.js'),
        require('./dom/manipulator.js'),
        require('./base-component.js')
      ))
    : typeof define === 'function' && define.amd
    ? define([
        './dom/selector-engine',
        './dom/event-handler',
        './dom/manipulator',
        './base-component',
      ], factory)
    : ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
      (global.Modal = factory(
        global.SelectorEngine,
        global.EventHandler,
        global.Manipulator,
        global.Base
      )));
})(this, function (SelectorEngine, 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 EventHandler__default = /*#__PURE__*/ _interopDefaultLegacy(EventHandler);
  var Manipulator__default = /*#__PURE__*/ _interopDefaultLegacy(Manipulator);
  var BaseComponent__default = /*#__PURE__*/ _interopDefaultLegacy(BaseComponent);

const MILLISECONDS_MULTIPLIER = 1000;
  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 getTransitionDurationFromElement = (element) => {
    if (!element) {
      return 0;
    } // Get transition-duration of the element

let { transitionDuration, transitionDelay } = window.getComputedStyle(element);
    const floatTransitionDuration = Number.parseFloat(transitionDuration);
    const floatTransitionDelay = Number.parseFloat(transitionDelay); // Return 0 if element or transition duration is not found

if (!floatTransitionDuration && !floatTransitionDelay) {
      return 0;
    } // If multiple durations are defined, take the first

transitionDuration = transitionDuration.split(',')[0];
    transitionDelay = transitionDelay.split(',')[0];
    return (
      (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) *
      MILLISECONDS_MULTIPLIER
    );
  };

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 emulateTransitionEnd = (element, duration) => {
    let called = false;
    const durationPadding = 5;
    const emulatedDuration = duration + durationPadding;

function listener() {
      called = true;
      element.removeEventListener(TRANSITION_END, listener);
    }

element.addEventListener(TRANSITION_END, listener);
    setTimeout(() => {
      if (!called) {
        triggerTransitionEnd(element);
      }
    }, emulatedDuration);
  };

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

const execute = (callback) => {
    if (typeof callback === 'function') {
      callback();
    }
  };

/**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.0.1): util/scrollBar.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
  const SELECTOR_STICKY_CONTENT = '.sticky-top';

const getWidth = () => {
    // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
    const documentWidth = document.documentElement.clientWidth;
    return Math.abs(window.innerWidth - documentWidth);
  };

const hide = (width = getWidth()) => {
    _disableOverFlow(); // give padding to element to balances the hidden scrollbar width

_setElementAttributes('body', 'paddingRight', (calculatedValue) => calculatedValue + width); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements, to keep shown fullwidth

_setElementAttributes(
      SELECTOR_FIXED_CONTENT,
      'paddingRight',
      (calculatedValue) => calculatedValue + width
    );

_setElementAttributes(
      SELECTOR_STICKY_CONTENT,
      'marginRight',
      (calculatedValue) => calculatedValue - width
    );
  };

const _disableOverFlow = () => {
    const actualValue = document.body.style.overflow;

if (actualValue) {
      Manipulator__default['default'].setDataAttribute(document.body, 'overflow', actualValue);
    }

document.body.style.overflow = 'hidden';
  };

const _setElementAttributes = (selector, styleProp, callback) => {
    const scrollbarWidth = getWidth();
    SelectorEngine__default['default'].find(selector).forEach((element) => {
      if (element !== document.body && window.innerWidth > element.clientWidth + scrollbarWidth) {
        return;
      }

const actualValue = element.style[styleProp];
      const calculatedValue = window.getComputedStyle(element)[styleProp];
      Manipulator__default['default'].setDataAttribute(element, styleProp, actualValue);
      element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
    });
  };

const reset = () => {
    _resetElementAttributes('body', 'overflow');

_resetElementAttributes('body', 'paddingRight');

_resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');

_resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
  };

const _resetElementAttributes = (selector, styleProp) => {
    SelectorEngine__default['default'].find(selector).forEach((element) => {
      const value = Manipulator__default['default'].getDataAttribute(element, styleProp);

if (typeof value === 'undefined') {
        element.style.removeProperty(styleProp);
      } else {
        Manipulator__default['default'].removeDataAttribute(element, styleProp);
        element.style[styleProp] = value;
      }
    });
  };

/**
   * --------------------------------------------------------------------------
   * Bootstrap (v5.0.1): util/backdrop.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
   * --------------------------------------------------------------------------
   */
  const Default$1 = {
    isVisible: true,
    // if false, we use the backdrop helper without adding any element to the dom
    isAnimated: false,
    rootElement: document.body,
    // give the choice to place backdrop under different elements
    clickCallback: null,
  };
  const DefaultType$1 = {
    isVisible: 'boolean',
    isAnimated: 'boolean',
    rootElement: 'element',
    clickCallback: '(function|null)',
  };
  const NAME$1 = 'backdrop';
  const CLASS_NAME_BACKDROP = 'modal-backdrop';
  const CLASS_NAME_FADE$1 = 'fade';
  const CLASS_NAME_SHOW$1 = 'show';
  const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$1}`;

class Backdrop {
    constructor(config) {
      this._config = this._getConfig(config);
      this._isAppended = false;
      this._element = null;
    }

show(callback) {
      if (!this._config.isVisible) {
        execute(callback);
        return;
      }

this._append();

if (this._config.isAnimated) {
        reflow(this._getElement());
      }

this._getElement().classList.add(CLASS_NAME_SHOW$1);

this._emulateAnimation(() => {
        execute(callback);
      });
    }

hide(callback) {
      if (!this._config.isVisible) {
        execute(callback);
        return;
      }

this._getElement().classList.remove(CLASS_NAME_SHOW$1);

this._emulateAnimation(() => {
        this.dispose();
        execute(callback);
      });
    } // Private

_getElement() {
      if (!this._element) {
        const backdrop = document.createElement('div');
        backdrop.className = CLASS_NAME_BACKDROP;

if (this._config.isAnimated) {
          backdrop.classList.add(CLASS_NAME_FADE$1);
        }

this._element = backdrop;
      }

return this._element;
    }

_getConfig(config) {
      config = { ...Default$1, ...(typeof config === 'object' ? config : {}) };
      config.rootElement = config.rootElement || document.body;
      typeCheckConfig(NAME$1, config, DefaultType$1);
      return config;
    }

_append() {
      if (this._isAppended) {
        return;
      }

this._config.rootElement.appendChild(this._getElement());

EventHandler__default['default'].on(this._getElement(), EVENT_MOUSEDOWN, () => {
        execute(this._config.clickCallback);
      });
      this._isAppended = true;
    }

dispose() {
      if (!this._isAppended) {
        return;
      }

EventHandler__default['default'].off(this._element, EVENT_MOUSEDOWN);

this._getElement().parentNode.removeChild(this._element);

this._isAppended = false;
    }

_emulateAnimation(callback) {
      if (!this._config.isAnimated) {
        execute(callback);
        return;
      }

const backdropTransitionDuration = getTransitionDurationFromElement(this._getElement());
      EventHandler__default['default'].one(this._getElement(), 'transitionend', () =>
        execute(callback)
      );
      emulateTransitionEnd(this._getElement(), backdropTransitionDuration);
    }
  }

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

class Modal extends BaseComponent__default['default'] {
    constructor(element, config) {
      super(element);
      this._config = this._getConfig(config);
      this._dialog = SelectorEngine__default['default'].findOne(SELECTOR_DIALOG, this._element);
      this._backdrop = this._initializeBackDrop();
      this._isShown = false;
      this._ignoreBackdropClick = false;
      this._isTransitioning = false;
    } // Getters

static get Default() {
      return Default;
    }

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

toggle(relatedTarget) {
      return this._isShown ? this.hide() : this.show(relatedTarget);
    }

show(relatedTarget) {
      if (this._isShown || this._isTransitioning) {
        return;
      }

if (this._isAnimated()) {
        this._isTransitioning = true;
      }

const showEvent = EventHandler__default['default'].trigger(this._element, EVENT_SHOW, {
        relatedTarget,
      });

if (this._isShown || showEvent.defaultPrevented) {
        return;
      }

this._isShown = true;
      hide();
      document.body.classList.add(CLASS_NAME_OPEN);

this._adjustDialog();

this._setEscapeEvent();

this._setResizeEvent();

EventHandler__default['default'].on(
        this._element,
        EVENT_CLICK_DISMISS,
        SELECTOR_DATA_DISMISS,
        (event) => this.hide(event)
      );
      EventHandler__default['default'].on(this._dialog, EVENT_MOUSEDOWN_DISMISS, () => {
        EventHandler__default['default'].one(this._element, EVENT_MOUSEUP_DISMISS, (event) => {
          if (event.target === this._element) {
            this._ignoreBackdropClick = true;
          }
        });
      });

this._showBackdrop(() => this._showElement(relatedTarget));
    }

hide(event) {
      if (event) {
        event.preventDefault();
      }

if (!this._isShown || this._isTransitioning) {
        return;
      }

const hideEvent = EventHandler__default['default'].trigger(this._element, EVENT_HIDE);

if (hideEvent.defaultPrevented) {
        return;
      }

this._isShown = false;

const isAnimated = this._isAnimated();

if (isAnimated) {
        this._isTransitioning = true;
      }

this._setEscapeEvent();

this._setResizeEvent();

EventHandler__default['default'].off(document, EVENT_FOCUSIN);

this._element.classList.remove(CLASS_NAME_SHOW);

EventHandler__default['default'].off(this._element, EVENT_CLICK_DISMISS);
      EventHandler__default['default'].off(this._dialog, EVENT_MOUSEDOWN_DISMISS);

this._queueCallback(() => this._hideModal(), this._element, isAnimated);
    }

dispose() {
      [window, this._dialog].forEach((htmlElement) =>
        EventHandler__default['default'].off(htmlElement, EVENT_KEY)
      );

this._backdrop.dispose();

super.dispose();
      /**
       * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API`
       * Do not move `document` in `htmlElements` array
       * It will remove `EVENT_CLICK_DATA_API` event that should remain
       */

EventHandler__default['default'].off(document, EVENT_FOCUSIN);
    }

handleUpdate() {
      this._adjustDialog();
    } // Private

_initializeBackDrop() {
      return new Backdrop({
        isVisible: Boolean(this._config.backdrop),
        // 'static' option will be translated to true, and booleans will keep their value
        isAnimated: this._isAnimated(),
      });
    }

_getConfig(config) {
      config = {
        ...Default,
        ...Manipulator__default['default'].getDataAttributes(this._element),
        ...config,
      };
      typeCheckConfig(NAME, config, DefaultType);
      return config;
    }

_showElement(relatedTarget) {
      const isAnimated = this._isAnimated();

const modalBody = SelectorEngine__default['default'].findOne(
        SELECTOR_MODAL_BODY,
        this._dialog
      );

if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) {
        // Don't move modal's DOM position
        document.body.appendChild(this._element);
      }

this._element.style.display = 'block';

this._element.removeAttribute('aria-hidden');

this._element.setAttribute('aria-modal', true);

this._element.setAttribute('role', 'dialog');

this._element.scrollTop = 0;

if (modalBody) {
        modalBody.scrollTop = 0;
      }

if (isAnimated) {
        reflow(this._element);
      }

this._element.classList.add(CLASS_NAME_SHOW);

if (this._config.focus) {
        this._enforceFocus();
      }

const transitionComplete = () => {
        if (this._config.focus) {
          this._element.focus();
        }

this._isTransitioning = false;
        EventHandler__default['default'].trigger(this._element, EVENT_SHOWN, {
          relatedTarget,
        });
      };

this._queueCallback(transitionComplete, this._dialog, isAnimated);
    }

_enforceFocus() {
      EventHandler__default['default'].off(document, EVENT_FOCUSIN); // guard against infinite focus loop

EventHandler__default['default'].on(document, EVENT_FOCUSIN, (event) => {
        if (
          document !== event.target &&
          this._element !== event.target &&
          !this._element.contains(event.target)
        ) {
          this._element.focus();
        }
      });
    }

_setEscapeEvent() {
      if (this._isShown) {
        EventHandler__default['default'].on(this._element, EVENT_KEYDOWN_DISMISS, (event) => {
          if (this._config.keyboard && event.key === ESCAPE_KEY) {
            event.preventDefault();
            this.hide();
          } else if (!this._config.keyboard && event.key === ESCAPE_KEY) {
            this._triggerBackdropTransition();
          }
        });
      } else {
        EventHandler__default['default'].off(this._element, EVENT_KEYDOWN_DISMISS);
      }
    }

_setResizeEvent() {
      if (this._isShown) {
        EventHandler__default['default'].on(window, EVENT_RESIZE, () => this._adjustDialog());
      } else {
        EventHandler__default['default'].off(window, EVENT_RESIZE);
      }
    }

_hideModal() {
      this._element.style.display = 'none';

this._element.setAttribute('aria-hidden', true);

this._element.removeAttribute('aria-modal');

this._element.removeAttribute('role');

this._isTransitioning = false;

this._backdrop.hide(() => {
        document.body.classList.remove(CLASS_NAME_OPEN);

this._resetAdjustments();

reset();
        EventHandler__default['default'].trigger(this._element, EVENT_HIDDEN);
      });
    }

_showBackdrop(callback) {
      EventHandler__default['default'].on(this._element, EVENT_CLICK_DISMISS, (event) => {
        if (this._ignoreBackdropClick) {
          this._ignoreBackdropClick = false;
          return;
        }

if (event.target !== event.currentTarget) {
          return;
        }

if (this._config.backdrop === true) {
          this.hide();
        } else if (this._config.backdrop === 'static') {
          this._triggerBackdropTransition();
        }
      });

this._backdrop.show(callback);
    }

_isAnimated() {
      return this._element.classList.contains(CLASS_NAME_FADE);
    }

_triggerBackdropTransition() {
      const hideEvent = EventHandler__default['default'].trigger(
        this._element,
        EVENT_HIDE_PREVENTED
      );

if (hideEvent.defaultPrevented) {
        return;
      }

const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;

if (!isModalOverflowing) {
        this._element.style.overflowY = 'hidden';
      }

this._element.classList.add(CLASS_NAME_STATIC);

const modalTransitionDuration = getTransitionDurationFromElement(this._dialog);
      EventHandler__default['default'].off(this._element, 'transitionend');
      EventHandler__default['default'].one(this._element, 'transitionend', () => {
        this._element.classList.remove(CLASS_NAME_STATIC);

if (!isModalOverflowing) {
          EventHandler__default['default'].one(this._element, 'transitionend', () => {
            this._element.style.overflowY = '';
          });
          emulateTransitionEnd(this._element, modalTransitionDuration);
        }
      });
      emulateTransitionEnd(this._element, modalTransitionDuration);

this._element.focus();
    } // ----------------------------------------------------------------------
    // the following methods are used to handle overflowing modals
    // ----------------------------------------------------------------------

_adjustDialog() {
      const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
      const scrollbarWidth = getWidth();
      const isBodyOverflowing = scrollbarWidth > 0;

if (
        (!isBodyOverflowing && isModalOverflowing && !isRTL()) ||
        (isBodyOverflowing && !isModalOverflowing && isRTL())
      ) {
        this._element.style.paddingLeft = `${scrollbarWidth}px`;
      }

if (
        (isBodyOverflowing && !isModalOverflowing && !isRTL()) ||
        (!isBodyOverflowing && isModalOverflowing && isRTL())
      ) {
        this._element.style.paddingRight = `${scrollbarWidth}px`;
      }
    }

_resetAdjustments() {
      this._element.style.paddingLeft = '';
      this._element.style.paddingRight = '';
    } // Static

static jQueryInterface(config, relatedTarget) {
      return this.each(function () {
        const data =
          Modal.getInstance(this) || new Modal(this, typeof config === 'object' ? config : {});

if (typeof config !== 'string') {
          return;
        }

if (typeof data[config] === 'undefined') {
          throw new TypeError(`No method named "${config}"`);
        }

data[config](relatedTarget);
      });
    }
  }
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */

EventHandler__default['default'].on(
    document,
    EVENT_CLICK_DATA_API,
    SELECTOR_DATA_TOGGLE,
    function (event) {
      const target = getElementFromSelector(this);

if (['A', 'AREA'].includes(this.tagName)) {
        event.preventDefault();
      }

EventHandler__default['default'].one(target, EVENT_SHOW, (showEvent) => {
        if (showEvent.defaultPrevented) {
          // only register focus restorer if modal will actually get shown
          return;
        }

EventHandler__default['default'].one(target, EVENT_HIDDEN, () => {
          if (isVisible(this)) {
            this.focus();
          }
        });
      });
      const data = Modal.getInstance(target) || new Modal(target);
      data.toggle(this);
    }
  );
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Modal to jQuery only if jQuery is present
   */

defineJQueryPlugin(Modal);

return Modal;
});
//# sourceMappingURL=modal.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