mumuki-styles 3.0.2 → 3.0.4

Sign up to get free protection for your applications and to get access to all the features.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: df25ce32e60a6f262122561c4f76eb8619f3dae9e2f7760074241aa60987f7ab
4
- data.tar.gz: 906bb4417270e19ee0f6f565c09fe239101502ae7aa46976c6ca858337fe6985
3
+ metadata.gz: 783d9d916a877ac1dd94e66788e15efd779a6c7d3659506cb35ea356360aaa02
4
+ data.tar.gz: 82319987d0ee6d422ac80089bd2d48b7a253031b54d73e682765875f2edb144a
5
5
  SHA512:
6
- metadata.gz: d9c7363fb8a2038d4c8796012af9a63d2adf068828cbf6b7c55c3fe1226756f5950441127e0669277bb470a670dbbf787d67cac138154f878993a152b636eaee
7
- data.tar.gz: f147753c6e913838dbf62bca4d5d89900bf04d1ea718a92af897574bae723a9eaccfb1473ce48441408896bf252d175a9123bcd6cbb9159ac92ddc08b772c57f
6
+ metadata.gz: '0108487d02fc5c3621c02fbb1b3f3df596e306eecc8aaa4bb964957c2955ffb47c87e2c28d7df9ab825d1bafdfa30a58004bd063c01108dd928bd1ac698a9f16'
7
+ data.tar.gz: eb2fcf005ca4c5a69d4d1b9ecddb626d06e409d6e56d0588c5df303feaf4947d0140dbf4ad4584ee78799724c7ceae63ce155d668985e8307e94cdfb8857b18e
Binary file
Binary file
Binary file
Binary file
@@ -10220,7 +10220,7 @@ return jQuery;
10220
10220
  } );
10221
10221
 
10222
10222
  /**
10223
- * @popperjs/core v2.9.1 - MIT License
10223
+ * @popperjs/core v2.9.2 - MIT License
10224
10224
  */
10225
10225
 
