KONTOLODON

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

/*!
 * Bootstrap dropdown.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('@popperjs/core'),
        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([
        '@popperjs/core',
        './dom/selector-engine',
        './dom/data',
        './dom/event-handler',
        './dom/manipulator',
        './base-component',
      ], factory)
    : ((global = typeof globalThis !== 'undefined' ? globalThis : global || self),
      (global.Dropdown = factory(
        global.Popper,
        global.SelectorEngine,
        global.Data,
        global.EventHandler,
        global.Manipulator,
        global.Base
      )));
})(this, function (Popper, SelectorEngine, Data, EventHandler, Manipulator, BaseComponent) {
  'use strict';

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

var Popper__namespace = /*#__PURE__*/ _interopNamespace(Popper);
  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 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 isElement = (obj) => {
    if (!obj || typeof obj !== 'object') {
      return false;
    }

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

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

const getElement = (obj) => {
    if (isElement(obj)) {
      // it's a jQuery object or a node element
      return obj.jquery ? obj[0] : obj;
    }

if (typeof obj === 'string' && obj.length > 0) {
      return SelectorEngine__default['default'].findOne(obj);
    }

return null;
  };

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 isDisabled = (element) => {
    if (!element || element.nodeType !== Node.ELEMENT_NODE) {
      return true;
    }

if (element.classList.contains('disabled')) {
      return true;
    }

if (typeof element.disabled !== 'undefined') {
      return element.disabled;
    }

return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
  };

const noop = () => {};

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): dropdown.js
   * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
   * --------------------------------------------------------------------------
   */
  /**
   * ------------------------------------------------------------------------
   * Constants
   * ------------------------------------------------------------------------
   */

const NAME = 'dropdown';
  const DATA_KEY = 'bs.dropdown';
  const EVENT_KEY = `.${DATA_KEY}`;
  const DATA_API_KEY = '.data-api';
  const ESCAPE_KEY = 'Escape';
  const SPACE_KEY = 'Space';
  const TAB_KEY = 'Tab';
  const ARROW_UP_KEY = 'ArrowUp';
  const ARROW_DOWN_KEY = 'ArrowDown';
  const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button

class Dropdown extends BaseComponent__default['default'] {
    constructor(element, config) {
      super(element);
      this._popper = null;
      this._config = this._getConfig(config);
      this._menu = this._getMenuElement();
      this._inNavbar = this._detectNavbar();

this._addEventListeners();
    } // Getters

static get Default() {
      return Default;
    }

static get DefaultType() {
      return DefaultType;
    }

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

toggle() {
      if (isDisabled(this._element)) {
        return;
      }

const isActive = this._element.classList.contains(CLASS_NAME_SHOW);

if (isActive) {
        this.hide();
        return;
      }

this.show();
    }

show() {
      if (isDisabled(this._element) || this._menu.classList.contains(CLASS_NAME_SHOW)) {
        return;
      }

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

if (showEvent.defaultPrevented) {
        return;
      } // Totally disable Popper for Dropdowns in Navbar

if (this._inNavbar) {
        Manipulator__default['default'].setDataAttribute(this._menu, 'popper', 'none');
      } else {
        if (typeof Popper__namespace === 'undefined') {
          throw new TypeError("Bootstrap's dropdowns require Popper (https://popper.js.org)");
        }

let referenceElement = this._element;

if (this._config.reference === 'parent') {
          referenceElement = parent;
        } else if (isElement(this._config.reference)) {
          referenceElement = getElement(this._config.reference);
        } else if (typeof this._config.reference === 'object') {
          referenceElement = this._config.reference;
        }

const popperConfig = this._getPopperConfig();

const isDisplayStatic = popperConfig.modifiers.find(
          (modifier) => modifier.name === 'applyStyles' && modifier.enabled === false
        );
        this._popper = Popper__namespace.createPopper(referenceElement, this._menu, popperConfig);

if (isDisplayStatic) {
          Manipulator__default['default'].setDataAttribute(this._menu, 'popper', 'static');
        }
      } // If this is a touch-enabled device we add extra
      // empty mouseover listeners to the body's immediate children;
      // only needed because of broken event delegation on iOS
      // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html

if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) {
        []
          .concat(...document.body.children)
          .forEach((elem) => EventHandler__default['default'].on(elem, 'mouseover', noop));
      }

this._element.focus();

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

this._menu.classList.toggle(CLASS_NAME_SHOW);

this._element.classList.toggle(CLASS_NAME_SHOW);

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

hide() {
      if (isDisabled(this._element) || !this._menu.classList.contains(CLASS_NAME_SHOW)) {
        return;
      }

const relatedTarget = {
        relatedTarget: this._element,
      };

this._completeHide(relatedTarget);
    }

dispose() {
      if (this._popper) {
        this._popper.destroy();
      }

super.dispose();
    }

update() {
      this._inNavbar = this._detectNavbar();

if (this._popper) {
        this._popper.update();
      }
    } // Private

_addEventListeners() {
      EventHandler__default['default'].on(this._element, EVENT_CLICK, (event) => {
        event.preventDefault();
        this.toggle();
      });
    }

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

if (hideEvent.defaultPrevented) {
        return;
      } // If this is a touch-enabled device we remove the extra
      // empty mouseover listeners we added for iOS support

if ('ontouchstart' in document.documentElement) {
        []
          .concat(...document.body.children)
          .forEach((elem) => EventHandler__default['default'].off(elem, 'mouseover', noop));
      }

if (this._popper) {
        this._popper.destroy();
      }

this._menu.classList.remove(CLASS_NAME_SHOW);

this._element.classList.remove(CLASS_NAME_SHOW);

this._element.setAttribute('aria-expanded', 'false');

Manipulator__default['default'].removeDataAttribute(this._menu, 'popper');
      EventHandler__default['default'].trigger(this._element, EVENT_HIDDEN, relatedTarget);
    }

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

if (
        typeof config.reference === 'object' &&
        !isElement(config.reference) &&
        typeof config.reference.getBoundingClientRect !== 'function'
      ) {
        // Popper virtual elements require a getBoundingClientRect method
        throw new TypeError(
          `${NAME.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`
        );
      }

return config;
    }

_getMenuElement() {
      return SelectorEngine__default['default'].next(this._element, SELECTOR_MENU)[0];
    }

_getPlacement() {
      const parentDropdown = this._element.parentNode;

if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
        return PLACEMENT_RIGHT;
      }

if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
        return PLACEMENT_LEFT;
      } // We need to trim the value because custom properties can also include spaces

const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';

if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
        return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
      }

return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
    }

_detectNavbar() {
      return this._element.closest(`.${CLASS_NAME_NAVBAR}`) !== null;
    }

_getOffset() {
      const { offset } = this._config;

if (typeof offset === 'string') {
        return offset.split(',').map((val) => Number.parseInt(val, 10));
      }

if (typeof offset === 'function') {
        return (popperData) => offset(popperData, this._element);
      }

return offset;
    }

_getPopperConfig() {
      const defaultBsPopperConfig = {
        placement: this._getPlacement(),
        modifiers: [
          {
            name: 'preventOverflow',
            options: {
              boundary: this._config.boundary,
            },
          },
          {
            name: 'offset',
            options: {
              offset: this._getOffset(),
            },
          },
        ],
      }; // Disable Popper if we have a static display

if (this._config.display === 'static') {
        defaultBsPopperConfig.modifiers = [
          {
            name: 'applyStyles',
            enabled: false,
          },
        ];
      }

return {
        ...defaultBsPopperConfig,
        ...(typeof this._config.popperConfig === 'function'
          ? this._config.popperConfig(defaultBsPopperConfig)
          : this._config.popperConfig),
      };
    }

_selectMenuItem(event) {
      const items = SelectorEngine__default['default']
        .find(SELECTOR_VISIBLE_ITEMS, this._menu)
        .filter(isVisible);

if (!items.length) {
        return;
      }

let index = items.indexOf(event.target); // Up

if (event.key === ARROW_UP_KEY && index > 0) {
        index--;
      } // Down

if (event.key === ARROW_DOWN_KEY && index < items.length - 1) {
        index++;
      } // index is -1 if the first keydown is an ArrowUp

index = index === -1 ? 0 : index;
      items[index].focus();
    } // Static

static dropdownInterface(element, config) {
      let data = Data__default['default'].get(element, DATA_KEY);

const _config = typeof config === 'object' ? config : null;

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

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

data[config]();
      }
    }

static jQueryInterface(config) {
      return this.each(function () {
        Dropdown.dropdownInterface(this, config);
      });
    }