10226
10226
  (function (global, factory) {
@@ -10473,6 +10473,17 @@ return jQuery;
10473
10473
 
10474
10474
  function getContainingBlock(element) {
10475
10475
  var isFirefox = navigator.userAgent.toLowerCase().indexOf('firefox') !== -1;
10476
+ var isIE = navigator.userAgent.indexOf('Trident') !== -1;
10477
+
10478
+ if (isIE && isHTMLElement(element)) {
10479
+ // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport
10480
+ var elementCss = getComputedStyle(element);
10481
+
10482
+ if (elementCss.position === 'fixed') {
10483
+ return null;
10484
+ }
10485
+ }
10486
+
10476
10487
  var currentNode = getParentNode(element);
10477
10488
 
10478
10489
  while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) {
@@ -12121,7 +12132,7 @@ return jQuery;
12121
12132
  //# sourceMappingURL=popper.js.map
12122
12133
 
12123
12134
  /*!
12124
- * Bootstrap v5.0.0-beta3 (https://getbootstrap.com/)
12135
+ * Bootstrap v5.0.1 (https://getbootstrap.com/)
12125
12136
  * Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
12126
12137
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12127
12138
  */
@@ -12155,10 +12166,82 @@ return jQuery;
12155
12166
 
12156
12167
  /**
12157
12168
  * --------------------------------------------------------------------------
12158
- * Bootstrap (v5.0.0-beta3): util/index.js
12169
+ * Bootstrap (v5.0.1): dom/selector-engine.js
12170
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12171
+ * --------------------------------------------------------------------------
12172
+ */
12173
+
12174
+ /**
12175
+ * ------------------------------------------------------------------------
12176
+ * Constants
12177
+ * ------------------------------------------------------------------------
12178
+ */
12179
+ const NODE_TEXT = 3;
12180
+ const SelectorEngine = {
12181
+ find(selector, element = document.documentElement) {
12182
+ return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
12183
+ },
12184
+
12185
+ findOne(selector, element = document.documentElement) {
12186
+ return Element.prototype.querySelector.call(element, selector);
12187
+ },
12188
+
12189
+ children(element, selector) {
12190
+ return [].concat(...element.children).filter(child => child.matches(selector));
12191
+ },
12192
+
12193
+ parents(element, selector) {
12194
+ const parents = [];
12195
+ let ancestor = element.parentNode;
12196
+
12197
+ while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
12198
+ if (ancestor.matches(selector)) {
12199
+ parents.push(ancestor);
12200
+ }
12201
+
12202
+ ancestor = ancestor.parentNode;
12203
+ }
12204
+
12205
+ return parents;
12206
+ },
12207
+
12208
+ prev(element, selector) {
12209
+ let previous = element.previousElementSibling;
12210
+
12211
+ while (previous) {
12212
+ if (previous.matches(selector)) {
12213
+ return [previous];
12214
+ }
12215
+
12216
+ previous = previous.previousElementSibling;
12217
+ }
12218
+
12219
+ return [];
12220
+ },
12221
+
12222
+ next(element, selector) {
12223
+ let next = element.nextElementSibling;
12224
+
12225
+ while (next) {
12226
+ if (next.matches(selector)) {
12227
+ return [next];
12228
+ }
12229
+
12230
+ next = next.nextElementSibling;
12231
+ }
12232
+
12233
+ return [];
12234
+ }
12235
+
12236
+ };
12237
+
12238
+ /**
12239
+ * --------------------------------------------------------------------------
12240
+ * Bootstrap (v5.0.1): util/index.js
12159
12241
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12160
12242
  * --------------------------------------------------------------------------
12161
12243
  */
12244
+
12162
12245
  const MAX_UID = 1000000;
12163
12246
  const MILLISECONDS_MULTIPLIER = 1000;
12164
12247
  const TRANSITION_END = 'transitionend'; // Shoutout AngusCroll (https://goo.gl/pxwQGp)
@@ -12200,7 +12283,7 @@ return jQuery;
12200
12283
 
12201
12284
 
12202
12285
  if (hrefAttr.includes('#') && !hrefAttr.startsWith('#')) {
12203
- hrefAttr = '#' + hrefAttr.split('#')[1];
12286
+ hrefAttr = `#${hrefAttr.split('#')[1]}`;
12204
12287
  }
12205
12288
 
12206
12289
  selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
@@ -12251,7 +12334,30 @@ return jQuery;
12251
12334
  element.dispatchEvent(new Event(TRANSITION_END));
12252
12335
  };
12253
12336
 
12254
- const isElement = obj => (obj[0] || obj).nodeType;
12337
+ const isElement = obj => {
12338
+ if (!obj || typeof obj !== 'object') {
12339
+ return false;
12340
+ }
12341
+
12342
+ if (typeof obj.jquery !== 'undefined') {
12343
+ obj = obj[0];
12344
+ }
12345
+
12346
+ return typeof obj.nodeType !== 'undefined';
12347
+ };
12348
+
12349
+ const getElement = obj => {
12350
+ if (isElement(obj)) {
12351
+ // it's a jQuery object or a node element
12352
+ return obj.jquery ? obj[0] : obj;
12353
+ }
12354
+
12355
+ if (typeof obj === 'string' && obj.length > 0) {
12356
+ return SelectorEngine.findOne(obj);
12357
+ }
12358
+
12359
+ return null;
12360
+ };
12255
12361
 
12256
12362
  const emulateTransitionEnd = (element, duration) => {
12257
12363
  let called = false;
@@ -12278,7 +12384,7 @@ return jQuery;
12278
12384
  const valueType = value && isElement(value) ? 'element' : toType(value);
12279
12385
 
12280
12386
  if (!new RegExp(expectedTypes).test(valueType)) {
12281
- throw new TypeError(`${componentName.toUpperCase()}: ` + `Option "${property}" provided type "${valueType}" ` + `but expected type "${expectedTypes}".`);
12387
+ throw new TypeError(`${componentName.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
12282
12388
  }
12283
12389
  });
12284
12390
  };
@@ -12336,7 +12442,7 @@ return jQuery;
12336
12442
  return findShadowRoot(element.parentNode);
12337
12443
  };
12338
12444
 
12339
- const noop = () => function () {};
12445
+ const noop = () => {};
12340
12446
 
12341
12447
  const reflow = element => element.offsetHeight;
12342
12448
 
@@ -12362,12 +12468,13 @@ return jQuery;
12362
12468
 
12363
12469
  const isRTL = () => document.documentElement.dir === 'rtl';
12364
12470
 
12365
- const defineJQueryPlugin = (name, plugin) => {
12471
+ const defineJQueryPlugin = plugin => {
12366
12472
  onDOMContentLoaded(() => {
12367
12473
  const $ = getjQuery();
12368
12474
  /* istanbul ignore if */
12369
12475
 
12370
12476
  if ($) {
12477
+ const name = plugin.NAME;
12371
12478
  const JQUERY_NO_CONFLICT = $.fn[name];
12372
12479
  $.fn[name] = plugin.jQueryInterface;
12373
12480
  $.fn[name].Constructor = plugin;
@@ -12380,9 +12487,15 @@ return jQuery;
12380
12487
  });
12381
12488
  };
12382
12489
 
12490
+ const execute = callback => {
12491
+ if (typeof callback === 'function') {
12492
+ callback();
12493
+ }
12494
+ };
12495
+
12383
12496
  /**
12384
12497
  * --------------------------------------------------------------------------
12385
- * Bootstrap (v5.0.0-beta3): dom/data.js
12498
+ * Bootstrap (v5.0.1): dom/data.js
12386
12499
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12387
12500
  * --------------------------------------------------------------------------
12388
12501
  */
@@ -12436,7 +12549,7 @@ return jQuery;
12436
12549
 
12437
12550
  /**
12438
12551
  * --------------------------------------------------------------------------
12439
- * Bootstrap (v5.0.0-beta3): dom/event-handler.js
12552
+ * Bootstrap (v5.0.1): dom/event-handler.js
12440
12553
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12441
12554
  * --------------------------------------------------------------------------
12442
12555
  */
@@ -12456,6 +12569,7 @@ return jQuery;
12456
12569
  mouseenter: 'mouseover',
12457
12570
  mouseleave: 'mouseout'
12458
12571
  };
12572
+ const customEventsRegex = /^(mouseenter|mouseleave)/i;
12459
12573
  const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']);
12460
12574
  /**
12461
12575
  * ------------------------------------------------------------------------
@@ -12499,7 +12613,7 @@ return jQuery;
12499
12613
 
12500
12614
  if (handler.oneOff) {
12501
12615
  // eslint-disable-next-line unicorn/consistent-destructuring
12502
- EventHandler.off(element, event.type, fn);
12616
+ EventHandler.off(element, event.type, selector, fn);
12503
12617
  }
12504
12618
 
12505
12619
  return fn.apply(target, [event]);
@@ -12528,15 +12642,8 @@ return jQuery;
12528
12642
 
12529
12643
  function normalizeParams(originalTypeEvent, handler, delegationFn) {
12530
12644
  const delegation = typeof handler === 'string';
12531
- const originalHandler = delegation ? delegationFn : handler; // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
12532
-
12533
- let typeEvent = originalTypeEvent.replace(stripNameRegex, '');
12534
- const custom = customEvents[typeEvent];
12535
-
12536
- if (custom) {
12537
- typeEvent = custom;
12538
- }
12539
-
12645
+ const originalHandler = delegation ? delegationFn : handler;
12646
+ let typeEvent = getTypeEvent(originalTypeEvent);
12540
12647
  const isNative = nativeEvents.has(typeEvent);
12541
12648
 
12542
12649
  if (!isNative) {
@@ -12554,6 +12661,24 @@ return jQuery;
12554
12661
  if (!handler) {
12555
12662
  handler = delegationFn;
12556
12663
  delegationFn = null;
12664
+ } // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
12665
+ // this prevents the handler from being dispatched the same way as mouseover or mouseout does
12666
+
12667
+
12668
+ if (customEventsRegex.test(originalTypeEvent)) {
12669
+ const wrapFn = fn => {
12670
+ return function (event) {
12671
+ if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
12672
+ return fn.call(this, event);
12673
+ }
12674
+ };
12675
+ };
12676
+
12677
+ if (delegationFn) {
12678
+ delegationFn = wrapFn(delegationFn);
12679
+ } else {
12680
+ handler = wrapFn(handler);
12681
+ }
12557
12682
  }
12558
12683
 
12559
12684
  const [delegation, originalHandler, typeEvent] = normalizeParams(originalTypeEvent, handler, delegationFn);
@@ -12597,6 +12722,12 @@ return jQuery;
12597
12722
  });
12598
12723
  }
12599
12724
 
12725
+ function getTypeEvent(event) {
12726
+ // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
12727
+ event = event.replace(stripNameRegex, '');
12728
+ return customEvents[event] || event;
12729
+ }
12730
+
12600
12731
  const EventHandler = {
12601
12732
  on(element, event, handler, delegationFn) {
12602
12733
  addHandler(element, event, handler, delegationFn, false);
@@ -12649,7 +12780,7 @@ return jQuery;
12649
12780
  }
12650
12781
 
12651
12782
  const $ = getjQuery();
12652
- const typeEvent = event.replace(stripNameRegex, '');
12783
+ const typeEvent = getTypeEvent(event);
12653
12784
  const inNamespace = event !== typeEvent;
12654
12785
  const isNative = nativeEvents.has(typeEvent);
12655
12786
  let jQueryEvent;
@@ -12707,7 +12838,7 @@ return jQuery;
12707
12838
 
12708
12839
  /**
12709
12840
  * --------------------------------------------------------------------------
12710
- * Bootstrap (v5.0.0-beta3): base-component.js
12841
+ * Bootstrap (v5.0.1): base-component.js
12711
12842
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12712
12843
  * --------------------------------------------------------------------------
12713
12844
  */
@@ -12717,11 +12848,11 @@ return jQuery;
12717
12848
  * ------------------------------------------------------------------------
12718
12849
  */
12719
12850
 
12720
- const VERSION = '5.0.0-beta3';
12851
+ const VERSION = '5.0.1';
12721
12852
 
12722
12853
  class BaseComponent {
12723
12854
  constructor(element) {
12724
- element = typeof element === 'string' ? document.querySelector(element) : element;
12855
+ element = getElement(element);
12725
12856
 
12726
12857
  if (!element) {
12727
12858
  return;
@@ -12733,7 +12864,21 @@ return jQuery;
12733
12864
 
12734
12865
  dispose() {
12735
12866
  Data.remove(this._element, this.constructor.DATA_KEY);
12736
- this._element = null;
12867
+ EventHandler.off(this._element, this.constructor.EVENT_KEY);
12868
+ Object.getOwnPropertyNames(this).forEach(propertyName => {
12869
+ this[propertyName] = null;
12870
+ });
12871
+ }
12872
+
12873
+ _queueCallback(callback, element, isAnimated = true) {
12874
+ if (!isAnimated) {
12875
+ execute(callback);
12876
+ return;
12877
+ }
12878
+
12879
+ const transitionDuration = getTransitionDurationFromElement(element);
12880
+ EventHandler.one(element, 'transitionend', () => execute(callback));
12881
+ emulateTransitionEnd(element, transitionDuration);
12737
12882
  }
12738
12883
  /** Static */
12739
12884
 
@@ -12746,11 +12891,23 @@ return jQuery;
12746
12891
  return VERSION;
12747
12892
  }
12748
12893
 
12894
+ static get NAME() {
12895
+ throw new Error('You have to implement the static method "NAME", for each component!');
12896
+ }
12897
+
12898
+ static get DATA_KEY() {
12899
+ return `bs.${this.NAME}`;
12900
+ }
12901
+
12902
+ static get EVENT_KEY() {
12903
+ return `.${this.DATA_KEY}`;
12904
+ }
12905
+
12749
12906
  }
12750
12907
 
12751
12908
  /**
12752
12909
  * --------------------------------------------------------------------------
12753
- * Bootstrap (v5.0.0-beta3): alert.js
12910
+ * Bootstrap (v5.0.1): alert.js
12754
12911
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12755
12912
  * --------------------------------------------------------------------------
12756
12913
  */
@@ -12760,7 +12917,7 @@ return jQuery;
12760
12917
  * ------------------------------------------------------------------------
12761
12918
  */
12762
12919
 
12763
- const NAME$b = 'alert';
12920
+ const NAME$c = 'alert';
12764
12921
  const DATA_KEY$b = 'bs.alert';
12765
12922
  const EVENT_KEY$b = `.${DATA_KEY$b}`;
12766
12923
  const DATA_API_KEY$8 = '.data-api';
@@ -12769,8 +12926,8 @@ return jQuery;
12769
12926
  const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
12770
12927
  const EVENT_CLICK_DATA_API$7 = `click${EVENT_KEY$b}${DATA_API_KEY$8}`;
12771
12928
  const CLASS_NAME_ALERT = 'alert';
12772
- const CLASS_NAME_FADE$5 = 'fade';
12773
- const CLASS_NAME_SHOW$8 = 'show';
12929
+ const CLASS_NAME_FADE$6 = 'fade';
12930
+ const CLASS_NAME_SHOW$9 = 'show';
12774
12931
  /**
12775
12932
  * ------------------------------------------------------------------------
12776
12933
  * Class Definition
@@ -12779,8 +12936,8 @@ return jQuery;
12779
12936
 
12780
12937
  class Alert extends BaseComponent {
12781
12938
  // Getters
12782
- static get DATA_KEY() {
12783
- return DATA_KEY$b;
12939
+ static get NAME() {
12940
+ return NAME$c;
12784
12941
  } // Public
12785
12942
 
12786
12943
 
@@ -12806,17 +12963,10 @@ return jQuery;
12806
12963
  }
12807
12964
 
12808
12965
  _removeElement(element) {
12809
- element.classList.remove(CLASS_NAME_SHOW$8);
12810
-
12811
- if (!element.classList.contains(CLASS_NAME_FADE$5)) {
12812
- this._destroyElement(element);
12966
+ element.classList.remove(CLASS_NAME_SHOW$9);
12967
+ const isAnimated = element.classList.contains(CLASS_NAME_FADE$6);
12813
12968
 
12814
- return;
12815
- }
12816
-
12817
- const transitionDuration = getTransitionDurationFromElement(element);
12818
- EventHandler.one(element, 'transitionend', () => this._destroyElement(element));
12819
- emulateTransitionEnd(element, transitionDuration);
12969
+ this._queueCallback(() => this._destroyElement(element), element, isAnimated);
12820
12970
  }
12821
12971
 
12822
12972
  _destroyElement(element) {
@@ -12868,11 +13018,11 @@ return jQuery;
12868
13018
  * add .Alert to jQuery only if jQuery is present
12869
13019
  */
12870
13020
 
12871
- defineJQueryPlugin(NAME$b, Alert);
13021
+ defineJQueryPlugin(Alert);
12872
13022
 
12873
13023
  /**
12874
13024
  * --------------------------------------------------------------------------
12875
- * Bootstrap (v5.0.0-beta3): button.js
13025
+ * Bootstrap (v5.0.1): button.js
12876
13026
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12877
13027
  * --------------------------------------------------------------------------
12878
13028
  */
@@ -12882,7 +13032,7 @@ return jQuery;
12882
13032
  * ------------------------------------------------------------------------
12883
13033
  */
12884
13034
 
12885
- const NAME$a = 'button';
13035
+ const NAME$b = 'button';
12886
13036
  const DATA_KEY$a = 'bs.button';
12887
13037
  const EVENT_KEY$a = `.${DATA_KEY$a}`;
12888
13038
  const DATA_API_KEY$7 = '.data-api';
@@ -12897,8 +13047,8 @@ return jQuery;
12897
13047
 
12898
13048
  class Button extends BaseComponent {
12899
13049
  // Getters
12900
- static get DATA_KEY() {
12901
- return DATA_KEY$a;
13050
+ static get NAME() {
13051
+ return NAME$b;
12902
13052
  } // Public
12903
13053
 
12904
13054
 
@@ -12948,11 +13098,11 @@ return jQuery;
12948
13098
  * add .Button to jQuery only if jQuery is present
12949
13099
  */
12950
13100
 
12951
- defineJQueryPlugin(NAME$a, Button);
13101
+ defineJQueryPlugin(Button);
12952
13102
 
12953
13103
  /**
12954
13104
  * --------------------------------------------------------------------------
12955
- * Bootstrap (v5.0.0-beta3): dom/manipulator.js
13105
+ * Bootstrap (v5.0.1): dom/manipulator.js
12956
13106
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12957
13107
  * --------------------------------------------------------------------------
12958
13108
  */
@@ -13026,78 +13176,7 @@ return jQuery;
13026
13176
 
13027
13177
  /**
13028
13178
  * --------------------------------------------------------------------------
13029
- * Bootstrap (v5.0.0-beta3): dom/selector-engine.js
13030
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
13031
- * --------------------------------------------------------------------------
13032
- */
13033
-
13034
- /**
13035
- * ------------------------------------------------------------------------
13036
- * Constants
13037
- * ------------------------------------------------------------------------
13038
- */
13039
- const NODE_TEXT = 3;
13040
- const SelectorEngine = {
13041
- find(selector, element = document.documentElement) {
13042
- return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
13043
- },
13044
-
13045
- findOne(selector, element = document.documentElement) {
13046
- return Element.prototype.querySelector.call(element, selector);
13047
- },
13048
-
13049
- children(element, selector) {
13050
- return [].concat(...element.children).filter(child => child.matches(selector));
13051
- },
13052
-
13053
- parents(element, selector) {
13054
- const parents = [];
13055
- let ancestor = element.parentNode;
13056
-
13057
- while (ancestor && ancestor.nodeType === Node.ELEMENT_NODE && ancestor.nodeType !== NODE_TEXT) {
13058
- if (ancestor.matches(selector)) {
13059
- parents.push(ancestor);
13060
- }
13061
-
13062
- ancestor = ancestor.parentNode;
13063
- }
13064
-
13065
- return parents;
13066
- },
13067
-
13068
- prev(element, selector) {
13069
- let previous = element.previousElementSibling;
13070
-
13071
- while (previous) {
13072
- if (previous.matches(selector)) {
13073
- return [previous];
13074
- }
13075
-
13076
- previous = previous.previousElementSibling;
13077
- }
13078
-
13079
- return [];
13080
- },
13081
-
13082
- next(element, selector) {
13083
- let next = element.nextElementSibling;
13084
-
13085
- while (next) {
13086
- if (next.matches(selector)) {
13087
- return [next];
13088
- }
13089
-
13090
- next = next.nextElementSibling;
13091
- }
13092
-
13093
- return [];
13094
- }
13095
-
13096
- };
13097
-
13098
- /**
13099
- * --------------------------------------------------------------------------
13100
- * Bootstrap (v5.0.0-beta3): carousel.js
13179
+ * Bootstrap (v5.0.1): carousel.js
13101
13180
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
13102
13181
  * --------------------------------------------------------------------------
13103
13182
  */
@@ -13107,7 +13186,7 @@ return jQuery;
13107
13186
  * ------------------------------------------------------------------------
13108
13187
  */
13109
13188
 
13110
- const NAME$9 = 'carousel';
13189
+ const NAME$a = 'carousel';
13111
13190
  const DATA_KEY$9 = 'bs.carousel';
13112
13191
  const EVENT_KEY$9 = `.${DATA_KEY$9}`;
13113
13192
  const DATA_API_KEY$6 = '.data-api';
@@ -13116,7 +13195,7 @@ return jQuery;
13116
13195
  const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
13117
13196
 
13118
13197
  const SWIPE_THRESHOLD = 40;
13119
- const Default$8 = {
13198
+ const Default$9 = {
13120
13199
  interval: 5000,
13121
13200
  keyboard: true,
13122
13201
  slide: false,
@@ -13124,7 +13203,7 @@ return jQuery;
13124
13203
  wrap: true,
13125
13204
  touch: true
13126
13205
  };
13127
- const DefaultType$8 = {
13206
+ const DefaultType$9 = {
13128
13207
  interval: '(number|boolean)',
13129
13208
  keyboard: 'boolean',
13130
13209
  slide: '(boolean|string)',
@@ -13195,11 +13274,11 @@ return jQuery;
13195
13274
 
13196
13275
 
13197
13276
  static get Default() {
13198
- return Default$8;
13277
+ return Default$9;
13199
13278
  }
13200
13279
 
13201
- static get DATA_KEY() {
13202
- return DATA_KEY$9;
13280
+ static get NAME() {
13281
+ return NAME$a;
13203
13282
  } // Public
13204
13283
 
13205
13284
 
@@ -13277,26 +13356,14 @@ return jQuery;
13277
13356
  const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
13278
13357
 
13279
13358
  this._slide(order, this._items[index]);
13280
- }
13281
-
13282
- dispose() {
13283
- EventHandler.off(this._element, EVENT_KEY$9);
13284
- this._items = null;
13285
- this._config = null;
13286
- this._interval = null;
13287
- this._isPaused = null;
13288
- this._isSliding = null;
13289
- this._activeElement = null;
13290
- this._indicatorsElement = null;
13291
- super.dispose();
13292
13359
  } // Private
13293
13360
 
13294
13361
 
13295
13362
  _getConfig(config) {
13296
- config = { ...Default$8,
13363
+ config = { ...Default$9,
13297
13364
  ...config
13298
13365
  };
13299
- typeCheckConfig(NAME$9, config, DefaultType$8);
13366
+ typeCheckConfig(NAME$a, config, DefaultType$9);
13300
13367
  return config;
13301
13368
  }
13302
13369
 
@@ -13395,11 +13462,11 @@ return jQuery;
13395
13462
  if (event.key === ARROW_LEFT_KEY) {
13396
13463
  event.preventDefault();
13397
13464
 
13398
- this._slide(DIRECTION_LEFT);
13465
+ this._slide(DIRECTION_RIGHT);
13399
13466
  } else if (event.key === ARROW_RIGHT_KEY) {
13400
13467
  event.preventDefault();
13401
13468
 
13402
- this._slide(DIRECTION_RIGHT);
13469
+ this._slide(DIRECTION_LEFT);
13403
13470
  }
13404
13471
  }
13405
13472
 
@@ -13517,37 +13584,35 @@ return jQuery;
13517
13584
 
13518
13585
  this._activeElement = nextElement;
13519
13586
 
13587
+ const triggerSlidEvent = () => {
13588
+ EventHandler.trigger(this._element, EVENT_SLID, {
13589
+ relatedTarget: nextElement,
13590
+ direction: eventDirectionName,
13591
+ from: activeElementIndex,
13592
+ to: nextElementIndex
13593
+ });
13594
+ };
13595
+
13520
13596
  if (this._element.classList.contains(CLASS_NAME_SLIDE)) {
13521
13597
  nextElement.classList.add(orderClassName);
13522
13598
  reflow(nextElement);
13523
13599
  activeElement.classList.add(directionalClassName);
13524
13600
  nextElement.classList.add(directionalClassName);
13525
- const transitionDuration = getTransitionDurationFromElement(activeElement);
13526
- EventHandler.one(activeElement, 'transitionend', () => {
13601
+
13602
+ const completeCallBack = () => {
13527
13603
  nextElement.classList.remove(directionalClassName, orderClassName);
13528
13604
  nextElement.classList.add(CLASS_NAME_ACTIVE$2);
13529
13605
  activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
13530
13606
  this._isSliding = false;
13531
- setTimeout(() => {
13532
- EventHandler.trigger(this._element, EVENT_SLID, {
13533
- relatedTarget: nextElement,
13534
- direction: eventDirectionName,
13535
- from: activeElementIndex,
13536
- to: nextElementIndex
13537
- });
13538
- }, 0);
13539
- });
13540
- emulateTransitionEnd(activeElement, transitionDuration);
13607
+ setTimeout(triggerSlidEvent, 0);
13608
+ };
13609
+
13610
+ this._queueCallback(completeCallBack, activeElement, true);
13541
13611
  } else {
13542
13612
  activeElement.classList.remove(CLASS_NAME_ACTIVE$2);
13543
13613
  nextElement.classList.add(CLASS_NAME_ACTIVE$2);
13544
13614
  this._isSliding = false;
13545
- EventHandler.trigger(this._element, EVENT_SLID, {
13546
- relatedTarget: nextElement,
13547
- direction: eventDirectionName,
13548
- from: activeElementIndex,
13549
- to: nextElementIndex
13550
- });
13615
+ triggerSlidEvent();
13551
13616
  }
13552
13617
 
13553
13618
  if (isCycling) {
@@ -13561,10 +13626,10 @@ return jQuery;
13561
13626
  }
13562
13627
 
13563
13628
  if (isRTL()) {
13564
- return direction === DIRECTION_RIGHT ? ORDER_PREV : ORDER_NEXT;
13629
+ return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
13565
13630
  }
13566
13631
 
13567
- return direction === DIRECTION_RIGHT ? ORDER_NEXT : ORDER_PREV;
13632
+ return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
13568
13633
  }
13569
13634
 
13570
13635
  _orderToDirection(order) {
@@ -13573,16 +13638,16 @@ return jQuery;
13573
13638
  }
13574
13639
 
13575
13640
  if (isRTL()) {
13576
- return order === ORDER_NEXT ? DIRECTION_LEFT : DIRECTION_RIGHT;
13641
+ return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
13577
13642
  }
13578
13643
 
13579
- return order === ORDER_NEXT ? DIRECTION_RIGHT : DIRECTION_LEFT;
13644
+ return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
13580
13645
  } // Static
13581
13646
 
13582
13647
 
13583
13648
  static carouselInterface(element, config) {
13584
13649
  let data = Data.get(element, DATA_KEY$9);
13585
- let _config = { ...Default$8,
13650
+ let _config = { ...Default$9,
13586
13651
  ...Manipulator.getDataAttributes(element)
13587
13652
  };
13588
13653
 
@@ -13666,11 +13731,11 @@ return jQuery;
13666
13731
  * add .Carousel to jQuery only if jQuery is present
13667
13732
  */
13668
13733
 
13669
- defineJQueryPlugin(NAME$9, Carousel);
13734
+ defineJQueryPlugin(Carousel);
13670
13735
 
13671
13736
  /**
13672
13737
  * --------------------------------------------------------------------------
13673
- * Bootstrap (v5.0.0-beta3): collapse.js
13738
+ * Bootstrap (v5.0.1): collapse.js
13674
13739
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
13675
13740
  * --------------------------------------------------------------------------
13676
13741
  */
@@ -13680,15 +13745,15 @@ return jQuery;
13680
13745
  * ------------------------------------------------------------------------
13681
13746
  */
13682
13747
 
13683
- const NAME$8 = 'collapse';
13748
+ const NAME$9 = 'collapse';
13684
13749
  const DATA_KEY$8 = 'bs.collapse';
13685
13750
  const EVENT_KEY$8 = `.${DATA_KEY$8}`;
13686
13751
  const DATA_API_KEY$5 = '.data-api';
13687
- const Default$7 = {
13752
+ const Default$8 = {
13688
13753
  toggle: true,
13689
13754
  parent: ''
13690
13755
  };
13691
- const DefaultType$7 = {
13756
+ const DefaultType$8 = {
13692
13757
  toggle: 'boolean',
13693
13758
  parent: '(string|element)'
13694
13759
  };
@@ -13697,7 +13762,7 @@ return jQuery;
13697
13762
  const EVENT_HIDE$5 = `hide${EVENT_KEY$8}`;
13698
13763
  const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$8}`;
13699
13764
  const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
13700
- const CLASS_NAME_SHOW$7 = 'show';
13765
+ const CLASS_NAME_SHOW$8 = 'show';
13701
13766
  const CLASS_NAME_COLLAPSE = 'collapse';
13702
13767
  const CLASS_NAME_COLLAPSING = 'collapsing';
13703
13768
  const CLASS_NAME_COLLAPSED = 'collapsed';
@@ -13744,16 +13809,16 @@ return jQuery;
13744
13809
 
13745
13810
 
13746
13811
  static get Default() {
13747
- return Default$7;
13812
+ return Default$8;
13748
13813
  }
13749
13814
 
13750
- static get DATA_KEY() {
13751
- return DATA_KEY$8;
13815
+ static get NAME() {
13816
+ return NAME$9;
13752
13817
  } // Public
13753
13818
 
13754
13819
 
13755
13820
  toggle() {
13756
- if (this._element.classList.contains(CLASS_NAME_SHOW$7)) {
13821
+ if (this._element.classList.contains(CLASS_NAME_SHOW$8)) {
13757
13822
  this.hide();
13758
13823
  } else {
13759
13824
  this.show();
@@ -13761,7 +13826,7 @@ return jQuery;
13761
13826
  }
13762
13827
 
13763
13828
  show() {
13764
- if (this._isTransitioning || this._element.classList.contains(CLASS_NAME_SHOW$7)) {
13829
+ if (this._isTransitioning || this._element.classList.contains(CLASS_NAME_SHOW$8)) {
13765
13830
  return;
13766
13831
  }
13767
13832
 
@@ -13831,7 +13896,7 @@ return jQuery;
13831
13896
  const complete = () => {
13832
13897
  this._element.classList.remove(CLASS_NAME_COLLAPSING);
13833
13898
 
13834
- this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
13899
+ this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$8);
13835
13900
 
13836
13901
  this._element.style[dimension] = '';
13837
13902
  this.setTransitioning(false);
@@ -13840,14 +13905,14 @@ return jQuery;
13840
13905
 
13841
13906
  const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
13842
13907
  const scrollSize = `scroll${capitalizedDimension}`;
13843
- const transitionDuration = getTransitionDurationFromElement(this._element);
13844
- EventHandler.one(this._element, 'transitionend', complete);
13845
- emulateTransitionEnd(this._element, transitionDuration);
13908
+
13909
+ this._queueCallback(complete, this._element, true);
13910
+
13846
13911
  this._element.style[dimension] = `${this._element[scrollSize]}px`;
13847
13912
  }
13848
13913
 
13849
13914
  hide() {
13850
- if (this._isTransitioning || !this._element.classList.contains(CLASS_NAME_SHOW$7)) {
13915
+ if (this._isTransitioning || !this._element.classList.contains(CLASS_NAME_SHOW$8)) {
13851
13916
  return;
13852
13917
  }
13853
13918
 
@@ -13864,7 +13929,7 @@ return jQuery;
13864
13929
 
13865
13930
  this._element.classList.add(CLASS_NAME_COLLAPSING);
13866
13931
 
13867
- this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
13932
+ this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$8);
13868
13933
 
13869
13934
  const triggerArrayLength = this._triggerArray.length;
13870
13935
 
@@ -13873,7 +13938,7 @@ return jQuery;
13873
13938
  const trigger = this._triggerArray[i];
13874
13939
  const elem = getElementFromSelector(trigger);
13875
13940
 
13876
- if (elem && !elem.classList.contains(CLASS_NAME_SHOW$7)) {
13941
+ if (elem && !elem.classList.contains(CLASS_NAME_SHOW$8)) {
13877
13942
  trigger.classList.add(CLASS_NAME_COLLAPSED);
13878
13943
  trigger.setAttribute('aria-expanded', false);
13879
13944
  }
@@ -13893,31 +13958,22 @@ return jQuery;
13893
13958
  };
13894
13959
 
13895
13960
  this._element.style[dimension] = '';
13896
- const transitionDuration = getTransitionDurationFromElement(this._element);
13897
- EventHandler.one(this._element, 'transitionend', complete);
13898
- emulateTransitionEnd(this._element, transitionDuration);
13961
+
13962
+ this._queueCallback(complete, this._element, true);
13899
13963
  }
13900
13964
 
13901
13965
  setTransitioning(isTransitioning) {
13902
13966
  this._isTransitioning = isTransitioning;
13903
- }
13904
-
13905
- dispose() {
13906
- super.dispose();
13907
- this._config = null;
13908
- this._parent = null;
13909
- this._triggerArray = null;
13910
- this._isTransitioning = null;
13911
13967
  } // Private
13912
13968
 
13913
13969
 
13914
13970
  _getConfig(config) {
13915
- config = { ...Default$7,
13971
+ config = { ...Default$8,
13916
13972
  ...config
13917
13973
  };
13918
13974
  config.toggle = Boolean(config.toggle); // Coerce string values
13919
13975
 
13920
- typeCheckConfig(NAME$8, config, DefaultType$7);
13976
+ typeCheckConfig(NAME$9, config, DefaultType$8);
13921
13977
  return config;
13922
13978
  }
13923
13979
 
@@ -13929,16 +13985,7 @@ return jQuery;
13929
13985
  let {
13930
13986
  parent
13931
13987
  } = this._config;
13932
-
13933
- if (isElement(parent)) {
13934
- // it's a jQuery object
13935
- if (typeof parent.jquery !== 'undefined' || typeof parent[0] !== 'undefined') {
13936
- parent = parent[0];
13937
- }
13938
- } else {
13939
- parent = SelectorEngine.findOne(parent);
13940
- }
13941
-
13988
+ parent = getElement(parent);
13942
13989
  const selector = `${SELECTOR_DATA_TOGGLE$4}[data-bs-parent="${parent}"]`;
13943
13990
  SelectorEngine.find(selector, parent).forEach(element => {
13944
13991
  const selected = getElementFromSelector(element);
@@ -13953,7 +14000,7 @@ return jQuery;
13953
14000
  return;
13954
14001
  }
13955
14002
 
13956
- const isOpen = element.classList.contains(CLASS_NAME_SHOW$7);
14003
+ const isOpen = element.classList.contains(CLASS_NAME_SHOW$8);
13957
14004
  triggerArray.forEach(elem => {
13958
14005
  if (isOpen) {
13959
14006
  elem.classList.remove(CLASS_NAME_COLLAPSED);
@@ -13968,7 +14015,7 @@ return jQuery;
13968
14015
 
13969
14016
  static collapseInterface(element, config) {
13970
14017
  let data = Data.get(element, DATA_KEY$8);
13971
- const _config = { ...Default$7,
14018
+ const _config = { ...Default$8,
13972
14019
  ...Manipulator.getDataAttributes(element),
13973
14020
  ...(typeof config === 'object' && config ? config : {})
13974
14021
  };
@@ -14039,11 +14086,11 @@ return jQuery;
14039
14086
  * add .Collapse to jQuery only if jQuery is present
14040
14087
  */
14041
14088
 
14042
- defineJQueryPlugin(NAME$8, Collapse);
14089
+ defineJQueryPlugin(Collapse);
14043
14090
 
14044
14091
  /**
14045
14092
  * --------------------------------------------------------------------------
14046
- * Bootstrap (v5.0.0-beta3): dropdown.js
14093
+ * Bootstrap (v5.0.1): dropdown.js
14047
14094
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
14048
14095
  * --------------------------------------------------------------------------
14049
14096
  */
@@ -14053,7 +14100,7 @@ return jQuery;
14053
14100
  * ------------------------------------------------------------------------
14054
14101
  */
14055
14102
 
14056
- const NAME$7 = 'dropdown';
14103
+ const NAME$8 = 'dropdown';
14057
14104
  const DATA_KEY$7 = 'bs.dropdown';
14058
14105
  const EVENT_KEY$7 = `.${DATA_KEY$7}`;
14059
14106
  const DATA_API_KEY$4 = '.data-api';
@@ -14073,8 +14120,7 @@ return jQuery;
14073
14120
  const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
14074
14121
  const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$7}${DATA_API_KEY$4}`;
14075
14122
  const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$7}${DATA_API_KEY$4}`;
14076
- const CLASS_NAME_DISABLED = 'disabled';
14077
- const CLASS_NAME_SHOW$6 = 'show';
14123
+ const CLASS_NAME_SHOW$7 = 'show';
14078
14124
  const CLASS_NAME_DROPUP = 'dropup';
14079
14125
  const CLASS_NAME_DROPEND = 'dropend';
14080
14126
  const CLASS_NAME_DROPSTART = 'dropstart';
@@ -14089,19 +14135,21 @@ return jQuery;
14089
14135
  const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
14090
14136
  const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
14091
14137
  const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
14092
- const Default$6 = {
14138
+ const Default$7 = {
14093
14139
  offset: [0, 2],
14094
14140
  boundary: 'clippingParents',
14095
14141
  reference: 'toggle',
14096
14142
  display: 'dynamic',
14097
- popperConfig: null
14143
+ popperConfig: null,
14144
+ autoClose: true
14098
14145
  };
14099
- const DefaultType$6 = {
14146
+ const DefaultType$7 = {
14100
14147
  offset: '(array|string|function)',
14101
14148
  boundary: '(string|element)',
14102
14149
  reference: '(string|element|object)',
14103
14150
  display: 'string',
14104
- popperConfig: '(null|object|function)'
14151
+ popperConfig: '(null|object|function)',
14152
+ autoClose: '(boolean|string)'
14105
14153
  };
14106
14154
  /**
14107
14155
  * ------------------------------------------------------------------------
@@ -14122,28 +14170,27 @@ return jQuery;
14122
14170
 
14123
14171
 
14124
14172
  static get Default() {
14125
- return Default$6;
14173
+ return Default$7;
14126
14174
  }
14127
14175
 
14128
14176
  static get DefaultType() {
14129
- return DefaultType$6;
14177
+ return DefaultType$7;
14130
14178
  }
14131
14179
 
14132
- static get DATA_KEY() {
14133
- return DATA_KEY$7;
14180
+ static get NAME() {
14181
+ return NAME$8;
14134
14182
  } // Public
14135
14183
 
14136
14184
 
14137
14185
  toggle() {
14138
- if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED)) {
14186
+ if (isDisabled(this._element)) {
14139
14187
  return;
14140
14188
  }
14141
14189
 
14142
- const isActive = this._element.classList.contains(CLASS_NAME_SHOW$6);
14143
-
14144
- Dropdown.clearMenus();
14190
+ const isActive = this._element.classList.contains(CLASS_NAME_SHOW$7);
14145
14191
 
14146
14192
  if (isActive) {
14193
+ this.hide();
14147
14194
  return;
14148
14195
  }
14149
14196
 
@@ -14151,7 +14198,7 @@ return jQuery;
14151
14198
  }
14152
14199
 
14153
14200
  show() {
14154
- if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || this._menu.classList.contains(CLASS_NAME_SHOW$6)) {
14201
+ if (isDisabled(this._element) || this._menu.classList.contains(CLASS_NAME_SHOW$7)) {
14155
14202
  return;
14156
14203
  }
14157
14204
 
@@ -14178,11 +14225,7 @@ return jQuery;
14178
14225
  if (this._config.reference === 'parent') {
14179
14226
  referenceElement = parent;
14180
14227
  } else if (isElement(this._config.reference)) {
14181
- referenceElement = this._config.reference; // Check if it's jQuery element
14182
-
14183
- if (typeof this._config.reference.jquery !== 'undefined') {
14184
- referenceElement = this._config.reference[0];
14185
- }
14228
+ referenceElement = getElement(this._config.reference);
14186
14229
  } else if (typeof this._config.reference === 'object') {
14187
14230
  referenceElement = this._config.reference;
14188
14231
  }
@@ -14202,54 +14245,35 @@ return jQuery;
14202
14245
 
14203
14246
 
14204
14247
  if ('ontouchstart' in document.documentElement && !parent.closest(SELECTOR_NAVBAR_NAV)) {
14205
- [].concat(...document.body.children).forEach(elem => EventHandler.on(elem, 'mouseover', null, noop()));
14248
+ [].concat(...document.body.children).forEach(elem => EventHandler.on(elem, 'mouseover', noop));
14206
14249
  }
14207
14250
 
14208
14251
  this._element.focus();
14209
14252
 
14210
14253
  this._element.setAttribute('aria-expanded', true);
14211
14254
 
14212
- this._menu.classList.toggle(CLASS_NAME_SHOW$6);
14255
+ this._menu.classList.toggle(CLASS_NAME_SHOW$7);
14213
14256
 
14214
- this._element.classList.toggle(CLASS_NAME_SHOW$6);
14257
+ this._element.classList.toggle(CLASS_NAME_SHOW$7);
14215
14258
 
14216
14259
  EventHandler.trigger(this._element, EVENT_SHOWN$4, relatedTarget);
14217
14260
  }
14218
14261
 
14219
14262
  hide() {
14220
- if (this._element.disabled || this._element.classList.contains(CLASS_NAME_DISABLED) || !this._menu.classList.contains(CLASS_NAME_SHOW$6)) {
14263
+ if (isDisabled(this._element) || !this._menu.classList.contains(CLASS_NAME_SHOW$7)) {
14221
14264
  return;
14222
14265
  }
14223
14266
 
14224
14267
  const relatedTarget = {
14225
14268
  relatedTarget: this._element
14226
14269
  };
14227
- const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget);
14228
-
14229
- if (hideEvent.defaultPrevented) {
14230
- return;
14231
- }
14232
-
14233
- if (this._popper) {
14234
- this._popper.destroy();
14235
- }
14236
-
14237
- this._menu.classList.toggle(CLASS_NAME_SHOW$6);
14238
14270
 
14239
- this._element.classList.toggle(CLASS_NAME_SHOW$6);
14240
-
14241
- Manipulator.removeDataAttribute(this._menu, 'popper');
14242
- EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget);
14271
+ this._completeHide(relatedTarget);
14243
14272
  }
14244
14273
 
14245
14274
  dispose() {
14246
- EventHandler.off(this._element, EVENT_KEY$7);
14247
- this._menu = null;
14248
-
14249
14275
  if (this._popper) {
14250
14276
  this._popper.destroy();
14251
-
14252
- this._popper = null;
14253
14277
  }
14254
14278
 
14255
14279
  super.dispose();
@@ -14271,16 +14295,43 @@ return jQuery;
14271
14295
  });
14272
14296
  }
14273
14297
 
14298
+ _completeHide(relatedTarget) {
14299
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4, relatedTarget);
14300
+
14301
+ if (hideEvent.defaultPrevented) {
14302
+ return;
14303
+ } // If this is a touch-enabled device we remove the extra
14304
+ // empty mouseover listeners we added for iOS support
14305
+
14306
+
14307
+ if ('ontouchstart' in document.documentElement) {
14308
+ [].concat(...document.body.children).forEach(elem => EventHandler.off(elem, 'mouseover', noop));
14309
+ }
14310
+
14311
+ if (this._popper) {
14312
+ this._popper.destroy();
14313
+ }
14314
+
14315
+ this._menu.classList.remove(CLASS_NAME_SHOW$7);
14316
+
14317
+ this._element.classList.remove(CLASS_NAME_SHOW$7);
14318
+
14319
+ this._element.setAttribute('aria-expanded', 'false');
14320
+
14321
+ Manipulator.removeDataAttribute(this._menu, 'popper');
14322
+ EventHandler.trigger(this._element, EVENT_HIDDEN$4, relatedTarget);
14323
+ }
14324
+
14274
14325
  _getConfig(config) {
14275
14326
  config = { ...this.constructor.Default,
14276
14327
  ...Manipulator.getDataAttributes(this._element),
14277
14328
  ...config
14278
14329
  };
14279
- typeCheckConfig(NAME$7, config, this.constructor.DefaultType);
14330
+ typeCheckConfig(NAME$8, config, this.constructor.DefaultType);
14280
14331
 
14281
14332
  if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
14282
14333
  // Popper virtual elements require a getBoundingClientRect method
14283
- throw new TypeError(`${NAME$7.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
14334
+ throw new TypeError(`${NAME$8.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
14284
14335
  }
14285
14336
 
14286
14337
  return config;
@@ -14357,6 +14408,29 @@ return jQuery;
14357
14408
  return { ...defaultBsPopperConfig,
14358
14409
  ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
14359
14410
  };
14411
+ }
14412
+
14413
+ _selectMenuItem(event) {
14414
+ const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(isVisible);
14415
+
14416
+ if (!items.length) {
14417
+ return;
14418
+ }
14419
+
14420
+ let index = items.indexOf(event.target); // Up
14421
+
14422
+ if (event.key === ARROW_UP_KEY && index > 0) {
14423
+ index--;
14424
+ } // Down
14425
+
14426
+
14427
+ if (event.key === ARROW_DOWN_KEY && index < items.length - 1) {
14428
+ index++;
14429
+ } // index is -1 if the first keydown is an ArrowUp
14430
+
14431
+
14432
+ index = index === -1 ? 0 : index;
14433
+ items[index].focus();
14360
14434
  } // Static
14361
14435
 
14362
14436
 
@@ -14385,72 +14459,46 @@ return jQuery;
14385
14459
  }
14386
14460
 
14387
14461
  static clearMenus(event) {
14388
- if (event) {
14389
- if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY) {
14390
- return;
14391
- }
14392
-
14393
- if (/input|select|textarea|form/i.test(event.target.tagName)) {
14394
- return;
14395
- }
14462
+ if (event && (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY)) {
14463
+ return;
14396
14464
  }
14397
14465
 
14398
14466
  const toggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE$3);
14399
14467
 
14400
14468
  for (let i = 0, len = toggles.length; i < len; i++) {
14401
14469
  const context = Data.get(toggles[i], DATA_KEY$7);
14402
- const relatedTarget = {
14403
- relatedTarget: toggles[i]
14404
- };
14405
-
14406
- if (event && event.type === 'click') {
14407
- relatedTarget.clickEvent = event;
14408
- }
14409
14470
 
14410
- if (!context) {
14471
+ if (!context || context._config.autoClose === false) {
14411
14472
  continue;
14412
14473
  }
14413
14474
 
14414
- const dropdownMenu = context._menu;
14415
-
14416
- if (!toggles[i].classList.contains(CLASS_NAME_SHOW$6)) {
14475
+ if (!context._element.classList.contains(CLASS_NAME_SHOW$7)) {
14417
14476
  continue;
14418
14477
  }
14419
14478
 
14479
+ const relatedTarget = {
14480
+ relatedTarget: context._element
14481
+ };
14482
+
14420
14483
  if (event) {
14421
- // Don't close the menu if the clicked element or one of its parents is the dropdown button
14422
- if ([context._element].some(element => event.composedPath().includes(element))) {
14484
+ const composedPath = event.composedPath();
14485
+ const isMenuTarget = composedPath.includes(context._menu);
14486
+
14487
+ if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
14423
14488
  continue;
14424
- } // Tab navigation through the dropdown menu shouldn't close the menu
14489
+ } // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
14425
14490
 
14426
14491
 
14427
- if (event.type === 'keyup' && event.key === TAB_KEY && dropdownMenu.contains(event.target)) {
14492
+ if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY || /input|select|option|textarea|form/i.test(event.target.tagName))) {
14428
14493
  continue;
14429
14494
  }
14430
- }
14431
-
14432
- const hideEvent = EventHandler.trigger(toggles[i], EVENT_HIDE$4, relatedTarget);
14433
-
14434
- if (hideEvent.defaultPrevented) {
14435
- continue;
14436
- } // If this is a touch-enabled device we remove the extra
14437
- // empty mouseover listeners we added for iOS support
14438
-
14439
14495
 
14440
- if ('ontouchstart' in document.documentElement) {
14441
- [].concat(...document.body.children).forEach(elem => EventHandler.off(elem, 'mouseover', null, noop()));
14442
- }
14443
-
14444
- toggles[i].setAttribute('aria-expanded', 'false');
14445
-
14446
- if (context._popper) {
14447
- context._popper.destroy();
14496
+ if (event.type === 'click') {
14497
+ relatedTarget.clickEvent = event;
14498
+ }
14448
14499
  }
14449
14500
 
14450
- dropdownMenu.classList.remove(CLASS_NAME_SHOW$6);
14451
- toggles[i].classList.remove(CLASS_NAME_SHOW$6);
14452
- Manipulator.removeDataAttribute(dropdownMenu, 'popper');
14453
- EventHandler.trigger(toggles[i], EVENT_HIDDEN$4, relatedTarget);
14501
+ context._completeHide(relatedTarget);
14454
14502
  }
14455
14503
  }
14456
14504
 
@@ -14470,26 +14518,29 @@ return jQuery;
14470
14518
  return;
14471
14519
  }
14472
14520
 
14521
+ const isActive = this.classList.contains(CLASS_NAME_SHOW$7);
14522
+
14523
+ if (!isActive && event.key === ESCAPE_KEY$2) {
14524
+ return;
14525
+ }
14526
+
14473
14527
  event.preventDefault();
14474
14528
  event.stopPropagation();
14475
14529
 
14476
- if (this.disabled || this.classList.contains(CLASS_NAME_DISABLED)) {
14530
+ if (isDisabled(this)) {
14477
14531
  return;
14478
14532
  }
14479
14533
 
14480
- const parent = Dropdown.getParentFromElement(this);
14481
- const isActive = this.classList.contains(CLASS_NAME_SHOW$6);
14534
+ const getToggleButton = () => this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
14482
14535
 
14483
14536
  if (event.key === ESCAPE_KEY$2) {
14484
- const button = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
14485
- button.focus();
14537
+ getToggleButton().focus();
14486
14538
  Dropdown.clearMenus();
14487
14539
  return;
14488
14540
  }
14489
14541
 
14490
14542
  if (!isActive && (event.key === ARROW_UP_KEY || event.key === ARROW_DOWN_KEY)) {
14491
- const button = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0];
14492
- button.click();
14543
+ getToggleButton().click();
14493
14544
  return;
14494
14545
  }
14495
14546
 
@@ -14498,26 +14549,7 @@ return jQuery;
14498
14549
  return;
14499
14550
  }
14500
14551
 
14501
- const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, parent).filter(isVisible);
14502
-
14503
- if (!items.length) {
14504
- return;
14505
- }
14506
-
14507
- let index = items.indexOf(event.target); // Up
14508
-
14509
- if (event.key === ARROW_UP_KEY && index > 0) {
14510
- index--;
14511
- } // Down
14512
-
14513
-
14514
- if (event.key === ARROW_DOWN_KEY && index < items.length - 1) {
14515
- index++;
14516
- } // index is -1 if the first keydown is an ArrowUp
14517
-
14518
-
14519
- index = index === -1 ? 0 : index;
14520
- items[index].focus();
14552
+ Dropdown.getInstance(getToggleButton())._selectMenuItem(event);
14521
14553
  }
14522
14554
 
14523
14555
  }
@@ -14543,11 +14575,214 @@ return jQuery;
14543
14575
  * add .Dropdown to jQuery only if jQuery is present
14544
14576
  */
14545
14577
 
14546
- defineJQueryPlugin(NAME$7, Dropdown);
14578
+ defineJQueryPlugin(Dropdown);
14547
14579
 
14548
14580
  /**
14549
14581
  * --------------------------------------------------------------------------
14550
- * Bootstrap (v5.0.0-beta3): modal.js
14582
+ * Bootstrap (v5.0.1): util/scrollBar.js
14583
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
14584
+ * --------------------------------------------------------------------------
14585
+ */
14586
+ const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
14587
+ const SELECTOR_STICKY_CONTENT = '.sticky-top';
14588
+
14589
+ const getWidth = () => {
14590
+ // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
14591
+ const documentWidth = document.documentElement.clientWidth;
14592
+ return Math.abs(window.innerWidth - documentWidth);
14593
+ };
14594
+
14595
+ const hide = (width = getWidth()) => {
14596
+ _disableOverFlow(); // give padding to element to balances the hidden scrollbar width
14597
+
14598
+
14599
+ _setElementAttributes('body', 'paddingRight', calculatedValue => calculatedValue + width); // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements, to keep shown fullwidth
14600
+
14601
+
14602
+ _setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width);
14603
+
14604
+ _setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width);
14605
+ };
14606
+
14607
+ const _disableOverFlow = () => {
14608
+ const actualValue = document.body.style.overflow;
14609
+
14610
+ if (actualValue) {
14611
+ Manipulator.setDataAttribute(document.body, 'overflow', actualValue);
14612
+ }
14613
+
14614
+ document.body.style.overflow = 'hidden';
14615
+ };
14616
+
14617
+ const _setElementAttributes = (selector, styleProp, callback) => {
14618
+ const scrollbarWidth = getWidth();
14619
+ SelectorEngine.find(selector).forEach(element => {
14620
+ if (element !== document.body && window.innerWidth > element.clientWidth + scrollbarWidth) {
14621
+ return;
14622
+ }
14623
+
14624
+ const actualValue = element.style[styleProp];
14625
+ const calculatedValue = window.getComputedStyle(element)[styleProp];
14626
+ Manipulator.setDataAttribute(element, styleProp, actualValue);
14627
+ element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
14628
+ });
14629
+ };
14630
+
14631
+ const reset = () => {
14632
+ _resetElementAttributes('body', 'overflow');
14633
+
14634
+ _resetElementAttributes('body', 'paddingRight');
14635
+
14636
+ _resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
14637
+
14638
+ _resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
14639
+ };
14640
+
14641
+ const _resetElementAttributes = (selector, styleProp) => {
14642
+ SelectorEngine.find(selector).forEach(element => {
14643
+ const value = Manipulator.getDataAttribute(element, styleProp);
14644
+
14645
+ if (typeof value === 'undefined') {
14646
+ element.style.removeProperty(styleProp);
14647
+ } else {
14648
+ Manipulator.removeDataAttribute(element, styleProp);
14649
+ element.style[styleProp] = value;
14650
+ }
14651
+ });
14652
+ };
14653
+
14654
+ /**
14655
+ * --------------------------------------------------------------------------
14656
+ * Bootstrap (v5.0.1): util/backdrop.js
14657
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
14658
+ * --------------------------------------------------------------------------
14659
+ */
14660
+ const Default$6 = {
14661
+ isVisible: true,
14662
+ // if false, we use the backdrop helper without adding any element to the dom
14663
+ isAnimated: false,
14664
+ rootElement: document.body,
14665
+ // give the choice to place backdrop under different elements
14666
+ clickCallback: null
14667
+ };
14668
+ const DefaultType$6 = {
14669
+ isVisible: 'boolean',
14670
+ isAnimated: 'boolean',
14671
+ rootElement: 'element',
14672
+ clickCallback: '(function|null)'
14673
+ };
14674
+ const NAME$7 = 'backdrop';
14675
+ const CLASS_NAME_BACKDROP = 'modal-backdrop';
14676
+ const CLASS_NAME_FADE$5 = 'fade';
14677
+ const CLASS_NAME_SHOW$6 = 'show';
14678
+ const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$7}`;
14679
+
14680
+ class Backdrop {
14681
+ constructor(config) {
14682
+ this._config = this._getConfig(config);
14683
+ this._isAppended = false;
14684
+ this._element = null;
14685
+ }
14686
+
14687
+ show(callback) {
14688
+ if (!this._config.isVisible) {
14689
+ execute(callback);
14690
+ return;
14691
+ }
14692
+
14693
+ this._append();
14694
+
14695
+ if (this._config.isAnimated) {
14696
+ reflow(this._getElement());
14697
+ }
14698
+
14699
+ this._getElement().classList.add(CLASS_NAME_SHOW$6);
14700
+
14701
+ this._emulateAnimation(() => {
14702
+ execute(callback);
14703
+ });
14704
+ }
14705
+
14706
+ hide(callback) {
14707
+ if (!this._config.isVisible) {
14708
+ execute(callback);
14709
+ return;
14710
+ }
14711
+
14712
+ this._getElement().classList.remove(CLASS_NAME_SHOW$6);
14713
+
14714
+ this._emulateAnimation(() => {
14715
+ this.dispose();
14716
+ execute(callback);
14717
+ });
14718
+ } // Private
14719
+
14720
+
14721
+ _getElement() {
14722
+ if (!this._element) {
14723
+ const backdrop = document.createElement('div');
14724
+ backdrop.className = CLASS_NAME_BACKDROP;
14725
+
14726
+ if (this._config.isAnimated) {
14727
+ backdrop.classList.add(CLASS_NAME_FADE$5);
14728
+ }
14729
+
14730
+ this._element = backdrop;
14731
+ }
14732
+
14733
+ return this._element;
14734
+ }
14735
+
14736
+ _getConfig(config) {
14737
+ config = { ...Default$6,
14738
+ ...(typeof config === 'object' ? config : {})
14739
+ };
14740
+ config.rootElement = config.rootElement || document.body;
14741
+ typeCheckConfig(NAME$7, config, DefaultType$6);
14742
+ return config;
14743
+ }
14744
+
14745
+ _append() {
14746
+ if (this._isAppended) {
14747
+ return;
14748
+ }
14749
+
14750
+ this._config.rootElement.appendChild(this._getElement());
14751
+
14752
+ EventHandler.on(this._getElement(), EVENT_MOUSEDOWN, () => {
14753
+ execute(this._config.clickCallback);
14754
+ });
14755
+ this._isAppended = true;
14756
+ }
14757
+
14758
+ dispose() {
14759
+ if (!this._isAppended) {
14760
+ return;
14761
+ }
14762
+
14763
+ EventHandler.off(this._element, EVENT_MOUSEDOWN);
14764
+
14765
+ this._getElement().parentNode.removeChild(this._element);
14766
+
14767
+ this._isAppended = false;
14768
+ }
14769
+
14770
+ _emulateAnimation(callback) {
14771
+ if (!this._config.isAnimated) {
14772
+ execute(callback);
14773
+ return;
14774
+ }
14775
+
14776
+ const backdropTransitionDuration = getTransitionDurationFromElement(this._getElement());
14777
+ EventHandler.one(this._getElement(), 'transitionend', () => execute(callback));
14778
+ emulateTransitionEnd(this._getElement(), backdropTransitionDuration);
14779
+ }
14780
+
14781
+ }
14782
+
14783
+ /**
14784
+ * --------------------------------------------------------------------------
14785
+ * Bootstrap (v5.0.1): modal.js
14551
14786
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
14552
14787
  * --------------------------------------------------------------------------
14553
14788
  */
@@ -14577,15 +14812,13 @@ return jQuery;
14577
14812
  const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$6}`;
14578
14813
  const EVENT_SHOW$3 = `show${EVENT_KEY$6}`;
14579
14814
  const EVENT_SHOWN$3 = `shown${EVENT_KEY$6}`;
14580
- const EVENT_FOCUSIN$1 = `focusin${EVENT_KEY$6}`;
14815
+ const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$6}`;
14581
14816
  const EVENT_RESIZE = `resize${EVENT_KEY$6}`;
14582
14817
  const EVENT_CLICK_DISMISS$2 = `click.dismiss${EVENT_KEY$6}`;
14583
- const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$6}`;
14818
+ const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$6}`;
14584
14819
  const EVENT_MOUSEUP_DISMISS = `mouseup.dismiss${EVENT_KEY$6}`;
14585
14820
  const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$6}`;
14586
14821
  const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
14587
- const CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure';
14588
- const CLASS_NAME_BACKDROP = 'modal-backdrop';
14589
14822
  const CLASS_NAME_OPEN = 'modal-open';
14590
14823
  const CLASS_NAME_FADE$4 = 'fade';
14591
14824
  const CLASS_NAME_SHOW$5 = 'show';
@@ -14594,8 +14827,6 @@ return jQuery;
14594
14827
  const SELECTOR_MODAL_BODY = '.modal-body';
14595
14828
  const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
14596
14829
  const SELECTOR_DATA_DISMISS$2 = '[data-bs-dismiss="modal"]';
14597
- const SELECTOR_FIXED_CONTENT$1 = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
14598
- const SELECTOR_STICKY_CONTENT$1 = '.sticky-top';
14599
14830
  /**
14600
14831
  * ------------------------------------------------------------------------
14601
14832
  * Class Definition
@@ -14607,12 +14838,10 @@ return jQuery;
14607
14838
  super(element);
14608
14839
  this._config = this._getConfig(config);
14609
14840
  this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
14610
- this._backdrop = null;
14841
+ this._backdrop = this._initializeBackDrop();
14611
14842
  this._isShown = false;
14612
- this._isBodyOverflowing = false;
14613
14843
  this._ignoreBackdropClick = false;
14614
14844
  this._isTransitioning = false;
14615
- this._scrollbarWidth = 0;
14616
14845
  } // Getters
14617
14846
 
14618
14847
 
@@ -14620,8 +14849,8 @@ return jQuery;
14620
14849
  return Default$5;
14621
14850
  }
14622
14851
 
14623
- static get DATA_KEY() {
14624
- return DATA_KEY$6;
14852
+ static get NAME() {
14853
+ return NAME$6;
14625
14854
  } // Public
14626
14855
 
14627
14856
 
@@ -14647,10 +14876,8 @@ return jQuery;
14647
14876
  }
14648
14877
 
14649
14878
  this._isShown = true;
14650
-
14651
- this._checkScrollbar();
14652
-
14653
- this._setScrollbar();
14879
+ hide();
14880
+ document.body.classList.add(CLASS_NAME_OPEN);
14654
14881
 
14655
14882
  this._adjustDialog();
14656
14883
 
@@ -14697,24 +14924,21 @@ return jQuery;
14697
14924
 
14698
14925
  this._setResizeEvent();
14699
14926
 
14700
- EventHandler.off(document, EVENT_FOCUSIN$1);
14927
+ EventHandler.off(document, EVENT_FOCUSIN$2);
14701
14928
 
14702
14929
  this._element.classList.remove(CLASS_NAME_SHOW$5);
14703
14930
 
14704
14931
  EventHandler.off(this._element, EVENT_CLICK_DISMISS$2);
14705
14932
  EventHandler.off(this._dialog, EVENT_MOUSEDOWN_DISMISS);
14706
14933
 
14707
- if (isAnimated) {
14708
- const transitionDuration = getTransitionDurationFromElement(this._element);
14709
- EventHandler.one(this._element, 'transitionend', event => this._hideModal(event));
14710
- emulateTransitionEnd(this._element, transitionDuration);
14711
- } else {
14712
- this._hideModal();
14713
- }
14934
+ this._queueCallback(() => this._hideModal(), this._element, isAnimated);
14714
14935
  }
14715
14936
 
14716
14937
  dispose() {
14717
- [window, this._element, this._dialog].forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY$6));
14938
+ [window, this._dialog].forEach(htmlElement => EventHandler.off(htmlElement, EVENT_KEY$6));
14939
+
14940
+ this._backdrop.dispose();
14941
+
14718
14942
  super.dispose();
14719
14943
  /**
14720
14944
  * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API`
@@ -14722,15 +14946,7 @@ return jQuery;
14722
14946
  * It will remove `EVENT_CLICK_DATA_API` event that should remain
14723
14947
  */
14724
14948
 
14725
- EventHandler.off(document, EVENT_FOCUSIN$1);
14726
- this._config = null;
14727
- this._dialog = null;
14728
- this._backdrop = null;
14729
- this._isShown = null;
14730
- this._isBodyOverflowing = null;
14731
- this._ignoreBackdropClick = null;
14732
- this._isTransitioning = null;
14733
- this._scrollbarWidth = null;
14949
+ EventHandler.off(document, EVENT_FOCUSIN$2);
14734
14950
  }
14735
14951
 
14736
14952
  handleUpdate() {
@@ -14738,8 +14954,17 @@ return jQuery;
14738
14954
  } // Private
14739
14955
 
14740
14956
 
14957
+ _initializeBackDrop() {
14958
+ return new Backdrop({
14959
+ isVisible: Boolean(this._config.backdrop),
14960
+ // 'static' option will be translated to true, and booleans will keep their value
14961
+ isAnimated: this._isAnimated()
14962
+ });
14963
+ }
14964
+
14741
14965
  _getConfig(config) {
14742
14966
  config = { ...Default$5,
14967
+ ...Manipulator.getDataAttributes(this._element),
14743
14968
  ...config
14744
14969
  };
14745
14970
  typeCheckConfig(NAME$6, config, DefaultType$5);
@@ -14791,19 +15016,13 @@ return jQuery;
14791
15016
  });
14792
15017
  };
14793
15018
 
14794
- if (isAnimated) {
14795
- const transitionDuration = getTransitionDurationFromElement(this._dialog);
14796
- EventHandler.one(this._dialog, 'transitionend', transitionComplete);
14797
- emulateTransitionEnd(this._dialog, transitionDuration);
14798
- } else {
14799
- transitionComplete();
14800
- }
15019
+ this._queueCallback(transitionComplete, this._dialog, isAnimated);
14801
15020
  }
14802
15021
 
14803
15022
  _enforceFocus() {
14804
- EventHandler.off(document, EVENT_FOCUSIN$1); // guard against infinite focus loop
15023
+ EventHandler.off(document, EVENT_FOCUSIN$2); // guard against infinite focus loop
14805
15024
 
14806
- EventHandler.on(document, EVENT_FOCUSIN$1, event => {
15025
+ EventHandler.on(document, EVENT_FOCUSIN$2, event => {
14807
15026
  if (document !== event.target && this._element !== event.target && !this._element.contains(event.target)) {
14808
15027
  this._element.focus();
14809
15028
  }
@@ -14812,7 +15031,7 @@ return jQuery;
14812
15031
 
14813
15032
  _setEscapeEvent() {
14814
15033
  if (this._isShown) {
14815
- EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
15034
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
14816
15035
  if (this._config.keyboard && event.key === ESCAPE_KEY$1) {
14817
15036
  event.preventDefault();
14818
15037
  this.hide();
@@ -14821,7 +15040,7 @@ return jQuery;
14821
15040
  }
14822
15041
  });
14823
15042
  } else {
14824
- EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS);
15043
+ EventHandler.off(this._element, EVENT_KEYDOWN_DISMISS$1);
14825
15044
  }
14826
15045
  }
14827
15046
 
@@ -14844,85 +15063,35 @@ return jQuery;
14844
15063
 
14845
15064
  this._isTransitioning = false;
14846
15065
 
14847
- this._showBackdrop(() => {
15066
+ this._backdrop.hide(() => {
14848
15067
  document.body.classList.remove(CLASS_NAME_OPEN);
14849
15068
 
14850
15069
  this._resetAdjustments();
14851
15070
 
14852
- this._resetScrollbar();
14853
-
15071
+ reset();
14854
15072
  EventHandler.trigger(this._element, EVENT_HIDDEN$3);
14855
15073
  });
14856
15074
  }
14857
15075
 
14858
- _removeBackdrop() {
14859
- this._backdrop.parentNode.removeChild(this._backdrop);
14860
-
14861
- this._backdrop = null;
14862
- }
14863
-
14864
15076
  _showBackdrop(callback) {
14865
- const isAnimated = this._isAnimated();
14866
-
14867
- if (this._isShown && this._config.backdrop) {
14868
- this._backdrop = document.createElement('div');
14869
- this._backdrop.className = CLASS_NAME_BACKDROP;
14870
-
14871
- if (isAnimated) {
14872
- this._backdrop.classList.add(CLASS_NAME_FADE$4);
14873
- }
14874
-
14875
- document.body.appendChild(this._backdrop);
14876
- EventHandler.on(this._element, EVENT_CLICK_DISMISS$2, event => {
14877
- if (this._ignoreBackdropClick) {
14878
- this._ignoreBackdropClick = false;
14879
- return;
14880
- }
14881
-
14882
- if (event.target !== event.currentTarget) {
14883
- return;
14884
- }
14885
-
14886
- if (this._config.backdrop === 'static') {
14887
- this._triggerBackdropTransition();
14888
- } else {
14889
- this.hide();
14890
- }
14891
- });
14892
-
14893
- if (isAnimated) {
14894
- reflow(this._backdrop);
15077
+ EventHandler.on(this._element, EVENT_CLICK_DISMISS$2, event => {
15078
+ if (this._ignoreBackdropClick) {
15079
+ this._ignoreBackdropClick = false;
15080
+ return;
14895
15081
  }
14896
15082
 
14897
- this._backdrop.classList.add(CLASS_NAME_SHOW$5);
14898
-
14899
- if (!isAnimated) {
14900
- callback();
15083
+ if (event.target !== event.currentTarget) {
14901
15084
  return;
14902
15085
  }
14903
15086
 
14904
- const backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop);
14905
- EventHandler.one(this._backdrop, 'transitionend', callback);
14906
- emulateTransitionEnd(this._backdrop, backdropTransitionDuration);
14907
- } else if (!this._isShown && this._backdrop) {
14908
- this._backdrop.classList.remove(CLASS_NAME_SHOW$5);
14909
-
14910
- const callbackRemove = () => {
14911
- this._removeBackdrop();
14912
-
14913
- callback();
14914
- };
14915
-
14916
- if (isAnimated) {
14917
- const backdropTransitionDuration = getTransitionDurationFromElement(this._backdrop);
14918
- EventHandler.one(this._backdrop, 'transitionend', callbackRemove);
14919
- emulateTransitionEnd(this._backdrop, backdropTransitionDuration);
14920
- } else {
14921
- callbackRemove();
15087
+ if (this._config.backdrop === true) {
15088
+ this.hide();
15089
+ } else if (this._config.backdrop === 'static') {
15090
+ this._triggerBackdropTransition();
14922
15091
  }
14923
- } else {
14924
- callback();
14925
- }
15092
+ });
15093
+
15094
+ this._backdrop.show(callback);
14926
15095
  }
14927
15096
 
14928
15097
  _isAnimated() {
@@ -14966,103 +15135,37 @@ return jQuery;
14966
15135
 
14967
15136
  _adjustDialog() {
14968
15137
  const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
15138
+ const scrollbarWidth = getWidth();
15139
+ const isBodyOverflowing = scrollbarWidth > 0;
14969
15140
 
14970
- if (!this._isBodyOverflowing && isModalOverflowing && !isRTL() || this._isBodyOverflowing && !isModalOverflowing && isRTL()) {
14971
- this._element.style.paddingLeft = `${this._scrollbarWidth}px`;
15141
+ if (!isBodyOverflowing && isModalOverflowing && !isRTL() || isBodyOverflowing && !isModalOverflowing && isRTL()) {
15142
+ this._element.style.paddingLeft = `${scrollbarWidth}px`;
14972
15143
  }
14973
15144
 
14974
- if (this._isBodyOverflowing && !isModalOverflowing && !isRTL() || !this._isBodyOverflowing && isModalOverflowing && isRTL()) {
14975
- this._element.style.paddingRight = `${this._scrollbarWidth}px`;
15145
+ if (isBodyOverflowing && !isModalOverflowing && !isRTL() || !isBodyOverflowing && isModalOverflowing && isRTL()) {
15146
+ this._element.style.paddingRight = `${scrollbarWidth}px`;
14976
15147
  }
14977
15148
  }
14978
15149
 
14979
15150
  _resetAdjustments() {
14980
15151
  this._element.style.paddingLeft = '';
14981
15152
  this._element.style.paddingRight = '';
14982
- }
14983
-
14984
- _checkScrollbar() {
14985
- const rect = document.body.getBoundingClientRect();
14986
- this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth;
14987
- this._scrollbarWidth = this._getScrollbarWidth();
14988
- }
14989
-
14990
- _setScrollbar() {
14991
- if (this._isBodyOverflowing) {
14992
- this._setElementAttributes(SELECTOR_FIXED_CONTENT$1, 'paddingRight', calculatedValue => calculatedValue + this._scrollbarWidth);
14993
-
14994
- this._setElementAttributes(SELECTOR_STICKY_CONTENT$1, 'marginRight', calculatedValue => calculatedValue - this._scrollbarWidth);
14995
-
14996
- this._setElementAttributes('body', 'paddingRight', calculatedValue => calculatedValue + this._scrollbarWidth);
14997
- }
14998
-
14999
- document.body.classList.add(CLASS_NAME_OPEN);
15000
- }
15001
-
15002
- _setElementAttributes(selector, styleProp, callback) {
15003
- SelectorEngine.find(selector).forEach(element => {
15004
- if (element !== document.body && window.innerWidth > element.clientWidth + this._scrollbarWidth) {
15005
- return;
15006
- }
15007
-
15008
- const actualValue = element.style[styleProp];
15009
- const calculatedValue = window.getComputedStyle(element)[styleProp];
15010
- Manipulator.setDataAttribute(element, styleProp, actualValue);
15011
- element.style[styleProp] = callback(Number.parseFloat(calculatedValue)) + 'px';
15012
- });
15013
- }
15014
-
15015
- _resetScrollbar() {
15016
- this._resetElementAttributes(SELECTOR_FIXED_CONTENT$1, 'paddingRight');
15017
-
15018
- this._resetElementAttributes(SELECTOR_STICKY_CONTENT$1, 'marginRight');
15019
-
15020
- this._resetElementAttributes('body', 'paddingRight');
15021
- }
15022
-
15023
- _resetElementAttributes(selector, styleProp) {
15024
- SelectorEngine.find(selector).forEach(element => {
15025
- const value = Manipulator.getDataAttribute(element, styleProp);
15026
-
15027
- if (typeof value === 'undefined' && element === document.body) {
15028
- element.style[styleProp] = '';
15029
- } else {
15030
- Manipulator.removeDataAttribute(element, styleProp);
15031
- element.style[styleProp] = value;
15032
- }
15033
- });
15034
- }
15035
-
15036
- _getScrollbarWidth() {
15037
- // thx d.walsh
15038
- const scrollDiv = document.createElement('div');
15039
- scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER;
15040
- document.body.appendChild(scrollDiv);
15041
- const scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth;
15042
- document.body.removeChild(scrollDiv);
15043
- return scrollbarWidth;
15044
15153
  } // Static
15045
15154
 
15046
15155
 
15047
15156
  static jQueryInterface(config, relatedTarget) {
15048
15157
  return this.each(function () {
15049
- let data = Data.get(this, DATA_KEY$6);
15050
- const _config = { ...Default$5,
15051
- ...Manipulator.getDataAttributes(this),
15052
- ...(typeof config === 'object' && config ? config : {})
15053
- };
15158
+ const data = Modal.getInstance(this) || new Modal(this, typeof config === 'object' ? config : {});
15054
15159
 
15055
- if (!data) {
15056
- data = new Modal(this, _config);
15160
+ if (typeof config !== 'string') {
15161
+ return;
15057
15162
  }
15058
15163
 
15059
- if (typeof config === 'string') {
15060
- if (typeof data[config] === 'undefined') {
15061
- throw new TypeError(`No method named "${config}"`);
15062
- }
15063
-
15064
- data[config](relatedTarget);
15164
+ if (typeof data[config] === 'undefined') {
15165
+ throw new TypeError(`No method named "${config}"`);
15065
15166
  }
15167
+
15168
+ data[config](relatedTarget);
15066
15169
  });
15067
15170
  }
15068
15171
 
@@ -15077,7 +15180,7 @@ return jQuery;
15077
15180
  EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
15078
15181
  const target = getElementFromSelector(this);
15079
15182
 
15080
- if (this.tagName === 'A' || this.tagName === 'AREA') {
15183
+ if (['A', 'AREA'].includes(this.tagName)) {
15081
15184
  event.preventDefault();
15082
15185
  }
15083
15186
 
@@ -15093,15 +15196,7 @@ return jQuery;
15093
15196
  }
15094
15197
  });
15095
15198
  });
15096
- let data = Data.get(target, DATA_KEY$6);
15097
-
15098
- if (!data) {
15099
- const config = { ...Manipulator.getDataAttributes(target),
15100
- ...Manipulator.getDataAttributes(this)
15101
- };
15102
- data = new Modal(target, config);
15103
- }
15104
-
15199
+ const data = Modal.getInstance(target) || new Modal(target);
15105
15200
  data.toggle(this);
15106
15201
  });
15107
15202
  /**
@@ -15111,73 +15206,11 @@ return jQuery;
15111
15206
  * add .Modal to jQuery only if jQuery is present
15112
15207
  */
15113
15208
 
15114
- defineJQueryPlugin(NAME$6, Modal);
15115
-
15116
- /**
15117
- * --------------------------------------------------------------------------
15118
- * Bootstrap (v5.0.0-beta3): util/scrollBar.js
15119
- * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
15120
- * --------------------------------------------------------------------------
15121
- */
15122
- const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed';
15123
- const SELECTOR_STICKY_CONTENT = '.sticky-top';
15124
-
15125
- const getWidth = () => {
15126
- // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
15127
- const documentWidth = document.documentElement.clientWidth;
15128
- return Math.abs(window.innerWidth - documentWidth);
15129
- };
15130
-
15131
- const hide = (width = getWidth()) => {
15132
- document.body.style.overflow = 'hidden';
15133
-
15134
- _setElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight', calculatedValue => calculatedValue + width);
15135
-
15136
- _setElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight', calculatedValue => calculatedValue - width);
15137
-
15138
- _setElementAttributes('body', 'paddingRight', calculatedValue => calculatedValue + width);
15139
- };
15140
-
15141
- const _setElementAttributes = (selector, styleProp, callback) => {
15142
- const scrollbarWidth = getWidth();
15143
- SelectorEngine.find(selector).forEach(element => {
15144
- if (element !== document.body && window.innerWidth > element.clientWidth + scrollbarWidth) {
15145
- return;
15146
- }
15147
-
15148
- const actualValue = element.style[styleProp];
15149
- const calculatedValue = window.getComputedStyle(element)[styleProp];
15150
- Manipulator.setDataAttribute(element, styleProp, actualValue);
15151
- element.style[styleProp] = callback(Number.parseFloat(calculatedValue)) + 'px';
15152
- });
15153
- };
15154
-
15155
- const reset = () => {
15156
- document.body.style.overflow = 'auto';
15157
-
15158
- _resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
15159
-
15160
- _resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
15161
-
15162
- _resetElementAttributes('body', 'paddingRight');
15163
- };
15164
-
15165
- const _resetElementAttributes = (selector, styleProp) => {
15166
- SelectorEngine.find(selector).forEach(element => {
15167
- const value = Manipulator.getDataAttribute(element, styleProp);
15168
-
15169
- if (typeof value === 'undefined' && element === document.body) {
15170
- element.style.removeProperty(styleProp);
15171
- } else {
15172
- Manipulator.removeDataAttribute(element, styleProp);
15173
- element.style[styleProp] = value;
15174
- }
15175
- });
15176
- };
15209
+ defineJQueryPlugin(Modal);
15177
15210
 
15178
15211
  /**
15179
15212
  * --------------------------------------------------------------------------
15180
- * Bootstrap (v5.0.0-beta3): offcanvas.js
15213
+ * Bootstrap (v5.0.1): offcanvas.js
15181
15214
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
15182
15215
  * --------------------------------------------------------------------------
15183
15216
  */
@@ -15203,18 +15236,16 @@ return jQuery;
15203
15236
  keyboard: 'boolean',
15204
15237
  scroll: 'boolean'
15205
15238
  };
15206
- const CLASS_NAME_BACKDROP_BODY = 'offcanvas-backdrop';
15207
15239
  const CLASS_NAME_SHOW$4 = 'show';
15208
- const CLASS_NAME_TOGGLING = 'offcanvas-toggling';
15209
15240
  const OPEN_SELECTOR = '.offcanvas.show';
15210
- const ACTIVE_SELECTOR = `${OPEN_SELECTOR}, .${CLASS_NAME_TOGGLING}`;
15211
15241
  const EVENT_SHOW$2 = `show${EVENT_KEY$5}`;
15212
15242
  const EVENT_SHOWN$2 = `shown${EVENT_KEY$5}`;
15213
15243
  const EVENT_HIDE$2 = `hide${EVENT_KEY$5}`;
15214
15244
  const EVENT_HIDDEN$2 = `hidden${EVENT_KEY$5}`;
15215
- const EVENT_FOCUSIN = `focusin${EVENT_KEY$5}`;
15245
+ const EVENT_FOCUSIN$1 = `focusin${EVENT_KEY$5}`;
15216
15246
  const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$5}${DATA_API_KEY$2}`;
15217
15247
  const EVENT_CLICK_DISMISS$1 = `click.dismiss${EVENT_KEY$5}`;
15248
+ const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$5}`;
15218
15249
  const SELECTOR_DATA_DISMISS$1 = '[data-bs-dismiss="offcanvas"]';
15219
15250
  const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
15220
15251
  /**
@@ -15228,17 +15259,18 @@ return jQuery;
15228
15259
  super(element);
15229
15260
  this._config = this._getConfig(config);
15230
15261
  this._isShown = false;
15262
+ this._backdrop = this._initializeBackDrop();
15231
15263
 
15232
15264
  this._addEventListeners();
15233
15265
  } // Getters
15234
15266
 
15235
15267
 
15236
- static get Default() {
15237
- return Default$4;
15268
+ static get NAME() {
15269
+ return NAME$5;
15238
15270
  }
15239
15271
 
15240
- static get DATA_KEY() {
15241
- return DATA_KEY$5;
15272
+ static get Default() {
15273
+ return Default$4;
15242
15274
  } // Public
15243
15275
 
15244
15276
 
@@ -15262,15 +15294,13 @@ return jQuery;
15262
15294
  this._isShown = true;
15263
15295
  this._element.style.visibility = 'visible';
15264
15296
 
15265
- if (this._config.backdrop) {
15266
- document.body.classList.add(CLASS_NAME_BACKDROP_BODY);
15267
- }
15297
+ this._backdrop.show();
15268
15298
 
15269
15299
  if (!this._config.scroll) {
15270
15300
  hide();
15271
- }
15272
15301
 
15273
- this._element.classList.add(CLASS_NAME_TOGGLING);
15302
+ this._enforceFocusOnElement(this._element);
15303
+ }
15274
15304
 
15275
15305
  this._element.removeAttribute('aria-hidden');
15276
15306
 
@@ -15281,16 +15311,12 @@ return jQuery;
15281
15311
  this._element.classList.add(CLASS_NAME_SHOW$4);
15282
15312
 
15283
15313
  const completeCallBack = () => {
15284
- this._element.classList.remove(CLASS_NAME_TOGGLING);
15285
-
15286
15314
  EventHandler.trigger(this._element, EVENT_SHOWN$2, {
15287
15315
  relatedTarget
15288
15316
  });
15289
-
15290
- this._enforceFocusOnElement(this._element);
15291
15317
  };
15292
15318
 
15293
- setTimeout(completeCallBack, getTransitionDurationFromElement(this._element));
15319
+ this._queueCallback(completeCallBack, this._element, true);
15294
15320
  }
15295
15321
 
15296
15322
  hide() {
@@ -15304,9 +15330,7 @@ return jQuery;
15304
15330
  return;
15305
15331
  }
15306
15332
 
15307
- this._element.classList.add(CLASS_NAME_TOGGLING);
15308
-
15309
- EventHandler.off(document, EVENT_FOCUSIN);
15333
+ EventHandler.off(document, EVENT_FOCUSIN$1);
15310
15334
 
15311
15335
  this._element.blur();
15312
15336
 
@@ -15314,6 +15338,8 @@ return jQuery;
15314
15338
 
15315
15339
  this._element.classList.remove(CLASS_NAME_SHOW$4);
15316
15340
 
15341
+ this._backdrop.hide();
15342
+
15317
15343
  const completeCallback = () => {
15318
15344
  this._element.setAttribute('aria-hidden', true);
15319
15345
 
@@ -15323,20 +15349,21 @@ return jQuery;
15323
15349
 
15324
15350
  this._element.style.visibility = 'hidden';
15325
15351
 
15326
- if (this._config.backdrop) {
15327
- document.body.classList.remove(CLASS_NAME_BACKDROP_BODY);
15328
- }
15329
-
15330
15352
  if (!this._config.scroll) {
15331
15353
  reset();
15332
15354
  }
15333
15355
 
15334
15356
  EventHandler.trigger(this._element, EVENT_HIDDEN$2);
15335
-
15336
- this._element.classList.remove(CLASS_NAME_TOGGLING);
15337
15357
  };
15338
15358
 
15339
- setTimeout(completeCallback, getTransitionDurationFromElement(this._element));
15359
+ this._queueCallback(completeCallback, this._element, true);
15360
+ }
15361
+
15362
+ dispose() {
15363
+ this._backdrop.dispose();
15364
+
15365
+ super.dispose();
15366
+ EventHandler.off(document, EVENT_FOCUSIN$1);
15340
15367
  } // Private
15341
15368
 
15342
15369
 
@@ -15349,10 +15376,19 @@ return jQuery;
15349
15376
  return config;
15350
15377
  }
15351
15378
 
15379
+ _initializeBackDrop() {
15380
+ return new Backdrop({
15381
+ isVisible: this._config.backdrop,
15382
+ isAnimated: true,
15383
+ rootElement: this._element.parentNode,
15384
+ clickCallback: () => this.hide()
15385
+ });
15386
+ }
15387
+
15352
15388
  _enforceFocusOnElement(element) {
15353
- EventHandler.off(document, EVENT_FOCUSIN); // guard against infinite focus loop
15389
+ EventHandler.off(document, EVENT_FOCUSIN$1); // guard against infinite focus loop
15354
15390
 
15355
- EventHandler.on(document, EVENT_FOCUSIN, event => {
15391
+ EventHandler.on(document, EVENT_FOCUSIN$1, event => {
15356
15392
  if (document !== event.target && element !== event.target && !element.contains(event.target)) {
15357
15393
  element.focus();
15358
15394
  }
@@ -15362,18 +15398,11 @@ return jQuery;
15362
15398
 
15363
15399
  _addEventListeners() {
15364
15400
  EventHandler.on(this._element, EVENT_CLICK_DISMISS$1, SELECTOR_DATA_DISMISS$1, () => this.hide());
15365
- EventHandler.on(document, 'keydown', event => {
15401
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
15366
15402
  if (this._config.keyboard && event.key === ESCAPE_KEY) {
15367
15403
  this.hide();
15368
15404
  }
15369
15405
  });
15370
- EventHandler.on(document, EVENT_CLICK_DATA_API$1, event => {
15371
- const target = SelectorEngine.findOne(getSelectorFromElement(event.target));
15372
-
15373
- if (!this._element.contains(event.target) && target !== this._element) {
15374
- this.hide();
15375
- }
15376
- });
15377
15406
  } // Static
15378
15407
 
15379
15408
 
@@ -15419,10 +15448,10 @@ return jQuery;
15419
15448
  }
15420
15449
  }); // avoid conflict when clicking a toggler of an offcanvas, while another is open
15421
15450
 
15422
- const allReadyOpen = SelectorEngine.findOne(ACTIVE_SELECTOR);
15451
+ const allReadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
15423
15452
 
15424
15453
  if (allReadyOpen && allReadyOpen !== target) {
15425
- return;
15454
+ Offcanvas.getInstance(allReadyOpen).hide();
15426
15455
  }
15427
15456
 
15428
15457
  const data = Data.get(target, DATA_KEY$5) || new Offcanvas(target);
@@ -15437,11 +15466,11 @@ return jQuery;
15437
15466
  * ------------------------------------------------------------------------
15438
15467
  */
15439
15468
 
15440
- defineJQueryPlugin(NAME$5, Offcanvas);
15469
+ defineJQueryPlugin(Offcanvas);
15441
15470
 
15442
15471
  /**
15443
15472
  * --------------------------------------------------------------------------
15444
- * Bootstrap (v5.0.0-beta3): util/sanitizer.js
15473
+ * Bootstrap (v5.0.1): util/sanitizer.js
15445
15474
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
15446
15475
  * --------------------------------------------------------------------------
15447
15476
  */
@@ -15554,7 +15583,7 @@ return jQuery;
15554
15583
 
15555
15584
  /**
15556
15585
  * --------------------------------------------------------------------------
15557
- * Bootstrap (v5.0.0-beta3): tooltip.js
15586
+ * Bootstrap (v5.0.1): tooltip.js
15558
15587
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
15559
15588
  * --------------------------------------------------------------------------
15560
15589
  */
@@ -15657,7 +15686,7 @@ return jQuery;
15657
15686
  this._activeTrigger = {};
15658
15687
  this._popper = null; // Protected
15659
15688
 
15660
- this.config = this._getConfig(config);
15689
+ this._config = this._getConfig(config);
15661
15690
  this.tip = null;
15662
15691
 
15663
15692
  this._setListeners();
@@ -15672,18 +15701,10 @@ return jQuery;
15672
15701
  return NAME$4;
15673
15702
  }
15674
15703
 
15675
- static get DATA_KEY() {
15676
- return DATA_KEY$4;
15677
- }
15678
-
15679
15704
  static get Event() {
15680
15705
  return Event$2;
15681
15706
  }
15682
15707
 
15683
- static get EVENT_KEY() {
15684
- return EVENT_KEY$4;
15685
- }
15686
-
15687
15708
  static get DefaultType() {
15688
15709
  return DefaultType$3;
15689
15710
  } // Public
@@ -15729,25 +15750,16 @@ return jQuery;
15729
15750
 
15730
15751
  dispose() {
15731
15752
  clearTimeout(this._timeout);
15732
- EventHandler.off(this._element, this.constructor.EVENT_KEY);
15733
15753
  EventHandler.off(this._element.closest(`.${CLASS_NAME_MODAL}`), 'hide.bs.modal', this._hideModalHandler);
15734
15754
 
15735
15755
  if (this.tip && this.tip.parentNode) {
15736
15756
  this.tip.parentNode.removeChild(this.tip);
15737
15757
  }
15738
15758
 
15739
- this._isEnabled = null;
15740
- this._timeout = null;
15741
- this._hoverState = null;
15742
- this._activeTrigger = null;
15743
-
15744
15759
  if (this._popper) {
15745
15760
  this._popper.destroy();
15746
15761
  }
15747
15762
 
15748
- this._popper = null;
15749
- this.config = null;
15750
- this.tip = null;
15751
15763
  super.dispose();
15752
15764
  }
15753
15765
 
@@ -15776,18 +15788,19 @@ return jQuery;
15776
15788
 
15777
15789
  this.setContent();
15778
15790
 
15779
- if (this.config.animation) {
15791
+ if (this._config.animation) {
15780
15792
  tip.classList.add(CLASS_NAME_FADE$3);
15781
15793
  }
15782
15794
 
15783
- const placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this._element) : this.config.placement;
15795
+ const placement = typeof this._config.placement === 'function' ? this._config.placement.call(this, tip, this._element) : this._config.placement;
15784
15796
 
15785
15797
  const attachment = this._getAttachment(placement);
15786
15798
 
15787
15799
  this._addAttachmentClass(attachment);
15788
15800
 
15789
- const container = this._getContainer();
15790
-
15801
+ const {
15802
+ container
15803
+ } = this._config;
15791
15804
  Data.set(tip, this.constructor.DATA_KEY, this);
15792
15805
 
15793
15806
  if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
@@ -15802,7 +15815,7 @@ return jQuery;
15802
15815
  }
15803
15816
 
15804
15817
  tip.classList.add(CLASS_NAME_SHOW$3);
15805
- const customClass = typeof this.config.customClass === 'function' ? this.config.customClass() : this.config.customClass;
15818
+ const customClass = typeof this._config.customClass === 'function' ? this._config.customClass() : this._config.customClass;
15806
15819
 
15807
15820
  if (customClass) {
15808
15821
  tip.classList.add(...customClass.split(' '));
@@ -15814,7 +15827,7 @@ return jQuery;
15814
15827
 
15815
15828
  if ('ontouchstart' in document.documentElement) {
15816
15829
  [].concat(...document.body.children).forEach(element => {
15817
- EventHandler.on(element, 'mouseover', noop());
15830
+ EventHandler.on(element, 'mouseover', noop);
15818
15831
  });
15819
15832
  }
15820
15833
 
@@ -15828,13 +15841,9 @@ return jQuery;
15828
15841
  }
15829
15842
  };
15830
15843
 
15831
- if (this.tip.classList.contains(CLASS_NAME_FADE$3)) {
15832
- const transitionDuration = getTransitionDurationFromElement(this.tip);
15833
- EventHandler.one(this.tip, 'transitionend', complete);
15834
- emulateTransitionEnd(this.tip, transitionDuration);
15835
- } else {
15836
- complete();
15837
- }
15844
+ const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$3);
15845
+
15846
+ this._queueCallback(complete, this.tip, isAnimated);
15838
15847
  }
15839
15848
 
15840
15849
  hide() {
@@ -15882,14 +15891,9 @@ return jQuery;
15882
15891
  this._activeTrigger[TRIGGER_CLICK] = false;
15883
15892
  this._activeTrigger[TRIGGER_FOCUS] = false;
15884
15893
  this._activeTrigger[TRIGGER_HOVER] = false;
15894
+ const isAnimated = this.tip.classList.contains(CLASS_NAME_FADE$3);
15885
15895
 
15886
- if (this.tip.classList.contains(CLASS_NAME_FADE$3)) {
15887
- const transitionDuration = getTransitionDurationFromElement(tip);
15888
- EventHandler.one(tip, 'transitionend', complete);
15889
- emulateTransitionEnd(tip, transitionDuration);
15890
- } else {
15891
- complete();
15892
- }
15896
+ this._queueCallback(complete, this.tip, isAnimated);
15893
15897
 
15894
15898
  this._hoverState = '';
15895
15899
  }
@@ -15911,7 +15915,7 @@ return jQuery;
15911
15915
  }
15912
15916
 
15913
15917
  const element = document.createElement('div');
15914
- element.innerHTML = this.config.template;
15918
+ element.innerHTML = this._config.template;
15915
15919
  this.tip = element.children[0];
15916
15920
  return this.tip;
15917
15921
  }
@@ -15927,13 +15931,10 @@ return jQuery;
15927
15931
  return;
15928
15932
  }
15929
15933
 
15930
- if (typeof content === 'object' && isElement(content)) {
15931
- if (content.jquery) {
15932
- content = content[0];
15933
- } // content is a DOM node or a jQuery
15934
-
15934
+ if (isElement(content)) {
15935
+ content = getElement(content); // content is a DOM node or a jQuery
15935
15936
 
15936
- if (this.config.html) {
15937
+ if (this._config.html) {
15937
15938
  if (content.parentNode !== element) {
15938
15939
  element.innerHTML = '';
15939
15940
  element.appendChild(content);
@@ -15945,9 +15946,9 @@ return jQuery;
15945
15946
  return;
15946
15947
  }
15947
15948
 
15948
- if (this.config.html) {
15949
- if (this.config.sanitize) {
15950
- content = sanitizeHtml(content, this.config.allowList, this.config.sanitizeFn);
15949
+ if (this._config.html) {
15950
+ if (this._config.sanitize) {
15951
+ content = sanitizeHtml(content, this._config.allowList, this._config.sanitizeFn);
15951
15952
  }
15952
15953
 
15953
15954
  element.innerHTML = content;
@@ -15960,7 +15961,7 @@ return jQuery;
15960
15961
  let title = this._element.getAttribute('data-bs-original-title');
15961
15962
 
15962
15963
  if (!title) {
15963
- title = typeof this.config.title === 'function' ? this.config.title.call(this._element) : this.config.title;
15964
+ title = typeof this._config.title === 'function' ? this._config.title.call(this._element) : this._config.title;
15964
15965
  }
15965
15966
 
15966
15967
  return title;
@@ -15994,7 +15995,7 @@ return jQuery;
15994
15995
  _getOffset() {
15995
15996
  const {
15996
15997
  offset
15997
- } = this.config;
15998
+ } = this._config;
15998
15999
 
15999
16000
  if (typeof offset === 'string') {
16000
16001
  return offset.split(',').map(val => Number.parseInt(val, 10));
@@ -16013,8 +16014,7 @@ return jQuery;
16013
16014
  modifiers: [{
16014
16015
  name: 'flip',
16015
16016
  options: {
16016
- altBoundary: true,
16017
- fallbackPlacements: this.config.fallbackPlacements
16017
+ fallbackPlacements: this._config.fallbackPlacements
16018
16018
  }
16019
16019
  }, {
16020
16020
  name: 'offset',
@@ -16024,7 +16024,7 @@ return jQuery;
16024
16024
  }, {
16025
16025
  name: 'preventOverflow',
16026
16026
  options: {
16027
- boundary: this.config.boundary
16027
+ boundary: this._config.boundary
16028
16028
  }
16029
16029
  }, {
16030
16030
  name: 'arrow',
@@ -16044,7 +16044,7 @@ return jQuery;
16044
16044
  }
16045
16045
  };
16046
16046
  return { ...defaultBsPopperConfig,
16047
- ...(typeof this.config.popperConfig === 'function' ? this.config.popperConfig(defaultBsPopperConfig) : this.config.popperConfig)
16047
+ ...(typeof this._config.popperConfig === 'function' ? this._config.popperConfig(defaultBsPopperConfig) : this._config.popperConfig)
16048
16048
  };
16049
16049
  }
16050
16050
 
@@ -16052,32 +16052,21 @@ return jQuery;
16052
16052
  this.getTipElement().classList.add(`${CLASS_PREFIX$1}-${this.updateAttachment(attachment)}`);
16053
16053
  }
16054
16054
 
16055
- _getContainer() {
16056
- if (this.config.container === false) {
16057
- return document.body;
16058
- }
16059
-
16060
- if (isElement(this.config.container)) {
16061
- return this.config.container;
16062
- }
16063
-
16064
- return SelectorEngine.findOne(this.config.container);
16065
- }
16066
-
16067
16055
  _getAttachment(placement) {
16068
16056
  return AttachmentMap[placement.toUpperCase()];
16069
16057
  }
16070
16058
 
16071
16059
  _setListeners() {
16072
- const triggers = this.config.trigger.split(' ');
16060
+ const triggers = this._config.trigger.split(' ');
16061
+
16073
16062
  triggers.forEach(trigger => {
16074
16063
  if (trigger === 'click') {
16075
- EventHandler.on(this._element, this.constructor.Event.CLICK, this.config.selector, event => this.toggle(event));
16064
+ EventHandler.on(this._element, this.constructor.Event.CLICK, this._config.selector, event => this.toggle(event));
16076
16065
  } else if (trigger !== TRIGGER_MANUAL) {
16077
16066
  const eventIn = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSEENTER : this.constructor.Event.FOCUSIN;
16078
16067
  const eventOut = trigger === TRIGGER_HOVER ? this.constructor.Event.MOUSELEAVE : this.constructor.Event.FOCUSOUT;
16079
- EventHandler.on(this._element, eventIn, this.config.selector, event => this._enter(event));
16080
- EventHandler.on(this._element, eventOut, this.config.selector, event => this._leave(event));
16068
+ EventHandler.on(this._element, eventIn, this._config.selector, event => this._enter(event));
16069
+ EventHandler.on(this._element, eventOut, this._config.selector, event => this._leave(event));
16081
16070
  }
16082
16071
  });
16083
16072
 
@@ -16089,8 +16078,8 @@ return jQuery;
16089
16078
 
16090
16079
  EventHandler.on(this._element.closest(`.${CLASS_NAME_MODAL}`), 'hide.bs.modal', this._hideModalHandler);
16091
16080
 
16092
- if (this.config.selector) {
16093
- this.config = { ...this.config,
16081
+ if (this._config.selector) {
16082
+ this._config = { ...this._config,
16094
16083
  trigger: 'manual',
16095
16084
  selector: ''
16096
16085
  };
@@ -16130,7 +16119,7 @@ return jQuery;
16130
16119
  clearTimeout(context._timeout);
16131
16120
  context._hoverState = HOVER_STATE_SHOW;
16132
16121
 
16133
- if (!context.config.delay || !context.config.delay.show) {
16122
+ if (!context._config.delay || !context._config.delay.show) {
16134
16123
  context.show();
16135
16124
  return;
16136
16125
  }
@@ -16139,7 +16128,7 @@ return jQuery;
16139
16128
  if (context._hoverState === HOVER_STATE_SHOW) {
16140
16129
  context.show();
16141
16130
  }
16142
- }, context.config.delay.show);
16131
+ }, context._config.delay.show);
16143
16132
  }
16144
16133
 
16145
16134
  _leave(event, context) {
@@ -16156,7 +16145,7 @@ return jQuery;
16156
16145
  clearTimeout(context._timeout);
16157
16146
  context._hoverState = HOVER_STATE_OUT;
16158
16147
 
16159
- if (!context.config.delay || !context.config.delay.hide) {
16148
+ if (!context._config.delay || !context._config.delay.hide) {
16160
16149
  context.hide();
16161
16150
  return;
16162
16151
  }
@@ -16165,7 +16154,7 @@ return jQuery;
16165
16154
  if (context._hoverState === HOVER_STATE_OUT) {
16166
16155
  context.hide();
16167
16156
  }
16168
- }, context.config.delay.hide);
16157
+ }, context._config.delay.hide);
16169
16158
  }
16170
16159
 
16171
16160
  _isWithActiveTrigger() {
@@ -16185,15 +16174,11 @@ return jQuery;
16185
16174
  delete dataAttributes[dataAttr];
16186
16175
  }
16187
16176
  });
16188
-
16189
- if (config && typeof config.container === 'object' && config.container.jquery) {
16190
- config.container = config.container[0];
16191
- }
16192
-
16193
16177
  config = { ...this.constructor.Default,
16194
16178
  ...dataAttributes,
16195
16179
  ...(typeof config === 'object' && config ? config : {})
16196
16180
  };
16181
+ config.container = config.container === false ? document.body : getElement(config.container);
16197
16182
 
16198
16183
  if (typeof config.delay === 'number') {
16199
16184
  config.delay = {
@@ -16222,10 +16207,10 @@ return jQuery;
16222
16207
  _getDelegateConfig() {
16223
16208
  const config = {};
16224
16209
 
16225
- if (this.config) {
16226
- for (const key in this.config) {
16227
- if (this.constructor.Default[key] !== this.config[key]) {
16228
- config[key] = this.config[key];
16210
+ if (this._config) {
16211
+ for (const key in this._config) {
16212
+ if (this.constructor.Default[key] !== this._config[key]) {
16213
+ config[key] = this._config[key];
16229
16214
  }
16230
16215
  }
16231
16216
  }
@@ -16292,11 +16277,11 @@ return jQuery;
16292
16277
  */
16293
16278
 
16294
16279
 
16295
- defineJQueryPlugin(NAME$4, Tooltip);
16280
+ defineJQueryPlugin(Tooltip);
16296
16281
 
16297
16282
  /**
16298
16283
  * --------------------------------------------------------------------------
16299
- * Bootstrap (v5.0.0-beta3): popover.js
16284
+ * Bootstrap (v5.0.1): popover.js
16300
16285
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16301
16286
  * --------------------------------------------------------------------------
16302
16287
  */
@@ -16353,18 +16338,10 @@ return jQuery;
16353
16338
  return NAME$3;
16354
16339
  }
16355
16340
 
16356
- static get DATA_KEY() {
16357
- return DATA_KEY$3;
16358
- }
16359
-
16360
16341
  static get Event() {
16361
16342
  return Event$1;
16362
16343
  }
16363
16344
 
16364
- static get EVENT_KEY() {
16365
- return EVENT_KEY$3;
16366
- }
16367
-
16368
16345
  static get DefaultType() {
16369
16346
  return DefaultType$2;
16370
16347
  } // Overrides
@@ -16395,7 +16372,7 @@ return jQuery;
16395
16372
  }
16396
16373
 
16397
16374
  _getContent() {
16398
- return this._element.getAttribute('data-bs-content') || this.config.content;
16375
+ return this._element.getAttribute('data-bs-content') || this._config.content;
16399
16376
  }
16400
16377
 
16401
16378
  _cleanTipClass() {
@@ -16442,11 +16419,11 @@ return jQuery;
16442
16419
  */
16443
16420
 
16444
16421
 
16445
- defineJQueryPlugin(NAME$3, Popover);
16422
+ defineJQueryPlugin(Popover);
16446
16423
 
16447
16424
  /**
16448
16425
  * --------------------------------------------------------------------------
16449
- * Bootstrap (v5.0.0-beta3): scrollspy.js
16426
+ * Bootstrap (v5.0.1): scrollspy.js
16450
16427
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16451
16428
  * --------------------------------------------------------------------------
16452
16429
  */
@@ -16511,8 +16488,8 @@ return jQuery;
16511
16488
  return Default$1;
16512
16489
  }
16513
16490
 
16514
- static get DATA_KEY() {
16515
- return DATA_KEY$2;
16491
+ static get NAME() {
16492
+ return NAME$2;
16516
16493
  } // Public
16517
16494
 
16518
16495
 
@@ -16545,20 +16522,14 @@ return jQuery;
16545
16522
  }
16546
16523
 
16547
16524
  dispose() {
16548
- super.dispose();
16549
16525
  EventHandler.off(this._scrollElement, EVENT_KEY$2);
16550
- this._scrollElement = null;
16551
- this._config = null;
16552
- this._selector = null;
16553
- this._offsets = null;
16554
- this._targets = null;
16555
- this._activeTarget = null;
16556
- this._scrollHeight = null;
16526
+ super.dispose();
16557
16527
  } // Private
16558
16528
 
16559
16529
 
16560
16530
  _getConfig(config) {
16561
16531
  config = { ...Default$1,
16532
+ ...Manipulator.getDataAttributes(this._element),
16562
16533
  ...(typeof config === 'object' && config ? config : {})
16563
16534
  };
16564
16535
 
@@ -16667,21 +16638,17 @@ return jQuery;
16667
16638
 
16668
16639
  static jQueryInterface(config) {
16669
16640
  return this.each(function () {
16670
- let data = Data.get(this, DATA_KEY$2);
16671
-
16672
- const _config = typeof config === 'object' && config;
16641
+ const data = ScrollSpy.getInstance(this) || new ScrollSpy(this, typeof config === 'object' ? config : {});
16673
16642
 
16674
- if (!data) {
16675
- data = new ScrollSpy(this, _config);
16643
+ if (typeof config !== 'string') {
16644
+ return;
16676
16645
  }
16677
16646
 
16678
- if (typeof config === 'string') {
16679
- if (typeof data[config] === 'undefined') {
16680
- throw new TypeError(`No method named "${config}"`);
16681
- }
16682
-
16683
- data[config]();
16647
+ if (typeof data[config] === 'undefined') {
16648
+ throw new TypeError(`No method named "${config}"`);
16684
16649
  }
16650
+
16651
+ data[config]();
16685
16652
  });
16686
16653
  }
16687
16654
 
@@ -16694,7 +16661,7 @@ return jQuery;
16694
16661
 
16695
16662
 
16696
16663
  EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
16697
- SelectorEngine.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy, Manipulator.getDataAttributes(spy)));
16664
+ SelectorEngine.find(SELECTOR_DATA_SPY).forEach(spy => new ScrollSpy(spy));
16698
16665
  });
16699
16666
  /**
16700
16667
  * ------------------------------------------------------------------------
@@ -16703,11 +16670,11 @@ return jQuery;
16703
16670
  * add .ScrollSpy to jQuery only if jQuery is present
16704
16671
  */
16705
16672
 
16706
- defineJQueryPlugin(NAME$2, ScrollSpy);
16673
+ defineJQueryPlugin(ScrollSpy);
16707
16674
 
16708
16675
  /**
16709
16676
  * --------------------------------------------------------------------------
16710
- * Bootstrap (v5.0.0-beta3): tab.js
16677
+ * Bootstrap (v5.0.1): tab.js
16711
16678
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16712
16679
  * --------------------------------------------------------------------------
16713
16680
  */
@@ -16745,13 +16712,13 @@ return jQuery;
16745
16712
 
16746
16713
  class Tab extends BaseComponent {
16747
16714
  // Getters
16748
- static get DATA_KEY() {
16749
- return DATA_KEY$1;
16715
+ static get NAME() {
16716
+ return NAME$1;
16750
16717
  } // Public
16751
16718
 
16752
16719
 
16753
16720
  show() {
16754
- if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE) || isDisabled(this._element)) {
16721
+ if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && this._element.classList.contains(CLASS_NAME_ACTIVE)) {
16755
16722
  return;
16756
16723
  }
16757
16724
 
@@ -16804,10 +16771,9 @@ return jQuery;
16804
16771
  const complete = () => this._transitionComplete(element, active, callback);
16805
16772
 
16806
16773
  if (active && isTransitioning) {
16807
- const transitionDuration = getTransitionDurationFromElement(active);
16808
16774
  active.classList.remove(CLASS_NAME_SHOW$1);
16809
- EventHandler.one(active, 'transitionend', complete);
16810
- emulateTransitionEnd(active, transitionDuration);
16775
+
16776
+ this._queueCallback(complete, element, true);
16811
16777
  } else {
16812
16778
  complete();
16813
16779
  }
@@ -16839,11 +16805,17 @@ return jQuery;
16839
16805
  element.classList.add(CLASS_NAME_SHOW$1);
16840
16806
  }
16841
16807
 
16842
- if (element.parentNode && element.parentNode.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
16808
+ let parent = element.parentNode;
16809
+
16810
+ if (parent && parent.nodeName === 'LI') {
16811
+ parent = parent.parentNode;
16812
+ }
16813
+
16814
+ if (parent && parent.classList.contains(CLASS_NAME_DROPDOWN_MENU)) {
16843
16815
  const dropdownElement = element.closest(SELECTOR_DROPDOWN);
16844
16816
 
16845
16817
  if (dropdownElement) {
16846
- SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE));
16818
+ SelectorEngine.find(SELECTOR_DROPDOWN_TOGGLE, dropdownElement).forEach(dropdown => dropdown.classList.add(CLASS_NAME_ACTIVE));
16847
16819
  }
16848
16820
 
16849
16821
  element.setAttribute('aria-expanded', true);
@@ -16878,7 +16850,14 @@ return jQuery;
16878
16850
 
16879
16851
 
16880
16852
  EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
16881
- event.preventDefault();
16853
+ if (['A', 'AREA'].includes(this.tagName)) {
16854
+ event.preventDefault();
16855
+ }
16856
+
16857
+ if (isDisabled(this)) {
16858
+ return;
16859
+ }
16860
+
16882
16861
  const data = Data.get(this, DATA_KEY$1) || new Tab(this);
16883
16862
  data.show();
16884
16863
  });
@@ -16889,11 +16868,11 @@ return jQuery;
16889
16868
  * add .Tab to jQuery only if jQuery is present
16890
16869
  */
16891
16870
 
16892
- defineJQueryPlugin(NAME$1, Tab);
16871
+ defineJQueryPlugin(Tab);
16893
16872
 
16894
16873
  /**
16895
16874
  * --------------------------------------------------------------------------
16896
- * Bootstrap (v5.0.0-beta3): toast.js
16875
+ * Bootstrap (v5.0.1): toast.js
16897
16876
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
16898
16877
  * --------------------------------------------------------------------------
16899
16878
  */
@@ -16907,6 +16886,10 @@ return jQuery;
16907
16886
  const DATA_KEY = 'bs.toast';
16908
16887
  const EVENT_KEY = `.${DATA_KEY}`;
16909
16888
  const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY}`;
16889
+ const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
16890
+ const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
16891
+ const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
16892
+ const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
16910
16893
  const EVENT_HIDE = `hide${EVENT_KEY}`;
16911
16894
  const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
16912
16895
  const EVENT_SHOW = `show${EVENT_KEY}`;
@@ -16937,6 +16920,8 @@ return jQuery;
16937
16920
  super(element);
16938
16921
  this._config = this._getConfig(config);
16939
16922
  this._timeout = null;
16923
+ this._hasMouseInteraction = false;
16924
+ this._hasKeyboardInteraction = false;
16940
16925
 
16941
16926
  this._setListeners();
16942
16927
  } // Getters
@@ -16950,8 +16935,8 @@ return jQuery;
16950
16935
  return Default;
16951
16936
  }
16952
16937
 
16953
- static get DATA_KEY() {
16954
- return DATA_KEY;
16938
+ static get NAME() {
16939
+ return NAME;
16955
16940
  } // Public
16956
16941
 
16957
16942
 
@@ -16975,11 +16960,7 @@ return jQuery;
16975
16960
 
16976
16961
  EventHandler.trigger(this._element, EVENT_SHOWN);
16977
16962
 
16978
- if (this._config.autohide) {
16979
- this._timeout = setTimeout(() => {
16980
- this.hide();
16981
- }, this._config.delay);
16982
- }
16963
+ this._maybeScheduleHide();
16983
16964
  };
16984
16965
 
16985
16966
  this._element.classList.remove(CLASS_NAME_HIDE);
@@ -16988,13 +16969,7 @@ return jQuery;
16988
16969
 
16989
16970
  this._element.classList.add(CLASS_NAME_SHOWING);
16990
16971
 
16991
- if (this._config.animation) {
16992
- const transitionDuration = getTransitionDurationFromElement(this._element);
16993
- EventHandler.one(this._element, 'transitionend', complete);
16994
- emulateTransitionEnd(this._element, transitionDuration);
16995
- } else {
16996
- complete();
16997
- }
16972
+ this._queueCallback(complete, this._element, this._config.animation);
16998
16973
  }
16999
16974
 
17000
16975
  hide() {
@@ -17016,13 +16991,7 @@ return jQuery;
17016
16991
 
17017
16992
  this._element.classList.remove(CLASS_NAME_SHOW);
17018
16993
 
17019
- if (this._config.animation) {
17020
- const transitionDuration = getTransitionDurationFromElement(this._element);
17021
- EventHandler.one(this._element, 'transitionend', complete);
17022
- emulateTransitionEnd(this._element, transitionDuration);
17023
- } else {
17024
- complete();
17025
- }
16994
+ this._queueCallback(complete, this._element, this._config.animation);
17026
16995
  }
17027
16996
 
17028
16997
  dispose() {
@@ -17032,9 +17001,7 @@ return jQuery;
17032
17001
  this._element.classList.remove(CLASS_NAME_SHOW);
17033
17002
  }
17034
17003
 
17035
- EventHandler.off(this._element, EVENT_CLICK_DISMISS);
17036
17004
  super.dispose();
17037
- this._config = null;
17038
17005
  } // Private
17039
17006
 
17040
17007
 
@@ -17047,8 +17014,54 @@ return jQuery;
17047
17014
  return config;
17048
17015
  }
17049
17016
 
17017
+ _maybeScheduleHide() {
17018
+ if (!this._config.autohide) {
17019
+ return;
17020
+ }
17021
+
17022
+ if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
17023
+ return;
17024
+ }
17025
+
17026
+ this._timeout = setTimeout(() => {
17027
+ this.hide();
17028
+ }, this._config.delay);
17029
+ }
17030
+
17031
+ _onInteraction(event, isInteracting) {
17032
+ switch (event.type) {
17033
+ case 'mouseover':
17034
+ case 'mouseout':
17035
+ this._hasMouseInteraction = isInteracting;
17036
+ break;
17037
+
17038
+ case 'focusin':
17039
+ case 'focusout':
17040
+ this._hasKeyboardInteraction = isInteracting;
17041
+ break;
17042
+ }
17043
+
17044
+ if (isInteracting) {
17045
+ this._clearTimeout();
17046
+
17047
+ return;
17048
+ }
17049
+
17050
+ const nextElement = event.relatedTarget;
17051
+
17052
+ if (this._element === nextElement || this._element.contains(nextElement)) {
17053
+ return;
17054
+ }
17055
+
17056
+ this._maybeScheduleHide();
17057
+ }
17058
+
17050
17059
  _setListeners() {
17051
17060
  EventHandler.on(this._element, EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, () => this.hide());
17061
+ EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
17062
+ EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
17063
+ EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
17064
+ EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
17052
17065
  }
17053
17066
 
17054
17067
  _clearTimeout() {
@@ -17086,11 +17099,11 @@ return jQuery;
17086
17099
  */
17087
17100
 
17088
17101
 
17089
- defineJQueryPlugin(NAME, Toast);
17102
+ defineJQueryPlugin(Toast);
17090
17103
 
17091
17104
  /**
17092
17105
  * --------------------------------------------------------------------------
17093
- * Bootstrap (v5.0.0-beta3): index.umd.js
17106
+ * Bootstrap (v5.0.1): index.umd.js
17094
17107
  * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
17095
17108
  * --------------------------------------------------------------------------
17096
17109
  */
@@ -17580,22 +17593,22 @@ mumuki.load(function () {
17580
17593
  })
17581
17594
  }
17582
17595
 
17583
- function getBrowserMain($browser) {
17584
- return $([
17585
- '<main>',
17586
- ' <iframe srcdoc="', escapeHTML($browser.data('srcdoc')), '" frameborder="0"></iframe>',
17587
- '</main>'
17588
- ].join(''));
17596
+ function getBrowserMain($browser, options) {
17597
+ return $(`
17598
+ <main>
17599
+ <iframe srcdoc="${escapeHTML($browser.data('srcdoc'))}" frameborder="0" ${options.allowScript ? '' : 'sandbox'}></iframe>
17600
+ </main>
17601
+ `);
17589
17602
  }
17590
17603
 
17591
- $.fn.renderWebBrowser = function () {
17604
+ $.fn.renderWebBrowser = function (options = {}) {
17592
17605
  var self = this;
17593
17606
  self.empty();
17594
17607
  self.each(function (i) {
17595
17608
  var $browser = $(self[i]);
17596
17609
 
17597
17610
  var $header = getBrowserHeader($browser);
17598
- var $main = getBrowserMain($browser);
17611
+ var $main = getBrowserMain($browser, options);
17599
17612
 
17600
17613
  $browser.empty();
17601
17614
 
@@ -17610,9 +17623,7 @@ mumuki.load(function () {
17610
17623
  return self;
17611
17624
  }
17612
17625
 
17613
- mumuki.resize(function () {
17614
- $('.mu-browser').renderWebBrowser();
17615
- });
17626
+ $('.mu-browser').renderWebBrowser();
17616
17627
 
17617
17628
  });
17618
17629
 
@@ -17827,10 +17838,10 @@ mumuki.load(function () {
17827
17838
 
17828
17839
  mumuki.load(function () {
17829
17840
 
17830
- $.fn.renderMuComponents = function () {
17841
+ $.fn.renderMuComponents = function (options = {}) {
17831
17842
  this.find('.mu-erd').renderERD();
17832
17843
  this.find('pre').renderCopyPaste();
17833
- this.find('.mu-browser').renderWebBrowser();
17844
+ this.find('.mu-browser').renderWebBrowser(options.webBrowser);
17834
17845
  this.find('.mu-sql-table').renderSqlTable();
17835
17846
  this.find('.mu-file-browser').renderFileBrowser();
17836
17847
  this.find('.mu-sql-table-rendered').renderPrerenderedSqlTable();