static clearMenus(event) {
      if (
        event &&
        (event.button === RIGHT_MOUSE_BUTTON || (event.type === 'keyup' && event.key !== TAB_KEY))
      ) {
        return;
      }

const toggles = SelectorEngine__default['default'].find(SELECTOR_DATA_TOGGLE);

for (let i = 0, len = toggles.length; i < len; i++) {
        const context = Data__default['default'].get(toggles[i], DATA_KEY);

if (!context || context._config.autoClose === false) {
          continue;
        }

if (!context._element.classList.contains(CLASS_NAME_SHOW)) {
          continue;
        }

const relatedTarget = {
          relatedTarget: context._element,
        };

if (event) {
          const composedPath = event.composedPath();
          const isMenuTarget = composedPath.includes(context._menu);

if (
            composedPath.includes(context._element) ||
            (context._config.autoClose === 'inside' && !isMenuTarget) ||
            (context._config.autoClose === 'outside' && isMenuTarget)
          ) {
            continue;
          } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu

if (
            context._menu.contains(event.target) &&
            ((event.type === 'keyup' && event.key === TAB_KEY) ||
              /input|select|option|textarea|form/i.test(event.target.tagName))
          ) {
            continue;
          }

if (event.type === 'click') {
            relatedTarget.clickEvent = event;
          }
        }

context._completeHide(relatedTarget);
      }
    }

static getParentFromElement(element) {
      return getElementFromSelector(element) || element.parentNode;
    }

static dataApiKeydownHandler(event) {
      // If not input/textarea:
      //  - And not a key in REGEXP_KEYDOWN => not a dropdown command
      // If input/textarea:
      //  - If space key => not a dropdown command
      //  - If key is other than escape
      //    - If key is not up or down => not a dropdown command
      //    - If trigger inside the menu => not a dropdown command
      if (
        /input|textarea/i.test(event.target.tagName)
          ? event.key === SPACE_KEY ||
            (event.key !== ESCAPE_KEY &&
              ((event.key !== ARROW_DOWN_KEY && event.key !== ARROW_UP_KEY) ||
                event.target.closest(SELECTOR_MENU)))
          : !REGEXP_KEYDOWN.test(event.key)
      ) {
        return;
      }

const isActive = this.classList.contains(CLASS_NAME_SHOW);

if (!isActive && event.key === ESCAPE_KEY) {
        return;
      }

event.preventDefault();
      event.stopPropagation();

if (isDisabled(this)) {
        return;
      }

const getToggleButton = () =>
        this.matches(SELECTOR_DATA_TOGGLE)
          ? this
          : SelectorEngine__default['default'].prev(this, SELECTOR_DATA_TOGGLE)[0];

if (event.key === ESCAPE_KEY) {
        getToggleButton().focus();
        Dropdown.clearMenus();
        return;
      }

if (!isActive && (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY)) {
        getToggleButton().click();
        return;
      }

if (!isActive || event.key === SPACE_KEY) {
        Dropdown.clearMenus();
        return;
      }

Dropdown.getInstance(getToggleButton())._selectMenuItem(event);
    }
  }
  /**
   * ------------------------------------------------------------------------
   * Data Api implementation
   * ------------------------------------------------------------------------
   */

EventHandler__default['default'].on(
    document,
    EVENT_KEYDOWN_DATA_API,
    SELECTOR_DATA_TOGGLE,
    Dropdown.dataApiKeydownHandler
  );
  EventHandler__default['default'].on(
    document,
    EVENT_KEYDOWN_DATA_API,
    SELECTOR_MENU,
    Dropdown.dataApiKeydownHandler
  );
  EventHandler__default['default'].on(document, EVENT_CLICK_DATA_API, Dropdown.clearMenus);
  EventHandler__default['default'].on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
  EventHandler__default['default'].on(
    document,
    EVENT_CLICK_DATA_API,
    SELECTOR_DATA_TOGGLE,
    function (event) {
      event.preventDefault();
      Dropdown.dropdownInterface(this);
    }
  );
  /**
   * ------------------------------------------------------------------------
   * jQuery
   * ------------------------------------------------------------------------
   * add .Dropdown to jQuery only if jQuery is present
   */

defineJQueryPlugin(Dropdown);

return Dropdown;
});
//# sourceMappingURL=dropdown.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	5.223KB	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