jekyll-theme-centos 2.51.1.beta.24 → 2.51.1.beta.26

Sign up to get free protection for your applications and to get access to all the features.
Files changed (108) hide show
  1. checksums.yaml +4 -4
  2. data/_sass/bootstrap/_accordion.scss +158 -0
  3. data/_sass/bootstrap/_alert.scss +68 -0
  4. data/_sass/bootstrap/_badge.scss +38 -0
  5. data/_sass/bootstrap/_breadcrumb.scss +40 -0
  6. data/_sass/bootstrap/_button-group.scss +142 -0
  7. data/_sass/bootstrap/_buttons.scss +216 -0
  8. data/_sass/bootstrap/_card.scss +239 -0
  9. data/_sass/bootstrap/_carousel.scss +236 -0
  10. data/_sass/bootstrap/_close.scss +63 -0
  11. data/_sass/bootstrap/_containers.scss +41 -0
  12. data/_sass/bootstrap/_dropdown.scss +250 -0
  13. data/_sass/bootstrap/_forms.scss +9 -0
  14. data/_sass/bootstrap/_functions.scss +302 -0
  15. data/_sass/bootstrap/_grid.scss +39 -0
  16. data/_sass/bootstrap/_helpers.scss +12 -0
  17. data/_sass/bootstrap/_images.scss +42 -0
  18. data/_sass/bootstrap/_list-group.scss +197 -0
  19. data/_sass/bootstrap/_maps.scss +174 -0
  20. data/_sass/bootstrap/_mixins.scss +42 -0
  21. data/_sass/bootstrap/_modal.scss +236 -0
  22. data/_sass/bootstrap/_nav.scss +197 -0
  23. data/_sass/bootstrap/_navbar.scss +289 -0
  24. data/_sass/bootstrap/_offcanvas.scss +143 -0
  25. data/_sass/bootstrap/_pagination.scss +109 -0
  26. data/_sass/bootstrap/_placeholders.scss +51 -0
  27. data/_sass/bootstrap/_popover.scss +196 -0
  28. data/_sass/bootstrap/_progress.scss +68 -0
  29. data/_sass/bootstrap/_reboot.scss +611 -0
  30. data/_sass/bootstrap/_root.scss +187 -0
  31. data/_sass/bootstrap/_spinners.scss +85 -0
  32. data/_sass/bootstrap/_tables.scss +171 -0
  33. data/_sass/bootstrap/_toasts.scss +73 -0
  34. data/_sass/bootstrap/_tooltip.scss +119 -0
  35. data/_sass/bootstrap/_transitions.scss +27 -0
  36. data/_sass/bootstrap/_type.scss +106 -0
  37. data/_sass/bootstrap/_utilities.scss +806 -0
  38. data/_sass/bootstrap/_variables-dark.scss +87 -0
  39. data/_sass/bootstrap/_variables.scss +1751 -0
  40. data/_sass/bootstrap/bootstrap-grid.scss +62 -0
  41. data/_sass/bootstrap/bootstrap-reboot.scss +10 -0
  42. data/_sass/bootstrap/bootstrap-utilities.scss +19 -0
  43. data/_sass/bootstrap/bootstrap.scss +52 -0
  44. data/_sass/bootstrap/forms/_floating-labels.scss +95 -0
  45. data/_sass/bootstrap/forms/_form-check.scss +189 -0
  46. data/_sass/bootstrap/forms/_form-control.scss +214 -0
  47. data/_sass/bootstrap/forms/_form-range.scss +91 -0
  48. data/_sass/bootstrap/forms/_form-select.scss +80 -0
  49. data/_sass/bootstrap/forms/_form-text.scss +11 -0
  50. data/_sass/bootstrap/forms/_input-group.scss +132 -0
  51. data/_sass/bootstrap/forms/_labels.scss +36 -0
  52. data/_sass/bootstrap/forms/_validation.scss +12 -0
  53. data/_sass/bootstrap/helpers/_clearfix.scss +3 -0
  54. data/_sass/bootstrap/helpers/_color-bg.scss +7 -0
  55. data/_sass/bootstrap/helpers/_colored-links.scss +30 -0
  56. data/_sass/bootstrap/helpers/_focus-ring.scss +5 -0
  57. data/_sass/bootstrap/helpers/_icon-link.scss +25 -0
  58. data/_sass/bootstrap/helpers/_position.scss +36 -0
  59. data/_sass/bootstrap/helpers/_ratio.scss +26 -0
  60. data/_sass/bootstrap/helpers/_stacks.scss +15 -0
  61. data/_sass/bootstrap/helpers/_stretched-link.scss +15 -0
  62. data/_sass/bootstrap/helpers/_text-truncation.scss +7 -0
  63. data/_sass/bootstrap/helpers/_visually-hidden.scss +8 -0
  64. data/_sass/bootstrap/helpers/_vr.scss +8 -0
  65. data/_sass/bootstrap/mixins/_alert.scss +18 -0
  66. data/_sass/bootstrap/mixins/_backdrop.scss +14 -0
  67. data/_sass/bootstrap/mixins/_banner.scss +7 -0
  68. data/_sass/bootstrap/mixins/_border-radius.scss +78 -0
  69. data/_sass/bootstrap/mixins/_box-shadow.scss +18 -0
  70. data/_sass/bootstrap/mixins/_breakpoints.scss +127 -0
  71. data/_sass/bootstrap/mixins/_buttons.scss +70 -0
  72. data/_sass/bootstrap/mixins/_caret.scss +69 -0
  73. data/_sass/bootstrap/mixins/_clearfix.scss +9 -0
  74. data/_sass/bootstrap/mixins/_color-mode.scss +21 -0
  75. data/_sass/bootstrap/mixins/_color-scheme.scss +7 -0
  76. data/_sass/bootstrap/mixins/_container.scss +11 -0
  77. data/_sass/bootstrap/mixins/_deprecate.scss +10 -0
  78. data/_sass/bootstrap/mixins/_forms.scss +163 -0
  79. data/_sass/bootstrap/mixins/_gradients.scss +47 -0
  80. data/_sass/bootstrap/mixins/_grid.scss +151 -0
  81. data/_sass/bootstrap/mixins/_image.scss +16 -0
  82. data/_sass/bootstrap/mixins/_list-group.scss +26 -0
  83. data/_sass/bootstrap/mixins/_lists.scss +7 -0
  84. data/_sass/bootstrap/mixins/_pagination.scss +10 -0
  85. data/_sass/bootstrap/mixins/_reset-text.scss +17 -0
  86. data/_sass/bootstrap/mixins/_resize.scss +6 -0
  87. data/_sass/bootstrap/mixins/_table-variants.scss +24 -0
  88. data/_sass/bootstrap/mixins/_text-truncate.scss +8 -0
  89. data/_sass/bootstrap/mixins/_transition.scss +26 -0
  90. data/_sass/bootstrap/mixins/_utilities.scss +97 -0
  91. data/_sass/bootstrap/mixins/_visually-hidden.scss +33 -0
  92. data/_sass/bootstrap/utilities/_api.scss +47 -0
  93. data/_sass/bootstrap/vendor/_rfs.scss +348 -0
  94. data/assets/js/bootstrap.bundle.js +6314 -0
  95. data/assets/js/bootstrap.bundle.js.map +1 -0
  96. data/assets/js/bootstrap.bundle.min.js +7 -0
  97. data/assets/js/bootstrap.bundle.min.js.map +1 -0
  98. data/assets/js/bootstrap.esm.js +4447 -0
  99. data/assets/js/bootstrap.esm.js.map +1 -0
  100. data/assets/js/bootstrap.esm.min.js +7 -0
  101. data/assets/js/bootstrap.esm.min.js.map +1 -0
  102. data/assets/js/bootstrap.js +4494 -0
  103. data/assets/js/bootstrap.js.map +1 -0
  104. data/assets/js/bootstrap.min.js +7 -0
  105. data/assets/js/bootstrap.min.js.map +1 -0
  106. metadata +105 -3
  107. data/assets/icons/favicon.ico +0 -0
  108. data/assets/icons/favicon.svg +0 -1
@@ -0,0 +1,4447 @@
1
+ /*!
2
+ * Bootstrap v5.3.3 (https://getbootstrap.com/)
3
+ * Copyright 2011-2024 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
4
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
5
+ */
6
+ import * as Popper from '@popperjs/core';
7
+
8
+ /**
9
+ * --------------------------------------------------------------------------
10
+ * Bootstrap dom/data.js
11
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
12
+ * --------------------------------------------------------------------------
13
+ */
14
+
15
+ /**
16
+ * Constants
17
+ */
18
+
19
+ const elementMap = new Map();
20
+ const Data = {
21
+ set(element, key, instance) {
22
+ if (!elementMap.has(element)) {
23
+ elementMap.set(element, new Map());
24
+ }
25
+ const instanceMap = elementMap.get(element);
26
+
27
+ // make it clear we only want one instance per element
28
+ // can be removed later when multiple key/instances are fine to be used
29
+ if (!instanceMap.has(key) && instanceMap.size !== 0) {
30
+ // eslint-disable-next-line no-console
31
+ console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`);
32
+ return;
33
+ }
34
+ instanceMap.set(key, instance);
35
+ },
36
+ get(element, key) {
37
+ if (elementMap.has(element)) {
38
+ return elementMap.get(element).get(key) || null;
39
+ }
40
+ return null;
41
+ },
42
+ remove(element, key) {
43
+ if (!elementMap.has(element)) {
44
+ return;
45
+ }
46
+ const instanceMap = elementMap.get(element);
47
+ instanceMap.delete(key);
48
+
49
+ // free up element references if there are no instances left for an element
50
+ if (instanceMap.size === 0) {
51
+ elementMap.delete(element);
52
+ }
53
+ }
54
+ };
55
+
56
+ /**
57
+ * --------------------------------------------------------------------------
58
+ * Bootstrap util/index.js
59
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
60
+ * --------------------------------------------------------------------------
61
+ */
62
+
63
+ const MAX_UID = 1000000;
64
+ const MILLISECONDS_MULTIPLIER = 1000;
65
+ const TRANSITION_END = 'transitionend';
66
+
67
+ /**
68
+ * Properly escape IDs selectors to handle weird IDs
69
+ * @param {string} selector
70
+ * @returns {string}
71
+ */
72
+ const parseSelector = selector => {
73
+ if (selector && window.CSS && window.CSS.escape) {
74
+ // document.querySelector needs escaping to handle IDs (html5+) containing for instance /
75
+ selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`);
76
+ }
77
+ return selector;
78
+ };
79
+
80
+ // Shout-out Angus Croll (https://goo.gl/pxwQGp)
81
+ const toType = object => {
82
+ if (object === null || object === undefined) {
83
+ return `${object}`;
84
+ }
85
+ return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase();
86
+ };
87
+
88
+ /**
89
+ * Public Util API
90
+ */
91
+
92
+ const getUID = prefix => {
93
+ do {
94
+ prefix += Math.floor(Math.random() * MAX_UID);
95
+ } while (document.getElementById(prefix));
96
+ return prefix;
97
+ };
98
+ const getTransitionDurationFromElement = element => {
99
+ if (!element) {
100
+ return 0;
101
+ }
102
+
103
+ // Get transition-duration of the element
104
+ let {
105
+ transitionDuration,
106
+ transitionDelay
107
+ } = window.getComputedStyle(element);
108
+ const floatTransitionDuration = Number.parseFloat(transitionDuration);
109
+ const floatTransitionDelay = Number.parseFloat(transitionDelay);
110
+
111
+ // Return 0 if element or transition duration is not found
112
+ if (!floatTransitionDuration && !floatTransitionDelay) {
113
+ return 0;
114
+ }
115
+
116
+ // If multiple durations are defined, take the first
117
+ transitionDuration = transitionDuration.split(',')[0];
118
+ transitionDelay = transitionDelay.split(',')[0];
119
+ return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER;
120
+ };
121
+ const triggerTransitionEnd = element => {
122
+ element.dispatchEvent(new Event(TRANSITION_END));
123
+ };
124
+ const isElement = object => {
125
+ if (!object || typeof object !== 'object') {
126
+ return false;
127
+ }
128
+ if (typeof object.jquery !== 'undefined') {
129
+ object = object[0];
130
+ }
131
+ return typeof object.nodeType !== 'undefined';
132
+ };
133
+ const getElement = object => {
134
+ // it's a jQuery object or a node element
135
+ if (isElement(object)) {
136
+ return object.jquery ? object[0] : object;
137
+ }
138
+ if (typeof object === 'string' && object.length > 0) {
139
+ return document.querySelector(parseSelector(object));
140
+ }
141
+ return null;
142
+ };
143
+ const isVisible = element => {
144
+ if (!isElement(element) || element.getClientRects().length === 0) {
145
+ return false;
146
+ }
147
+ const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible';
148
+ // Handle `details` element as its content may falsie appear visible when it is closed
149
+ const closedDetails = element.closest('details:not([open])');
150
+ if (!closedDetails) {
151
+ return elementIsVisible;
152
+ }
153
+ if (closedDetails !== element) {
154
+ const summary = element.closest('summary');
155
+ if (summary && summary.parentNode !== closedDetails) {
156
+ return false;
157
+ }
158
+ if (summary === null) {
159
+ return false;
160
+ }
161
+ }
162
+ return elementIsVisible;
163
+ };
164
+ const isDisabled = element => {
165
+ if (!element || element.nodeType !== Node.ELEMENT_NODE) {
166
+ return true;
167
+ }
168
+ if (element.classList.contains('disabled')) {
169
+ return true;
170
+ }
171
+ if (typeof element.disabled !== 'undefined') {
172
+ return element.disabled;
173
+ }
174
+ return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false';
175
+ };
176
+ const findShadowRoot = element => {
177
+ if (!document.documentElement.attachShadow) {
178
+ return null;
179
+ }
180
+
181
+ // Can find the shadow root otherwise it'll return the document
182
+ if (typeof element.getRootNode === 'function') {
183
+ const root = element.getRootNode();
184
+ return root instanceof ShadowRoot ? root : null;
185
+ }
186
+ if (element instanceof ShadowRoot) {
187
+ return element;
188
+ }
189
+
190
+ // when we don't find a shadow root
191
+ if (!element.parentNode) {
192
+ return null;
193
+ }
194
+ return findShadowRoot(element.parentNode);
195
+ };
196
+ const noop = () => {};
197
+
198
+ /**
199
+ * Trick to restart an element's animation
200
+ *
201
+ * @param {HTMLElement} element
202
+ * @return void
203
+ *
204
+ * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation
205
+ */
206
+ const reflow = element => {
207
+ element.offsetHeight; // eslint-disable-line no-unused-expressions
208
+ };
209
+ const getjQuery = () => {
210
+ if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) {
211
+ return window.jQuery;
212
+ }
213
+ return null;
214
+ };
215
+ const DOMContentLoadedCallbacks = [];
216
+ const onDOMContentLoaded = callback => {
217
+ if (document.readyState === 'loading') {
218
+ // add listener on the first call when the document is in loading state
219
+ if (!DOMContentLoadedCallbacks.length) {
220
+ document.addEventListener('DOMContentLoaded', () => {
221
+ for (const callback of DOMContentLoadedCallbacks) {
222
+ callback();
223
+ }
224
+ });
225
+ }
226
+ DOMContentLoadedCallbacks.push(callback);
227
+ } else {
228
+ callback();
229
+ }
230
+ };
231
+ const isRTL = () => document.documentElement.dir === 'rtl';
232
+ const defineJQueryPlugin = plugin => {
233
+ onDOMContentLoaded(() => {
234
+ const $ = getjQuery();
235
+ /* istanbul ignore if */
236
+ if ($) {
237
+ const name = plugin.NAME;
238
+ const JQUERY_NO_CONFLICT = $.fn[name];
239
+ $.fn[name] = plugin.jQueryInterface;
240
+ $.fn[name].Constructor = plugin;
241
+ $.fn[name].noConflict = () => {
242
+ $.fn[name] = JQUERY_NO_CONFLICT;
243
+ return plugin.jQueryInterface;
244
+ };
245
+ }
246
+ });
247
+ };
248
+ const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => {
249
+ return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue;
250
+ };
251
+ const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => {
252
+ if (!waitForTransition) {
253
+ execute(callback);
254
+ return;
255
+ }
256
+ const durationPadding = 5;
257
+ const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding;
258
+ let called = false;
259
+ const handler = ({
260
+ target
261
+ }) => {
262
+ if (target !== transitionElement) {
263
+ return;
264
+ }
265
+ called = true;
266
+ transitionElement.removeEventListener(TRANSITION_END, handler);
267
+ execute(callback);
268
+ };
269
+ transitionElement.addEventListener(TRANSITION_END, handler);
270
+ setTimeout(() => {
271
+ if (!called) {
272
+ triggerTransitionEnd(transitionElement);
273
+ }
274
+ }, emulatedDuration);
275
+ };
276
+
277
+ /**
278
+ * Return the previous/next element of a list.
279
+ *
280
+ * @param {array} list The list of elements
281
+ * @param activeElement The active element
282
+ * @param shouldGetNext Choose to get next or previous element
283
+ * @param isCycleAllowed
284
+ * @return {Element|elem} The proper element
285
+ */
286
+ const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => {
287
+ const listLength = list.length;
288
+ let index = list.indexOf(activeElement);
289
+
290
+ // if the element does not exist in the list return an element
291
+ // depending on the direction and if cycle is allowed
292
+ if (index === -1) {
293
+ return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0];
294
+ }
295
+ index += shouldGetNext ? 1 : -1;
296
+ if (isCycleAllowed) {
297
+ index = (index + listLength) % listLength;
298
+ }
299
+ return list[Math.max(0, Math.min(index, listLength - 1))];
300
+ };
301
+
302
+ /**
303
+ * --------------------------------------------------------------------------
304
+ * Bootstrap dom/event-handler.js
305
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
306
+ * --------------------------------------------------------------------------
307
+ */
308
+
309
+
310
+ /**
311
+ * Constants
312
+ */
313
+
314
+ const namespaceRegex = /[^.]*(?=\..*)\.|.*/;
315
+ const stripNameRegex = /\..*/;
316
+ const stripUidRegex = /::\d+$/;
317
+ const eventRegistry = {}; // Events storage
318
+ let uidEvent = 1;
319
+ const customEvents = {
320
+ mouseenter: 'mouseover',
321
+ mouseleave: 'mouseout'
322
+ };
323
+ 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']);
324
+
325
+ /**
326
+ * Private methods
327
+ */
328
+
329
+ function makeEventUid(element, uid) {
330
+ return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++;
331
+ }
332
+ function getElementEvents(element) {
333
+ const uid = makeEventUid(element);
334
+ element.uidEvent = uid;
335
+ eventRegistry[uid] = eventRegistry[uid] || {};
336
+ return eventRegistry[uid];
337
+ }
338
+ function bootstrapHandler(element, fn) {
339
+ return function handler(event) {
340
+ hydrateObj(event, {
341
+ delegateTarget: element
342
+ });
343
+ if (handler.oneOff) {
344
+ EventHandler.off(element, event.type, fn);
345
+ }
346
+ return fn.apply(element, [event]);
347
+ };
348
+ }
349
+ function bootstrapDelegationHandler(element, selector, fn) {
350
+ return function handler(event) {
351
+ const domElements = element.querySelectorAll(selector);
352
+ for (let {
353
+ target
354
+ } = event; target && target !== this; target = target.parentNode) {
355
+ for (const domElement of domElements) {
356
+ if (domElement !== target) {
357
+ continue;
358
+ }
359
+ hydrateObj(event, {
360
+ delegateTarget: target
361
+ });
362
+ if (handler.oneOff) {
363
+ EventHandler.off(element, event.type, selector, fn);
364
+ }
365
+ return fn.apply(target, [event]);
366
+ }
367
+ }
368
+ };
369
+ }
370
+ function findHandler(events, callable, delegationSelector = null) {
371
+ return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector);
372
+ }
373
+ function normalizeParameters(originalTypeEvent, handler, delegationFunction) {
374
+ const isDelegated = typeof handler === 'string';
375
+ // TODO: tooltip passes `false` instead of selector, so we need to check
376
+ const callable = isDelegated ? delegationFunction : handler || delegationFunction;
377
+ let typeEvent = getTypeEvent(originalTypeEvent);
378
+ if (!nativeEvents.has(typeEvent)) {
379
+ typeEvent = originalTypeEvent;
380
+ }
381
+ return [isDelegated, callable, typeEvent];
382
+ }
383
+ function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) {
384
+ if (typeof originalTypeEvent !== 'string' || !element) {
385
+ return;
386
+ }
387
+ let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
388
+
389
+ // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
390
+ // this prevents the handler from being dispatched the same way as mouseover or mouseout does
391
+ if (originalTypeEvent in customEvents) {
392
+ const wrapFunction = fn => {
393
+ return function (event) {
394
+ if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) {
395
+ return fn.call(this, event);
396
+ }
397
+ };
398
+ };
399
+ callable = wrapFunction(callable);
400
+ }
401
+ const events = getElementEvents(element);
402
+ const handlers = events[typeEvent] || (events[typeEvent] = {});
403
+ const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null);
404
+ if (previousFunction) {
405
+ previousFunction.oneOff = previousFunction.oneOff && oneOff;
406
+ return;
407
+ }
408
+ const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, ''));
409
+ const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable);
410
+ fn.delegationSelector = isDelegated ? handler : null;
411
+ fn.callable = callable;
412
+ fn.oneOff = oneOff;
413
+ fn.uidEvent = uid;
414
+ handlers[uid] = fn;
415
+ element.addEventListener(typeEvent, fn, isDelegated);
416
+ }
417
+ function removeHandler(element, events, typeEvent, handler, delegationSelector) {
418
+ const fn = findHandler(events[typeEvent], handler, delegationSelector);
419
+ if (!fn) {
420
+ return;
421
+ }
422
+ element.removeEventListener(typeEvent, fn, Boolean(delegationSelector));
423
+ delete events[typeEvent][fn.uidEvent];
424
+ }
425
+ function removeNamespacedHandlers(element, events, typeEvent, namespace) {
426
+ const storeElementEvent = events[typeEvent] || {};
427
+ for (const [handlerKey, event] of Object.entries(storeElementEvent)) {
428
+ if (handlerKey.includes(namespace)) {
429
+ removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
430
+ }
431
+ }
432
+ }
433
+ function getTypeEvent(event) {
434
+ // allow to get the native events from namespaced events ('click.bs.button' --> 'click')
435
+ event = event.replace(stripNameRegex, '');
436
+ return customEvents[event] || event;
437
+ }
438
+ const EventHandler = {
439
+ on(element, event, handler, delegationFunction) {
440
+ addHandler(element, event, handler, delegationFunction, false);
441
+ },
442
+ one(element, event, handler, delegationFunction) {
443
+ addHandler(element, event, handler, delegationFunction, true);
444
+ },
445
+ off(element, originalTypeEvent, handler, delegationFunction) {
446
+ if (typeof originalTypeEvent !== 'string' || !element) {
447
+ return;
448
+ }
449
+ const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction);
450
+ const inNamespace = typeEvent !== originalTypeEvent;
451
+ const events = getElementEvents(element);
452
+ const storeElementEvent = events[typeEvent] || {};
453
+ const isNamespace = originalTypeEvent.startsWith('.');
454
+ if (typeof callable !== 'undefined') {
455
+ // Simplest case: handler is passed, remove that listener ONLY.
456
+ if (!Object.keys(storeElementEvent).length) {
457
+ return;
458
+ }
459
+ removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null);
460
+ return;
461
+ }
462
+ if (isNamespace) {
463
+ for (const elementEvent of Object.keys(events)) {
464
+ removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1));
465
+ }
466
+ }
467
+ for (const [keyHandlers, event] of Object.entries(storeElementEvent)) {
468
+ const handlerKey = keyHandlers.replace(stripUidRegex, '');
469
+ if (!inNamespace || originalTypeEvent.includes(handlerKey)) {
470
+ removeHandler(element, events, typeEvent, event.callable, event.delegationSelector);
471
+ }
472
+ }
473
+ },
474
+ trigger(element, event, args) {
475
+ if (typeof event !== 'string' || !element) {
476
+ return null;
477
+ }
478
+ const $ = getjQuery();
479
+ const typeEvent = getTypeEvent(event);
480
+ const inNamespace = event !== typeEvent;
481
+ let jQueryEvent = null;
482
+ let bubbles = true;
483
+ let nativeDispatch = true;
484
+ let defaultPrevented = false;
485
+ if (inNamespace && $) {
486
+ jQueryEvent = $.Event(event, args);
487
+ $(element).trigger(jQueryEvent);
488
+ bubbles = !jQueryEvent.isPropagationStopped();
489
+ nativeDispatch = !jQueryEvent.isImmediatePropagationStopped();
490
+ defaultPrevented = jQueryEvent.isDefaultPrevented();
491
+ }
492
+ const evt = hydrateObj(new Event(event, {
493
+ bubbles,
494
+ cancelable: true
495
+ }), args);
496
+ if (defaultPrevented) {
497
+ evt.preventDefault();
498
+ }
499
+ if (nativeDispatch) {
500
+ element.dispatchEvent(evt);
501
+ }
502
+ if (evt.defaultPrevented && jQueryEvent) {
503
+ jQueryEvent.preventDefault();
504
+ }
505
+ return evt;
506
+ }
507
+ };
508
+ function hydrateObj(obj, meta = {}) {
509
+ for (const [key, value] of Object.entries(meta)) {
510
+ try {
511
+ obj[key] = value;
512
+ } catch (_unused) {
513
+ Object.defineProperty(obj, key, {
514
+ configurable: true,
515
+ get() {
516
+ return value;
517
+ }
518
+ });
519
+ }
520
+ }
521
+ return obj;
522
+ }
523
+
524
+ /**
525
+ * --------------------------------------------------------------------------
526
+ * Bootstrap dom/manipulator.js
527
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
528
+ * --------------------------------------------------------------------------
529
+ */
530
+
531
+ function normalizeData(value) {
532
+ if (value === 'true') {
533
+ return true;
534
+ }
535
+ if (value === 'false') {
536
+ return false;
537
+ }
538
+ if (value === Number(value).toString()) {
539
+ return Number(value);
540
+ }
541
+ if (value === '' || value === 'null') {
542
+ return null;
543
+ }
544
+ if (typeof value !== 'string') {
545
+ return value;
546
+ }
547
+ try {
548
+ return JSON.parse(decodeURIComponent(value));
549
+ } catch (_unused) {
550
+ return value;
551
+ }
552
+ }
553
+ function normalizeDataKey(key) {
554
+ return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`);
555
+ }
556
+ const Manipulator = {
557
+ setDataAttribute(element, key, value) {
558
+ element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value);
559
+ },
560
+ removeDataAttribute(element, key) {
561
+ element.removeAttribute(`data-bs-${normalizeDataKey(key)}`);
562
+ },
563
+ getDataAttributes(element) {
564
+ if (!element) {
565
+ return {};
566
+ }
567
+ const attributes = {};
568
+ const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig'));
569
+ for (const key of bsKeys) {
570
+ let pureKey = key.replace(/^bs/, '');
571
+ pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length);
572
+ attributes[pureKey] = normalizeData(element.dataset[key]);
573
+ }
574
+ return attributes;
575
+ },
576
+ getDataAttribute(element, key) {
577
+ return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`));
578
+ }
579
+ };
580
+
581
+ /**
582
+ * --------------------------------------------------------------------------
583
+ * Bootstrap util/config.js
584
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
585
+ * --------------------------------------------------------------------------
586
+ */
587
+
588
+
589
+ /**
590
+ * Class definition
591
+ */
592
+
593
+ class Config {
594
+ // Getters
595
+ static get Default() {
596
+ return {};
597
+ }
598
+ static get DefaultType() {
599
+ return {};
600
+ }
601
+ static get NAME() {
602
+ throw new Error('You have to implement the static method "NAME", for each component!');
603
+ }
604
+ _getConfig(config) {
605
+ config = this._mergeConfigObj(config);
606
+ config = this._configAfterMerge(config);
607
+ this._typeCheckConfig(config);
608
+ return config;
609
+ }
610
+ _configAfterMerge(config) {
611
+ return config;
612
+ }
613
+ _mergeConfigObj(config, element) {
614
+ const jsonConfig = isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse
615
+
616
+ return {
617
+ ...this.constructor.Default,
618
+ ...(typeof jsonConfig === 'object' ? jsonConfig : {}),
619
+ ...(isElement(element) ? Manipulator.getDataAttributes(element) : {}),
620
+ ...(typeof config === 'object' ? config : {})
621
+ };
622
+ }
623
+ _typeCheckConfig(config, configTypes = this.constructor.DefaultType) {
624
+ for (const [property, expectedTypes] of Object.entries(configTypes)) {
625
+ const value = config[property];
626
+ const valueType = isElement(value) ? 'element' : toType(value);
627
+ if (!new RegExp(expectedTypes).test(valueType)) {
628
+ throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`);
629
+ }
630
+ }
631
+ }
632
+ }
633
+
634
+ /**
635
+ * --------------------------------------------------------------------------
636
+ * Bootstrap base-component.js
637
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
638
+ * --------------------------------------------------------------------------
639
+ */
640
+
641
+
642
+ /**
643
+ * Constants
644
+ */
645
+
646
+ const VERSION = '5.3.3';
647
+
648
+ /**
649
+ * Class definition
650
+ */
651
+
652
+ class BaseComponent extends Config {
653
+ constructor(element, config) {
654
+ super();
655
+ element = getElement(element);
656
+ if (!element) {
657
+ return;
658
+ }
659
+ this._element = element;
660
+ this._config = this._getConfig(config);
661
+ Data.set(this._element, this.constructor.DATA_KEY, this);
662
+ }
663
+
664
+ // Public
665
+ dispose() {
666
+ Data.remove(this._element, this.constructor.DATA_KEY);
667
+ EventHandler.off(this._element, this.constructor.EVENT_KEY);
668
+ for (const propertyName of Object.getOwnPropertyNames(this)) {
669
+ this[propertyName] = null;
670
+ }
671
+ }
672
+ _queueCallback(callback, element, isAnimated = true) {
673
+ executeAfterTransition(callback, element, isAnimated);
674
+ }
675
+ _getConfig(config) {
676
+ config = this._mergeConfigObj(config, this._element);
677
+ config = this._configAfterMerge(config);
678
+ this._typeCheckConfig(config);
679
+ return config;
680
+ }
681
+
682
+ // Static
683
+ static getInstance(element) {
684
+ return Data.get(getElement(element), this.DATA_KEY);
685
+ }
686
+ static getOrCreateInstance(element, config = {}) {
687
+ return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null);
688
+ }
689
+ static get VERSION() {
690
+ return VERSION;
691
+ }
692
+ static get DATA_KEY() {
693
+ return `bs.${this.NAME}`;
694
+ }
695
+ static get EVENT_KEY() {
696
+ return `.${this.DATA_KEY}`;
697
+ }
698
+ static eventName(name) {
699
+ return `${name}${this.EVENT_KEY}`;
700
+ }
701
+ }
702
+
703
+ /**
704
+ * --------------------------------------------------------------------------
705
+ * Bootstrap dom/selector-engine.js
706
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
707
+ * --------------------------------------------------------------------------
708
+ */
709
+
710
+ const getSelector = element => {
711
+ let selector = element.getAttribute('data-bs-target');
712
+ if (!selector || selector === '#') {
713
+ let hrefAttribute = element.getAttribute('href');
714
+
715
+ // The only valid content that could double as a selector are IDs or classes,
716
+ // so everything starting with `#` or `.`. If a "real" URL is used as the selector,
717
+ // `document.querySelector` will rightfully complain it is invalid.
718
+ // See https://github.com/twbs/bootstrap/issues/32273
719
+ if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) {
720
+ return null;
721
+ }
722
+
723
+ // Just in case some CMS puts out a full URL with the anchor appended
724
+ if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) {
725
+ hrefAttribute = `#${hrefAttribute.split('#')[1]}`;
726
+ }
727
+ selector = hrefAttribute && hrefAttribute !== '#' ? hrefAttribute.trim() : null;
728
+ }
729
+ return selector ? selector.split(',').map(sel => parseSelector(sel)).join(',') : null;
730
+ };
731
+ const SelectorEngine = {
732
+ find(selector, element = document.documentElement) {
733
+ return [].concat(...Element.prototype.querySelectorAll.call(element, selector));
734
+ },
735
+ findOne(selector, element = document.documentElement) {
736
+ return Element.prototype.querySelector.call(element, selector);
737
+ },
738
+ children(element, selector) {
739
+ return [].concat(...element.children).filter(child => child.matches(selector));
740
+ },
741
+ parents(element, selector) {
742
+ const parents = [];
743
+ let ancestor = element.parentNode.closest(selector);
744
+ while (ancestor) {
745
+ parents.push(ancestor);
746
+ ancestor = ancestor.parentNode.closest(selector);
747
+ }
748
+ return parents;
749
+ },
750
+ prev(element, selector) {
751
+ let previous = element.previousElementSibling;
752
+ while (previous) {
753
+ if (previous.matches(selector)) {
754
+ return [previous];
755
+ }
756
+ previous = previous.previousElementSibling;
757
+ }
758
+ return [];
759
+ },
760
+ // TODO: this is now unused; remove later along with prev()
761
+ next(element, selector) {
762
+ let next = element.nextElementSibling;
763
+ while (next) {
764
+ if (next.matches(selector)) {
765
+ return [next];
766
+ }
767
+ next = next.nextElementSibling;
768
+ }
769
+ return [];
770
+ },
771
+ focusableChildren(element) {
772
+ const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(',');
773
+ return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el));
774
+ },
775
+ getSelectorFromElement(element) {
776
+ const selector = getSelector(element);
777
+ if (selector) {
778
+ return SelectorEngine.findOne(selector) ? selector : null;
779
+ }
780
+ return null;
781
+ },
782
+ getElementFromSelector(element) {
783
+ const selector = getSelector(element);
784
+ return selector ? SelectorEngine.findOne(selector) : null;
785
+ },
786
+ getMultipleElementsFromSelector(element) {
787
+ const selector = getSelector(element);
788
+ return selector ? SelectorEngine.find(selector) : [];
789
+ }
790
+ };
791
+
792
+ /**
793
+ * --------------------------------------------------------------------------
794
+ * Bootstrap util/component-functions.js
795
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
796
+ * --------------------------------------------------------------------------
797
+ */
798
+
799
+ const enableDismissTrigger = (component, method = 'hide') => {
800
+ const clickEvent = `click.dismiss${component.EVENT_KEY}`;
801
+ const name = component.NAME;
802
+ EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) {
803
+ if (['A', 'AREA'].includes(this.tagName)) {
804
+ event.preventDefault();
805
+ }
806
+ if (isDisabled(this)) {
807
+ return;
808
+ }
809
+ const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`);
810
+ const instance = component.getOrCreateInstance(target);
811
+
812
+ // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method
813
+ instance[method]();
814
+ });
815
+ };
816
+
817
+ /**
818
+ * --------------------------------------------------------------------------
819
+ * Bootstrap alert.js
820
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
821
+ * --------------------------------------------------------------------------
822
+ */
823
+
824
+
825
+ /**
826
+ * Constants
827
+ */
828
+
829
+ const NAME$f = 'alert';
830
+ const DATA_KEY$a = 'bs.alert';
831
+ const EVENT_KEY$b = `.${DATA_KEY$a}`;
832
+ const EVENT_CLOSE = `close${EVENT_KEY$b}`;
833
+ const EVENT_CLOSED = `closed${EVENT_KEY$b}`;
834
+ const CLASS_NAME_FADE$5 = 'fade';
835
+ const CLASS_NAME_SHOW$8 = 'show';
836
+
837
+ /**
838
+ * Class definition
839
+ */
840
+
841
+ class Alert extends BaseComponent {
842
+ // Getters
843
+ static get NAME() {
844
+ return NAME$f;
845
+ }
846
+
847
+ // Public
848
+ close() {
849
+ const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE);
850
+ if (closeEvent.defaultPrevented) {
851
+ return;
852
+ }
853
+ this._element.classList.remove(CLASS_NAME_SHOW$8);
854
+ const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5);
855
+ this._queueCallback(() => this._destroyElement(), this._element, isAnimated);
856
+ }
857
+
858
+ // Private
859
+ _destroyElement() {
860
+ this._element.remove();
861
+ EventHandler.trigger(this._element, EVENT_CLOSED);
862
+ this.dispose();
863
+ }
864
+
865
+ // Static
866
+ static jQueryInterface(config) {
867
+ return this.each(function () {
868
+ const data = Alert.getOrCreateInstance(this);
869
+ if (typeof config !== 'string') {
870
+ return;
871
+ }
872
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
873
+ throw new TypeError(`No method named "${config}"`);
874
+ }
875
+ data[config](this);
876
+ });
877
+ }
878
+ }
879
+
880
+ /**
881
+ * Data API implementation
882
+ */
883
+
884
+ enableDismissTrigger(Alert, 'close');
885
+
886
+ /**
887
+ * jQuery
888
+ */
889
+
890
+ defineJQueryPlugin(Alert);
891
+
892
+ /**
893
+ * --------------------------------------------------------------------------
894
+ * Bootstrap button.js
895
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
896
+ * --------------------------------------------------------------------------
897
+ */
898
+
899
+
900
+ /**
901
+ * Constants
902
+ */
903
+
904
+ const NAME$e = 'button';
905
+ const DATA_KEY$9 = 'bs.button';
906
+ const EVENT_KEY$a = `.${DATA_KEY$9}`;
907
+ const DATA_API_KEY$6 = '.data-api';
908
+ const CLASS_NAME_ACTIVE$3 = 'active';
909
+ const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]';
910
+ const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`;
911
+
912
+ /**
913
+ * Class definition
914
+ */
915
+
916
+ class Button extends BaseComponent {
917
+ // Getters
918
+ static get NAME() {
919
+ return NAME$e;
920
+ }
921
+
922
+ // Public
923
+ toggle() {
924
+ // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method
925
+ this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3));
926
+ }
927
+
928
+ // Static
929
+ static jQueryInterface(config) {
930
+ return this.each(function () {
931
+ const data = Button.getOrCreateInstance(this);
932
+ if (config === 'toggle') {
933
+ data[config]();
934
+ }
935
+ });
936
+ }
937
+ }
938
+
939
+ /**
940
+ * Data API implementation
941
+ */
942
+
943
+ EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => {
944
+ event.preventDefault();
945
+ const button = event.target.closest(SELECTOR_DATA_TOGGLE$5);
946
+ const data = Button.getOrCreateInstance(button);
947
+ data.toggle();
948
+ });
949
+
950
+ /**
951
+ * jQuery
952
+ */
953
+
954
+ defineJQueryPlugin(Button);
955
+
956
+ /**
957
+ * --------------------------------------------------------------------------
958
+ * Bootstrap util/swipe.js
959
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
960
+ * --------------------------------------------------------------------------
961
+ */
962
+
963
+
964
+ /**
965
+ * Constants
966
+ */
967
+
968
+ const NAME$d = 'swipe';
969
+ const EVENT_KEY$9 = '.bs.swipe';
970
+ const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`;
971
+ const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`;
972
+ const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`;
973
+ const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`;
974
+ const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`;
975
+ const POINTER_TYPE_TOUCH = 'touch';
976
+ const POINTER_TYPE_PEN = 'pen';
977
+ const CLASS_NAME_POINTER_EVENT = 'pointer-event';
978
+ const SWIPE_THRESHOLD = 40;
979
+ const Default$c = {
980
+ endCallback: null,
981
+ leftCallback: null,
982
+ rightCallback: null
983
+ };
984
+ const DefaultType$c = {
985
+ endCallback: '(function|null)',
986
+ leftCallback: '(function|null)',
987
+ rightCallback: '(function|null)'
988
+ };
989
+
990
+ /**
991
+ * Class definition
992
+ */
993
+
994
+ class Swipe extends Config {
995
+ constructor(element, config) {
996
+ super();
997
+ this._element = element;
998
+ if (!element || !Swipe.isSupported()) {
999
+ return;
1000
+ }
1001
+ this._config = this._getConfig(config);
1002
+ this._deltaX = 0;
1003
+ this._supportPointerEvents = Boolean(window.PointerEvent);
1004
+ this._initEvents();
1005
+ }
1006
+
1007
+ // Getters
1008
+ static get Default() {
1009
+ return Default$c;
1010
+ }
1011
+ static get DefaultType() {
1012
+ return DefaultType$c;
1013
+ }
1014
+ static get NAME() {
1015
+ return NAME$d;
1016
+ }
1017
+
1018
+ // Public
1019
+ dispose() {
1020
+ EventHandler.off(this._element, EVENT_KEY$9);
1021
+ }
1022
+
1023
+ // Private
1024
+ _start(event) {
1025
+ if (!this._supportPointerEvents) {
1026
+ this._deltaX = event.touches[0].clientX;
1027
+ return;
1028
+ }
1029
+ if (this._eventIsPointerPenTouch(event)) {
1030
+ this._deltaX = event.clientX;
1031
+ }
1032
+ }
1033
+ _end(event) {
1034
+ if (this._eventIsPointerPenTouch(event)) {
1035
+ this._deltaX = event.clientX - this._deltaX;
1036
+ }
1037
+ this._handleSwipe();
1038
+ execute(this._config.endCallback);
1039
+ }
1040
+ _move(event) {
1041
+ this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX;
1042
+ }
1043
+ _handleSwipe() {
1044
+ const absDeltaX = Math.abs(this._deltaX);
1045
+ if (absDeltaX <= SWIPE_THRESHOLD) {
1046
+ return;
1047
+ }
1048
+ const direction = absDeltaX / this._deltaX;
1049
+ this._deltaX = 0;
1050
+ if (!direction) {
1051
+ return;
1052
+ }
1053
+ execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback);
1054
+ }
1055
+ _initEvents() {
1056
+ if (this._supportPointerEvents) {
1057
+ EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event));
1058
+ EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event));
1059
+ this._element.classList.add(CLASS_NAME_POINTER_EVENT);
1060
+ } else {
1061
+ EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event));
1062
+ EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event));
1063
+ EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event));
1064
+ }
1065
+ }
1066
+ _eventIsPointerPenTouch(event) {
1067
+ return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH);
1068
+ }
1069
+
1070
+ // Static
1071
+ static isSupported() {
1072
+ return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0;
1073
+ }
1074
+ }
1075
+
1076
+ /**
1077
+ * --------------------------------------------------------------------------
1078
+ * Bootstrap carousel.js
1079
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1080
+ * --------------------------------------------------------------------------
1081
+ */
1082
+
1083
+
1084
+ /**
1085
+ * Constants
1086
+ */
1087
+
1088
+ const NAME$c = 'carousel';
1089
+ const DATA_KEY$8 = 'bs.carousel';
1090
+ const EVENT_KEY$8 = `.${DATA_KEY$8}`;
1091
+ const DATA_API_KEY$5 = '.data-api';
1092
+ const ARROW_LEFT_KEY$1 = 'ArrowLeft';
1093
+ const ARROW_RIGHT_KEY$1 = 'ArrowRight';
1094
+ const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch
1095
+
1096
+ const ORDER_NEXT = 'next';
1097
+ const ORDER_PREV = 'prev';
1098
+ const DIRECTION_LEFT = 'left';
1099
+ const DIRECTION_RIGHT = 'right';
1100
+ const EVENT_SLIDE = `slide${EVENT_KEY$8}`;
1101
+ const EVENT_SLID = `slid${EVENT_KEY$8}`;
1102
+ const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`;
1103
+ const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`;
1104
+ const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`;
1105
+ const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`;
1106
+ const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`;
1107
+ const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`;
1108
+ const CLASS_NAME_CAROUSEL = 'carousel';
1109
+ const CLASS_NAME_ACTIVE$2 = 'active';
1110
+ const CLASS_NAME_SLIDE = 'slide';
1111
+ const CLASS_NAME_END = 'carousel-item-end';
1112
+ const CLASS_NAME_START = 'carousel-item-start';
1113
+ const CLASS_NAME_NEXT = 'carousel-item-next';
1114
+ const CLASS_NAME_PREV = 'carousel-item-prev';
1115
+ const SELECTOR_ACTIVE = '.active';
1116
+ const SELECTOR_ITEM = '.carousel-item';
1117
+ const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM;
1118
+ const SELECTOR_ITEM_IMG = '.carousel-item img';
1119
+ const SELECTOR_INDICATORS = '.carousel-indicators';
1120
+ const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]';
1121
+ const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]';
1122
+ const KEY_TO_DIRECTION = {
1123
+ [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT,
1124
+ [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT
1125
+ };
1126
+ const Default$b = {
1127
+ interval: 5000,
1128
+ keyboard: true,
1129
+ pause: 'hover',
1130
+ ride: false,
1131
+ touch: true,
1132
+ wrap: true
1133
+ };
1134
+ const DefaultType$b = {
1135
+ interval: '(number|boolean)',
1136
+ // TODO:v6 remove boolean support
1137
+ keyboard: 'boolean',
1138
+ pause: '(string|boolean)',
1139
+ ride: '(boolean|string)',
1140
+ touch: 'boolean',
1141
+ wrap: 'boolean'
1142
+ };
1143
+
1144
+ /**
1145
+ * Class definition
1146
+ */
1147
+
1148
+ class Carousel extends BaseComponent {
1149
+ constructor(element, config) {
1150
+ super(element, config);
1151
+ this._interval = null;
1152
+ this._activeElement = null;
1153
+ this._isSliding = false;
1154
+ this.touchTimeout = null;
1155
+ this._swipeHelper = null;
1156
+ this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element);
1157
+ this._addEventListeners();
1158
+ if (this._config.ride === CLASS_NAME_CAROUSEL) {
1159
+ this.cycle();
1160
+ }
1161
+ }
1162
+
1163
+ // Getters
1164
+ static get Default() {
1165
+ return Default$b;
1166
+ }
1167
+ static get DefaultType() {
1168
+ return DefaultType$b;
1169
+ }
1170
+ static get NAME() {
1171
+ return NAME$c;
1172
+ }
1173
+
1174
+ // Public
1175
+ next() {
1176
+ this._slide(ORDER_NEXT);
1177
+ }
1178
+ nextWhenVisible() {
1179
+ // FIXME TODO use `document.visibilityState`
1180
+ // Don't call next when the page isn't visible
1181
+ // or the carousel or its parent isn't visible
1182
+ if (!document.hidden && isVisible(this._element)) {
1183
+ this.next();
1184
+ }
1185
+ }
1186
+ prev() {
1187
+ this._slide(ORDER_PREV);
1188
+ }
1189
+ pause() {
1190
+ if (this._isSliding) {
1191
+ triggerTransitionEnd(this._element);
1192
+ }
1193
+ this._clearInterval();
1194
+ }
1195
+ cycle() {
1196
+ this._clearInterval();
1197
+ this._updateInterval();
1198
+ this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval);
1199
+ }
1200
+ _maybeEnableCycle() {
1201
+ if (!this._config.ride) {
1202
+ return;
1203
+ }
1204
+ if (this._isSliding) {
1205
+ EventHandler.one(this._element, EVENT_SLID, () => this.cycle());
1206
+ return;
1207
+ }
1208
+ this.cycle();
1209
+ }
1210
+ to(index) {
1211
+ const items = this._getItems();
1212
+ if (index > items.length - 1 || index < 0) {
1213
+ return;
1214
+ }
1215
+ if (this._isSliding) {
1216
+ EventHandler.one(this._element, EVENT_SLID, () => this.to(index));
1217
+ return;
1218
+ }
1219
+ const activeIndex = this._getItemIndex(this._getActive());
1220
+ if (activeIndex === index) {
1221
+ return;
1222
+ }
1223
+ const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV;
1224
+ this._slide(order, items[index]);
1225
+ }
1226
+ dispose() {
1227
+ if (this._swipeHelper) {
1228
+ this._swipeHelper.dispose();
1229
+ }
1230
+ super.dispose();
1231
+ }
1232
+
1233
+ // Private
1234
+ _configAfterMerge(config) {
1235
+ config.defaultInterval = config.interval;
1236
+ return config;
1237
+ }
1238
+ _addEventListeners() {
1239
+ if (this._config.keyboard) {
1240
+ EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event));
1241
+ }
1242
+ if (this._config.pause === 'hover') {
1243
+ EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause());
1244
+ EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle());
1245
+ }
1246
+ if (this._config.touch && Swipe.isSupported()) {
1247
+ this._addTouchEventListeners();
1248
+ }
1249
+ }
1250
+ _addTouchEventListeners() {
1251
+ for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) {
1252
+ EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault());
1253
+ }
1254
+ const endCallBack = () => {
1255
+ if (this._config.pause !== 'hover') {
1256
+ return;
1257
+ }
1258
+
1259
+ // If it's a touch-enabled device, mouseenter/leave are fired as
1260
+ // part of the mouse compatibility events on first tap - the carousel
1261
+ // would stop cycling until user tapped out of it;
1262
+ // here, we listen for touchend, explicitly pause the carousel
1263
+ // (as if it's the second time we tap on it, mouseenter compat event
1264
+ // is NOT fired) and after a timeout (to allow for mouse compatibility
1265
+ // events to fire) we explicitly restart cycling
1266
+
1267
+ this.pause();
1268
+ if (this.touchTimeout) {
1269
+ clearTimeout(this.touchTimeout);
1270
+ }
1271
+ this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval);
1272
+ };
1273
+ const swipeConfig = {
1274
+ leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)),
1275
+ rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)),
1276
+ endCallback: endCallBack
1277
+ };
1278
+ this._swipeHelper = new Swipe(this._element, swipeConfig);
1279
+ }
1280
+ _keydown(event) {
1281
+ if (/input|textarea/i.test(event.target.tagName)) {
1282
+ return;
1283
+ }
1284
+ const direction = KEY_TO_DIRECTION[event.key];
1285
+ if (direction) {
1286
+ event.preventDefault();
1287
+ this._slide(this._directionToOrder(direction));
1288
+ }
1289
+ }
1290
+ _getItemIndex(element) {
1291
+ return this._getItems().indexOf(element);
1292
+ }
1293
+ _setActiveIndicatorElement(index) {
1294
+ if (!this._indicatorsElement) {
1295
+ return;
1296
+ }
1297
+ const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement);
1298
+ activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2);
1299
+ activeIndicator.removeAttribute('aria-current');
1300
+ const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement);
1301
+ if (newActiveIndicator) {
1302
+ newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2);
1303
+ newActiveIndicator.setAttribute('aria-current', 'true');
1304
+ }
1305
+ }
1306
+ _updateInterval() {
1307
+ const element = this._activeElement || this._getActive();
1308
+ if (!element) {
1309
+ return;
1310
+ }
1311
+ const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10);
1312
+ this._config.interval = elementInterval || this._config.defaultInterval;
1313
+ }
1314
+ _slide(order, element = null) {
1315
+ if (this._isSliding) {
1316
+ return;
1317
+ }
1318
+ const activeElement = this._getActive();
1319
+ const isNext = order === ORDER_NEXT;
1320
+ const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap);
1321
+ if (nextElement === activeElement) {
1322
+ return;
1323
+ }
1324
+ const nextElementIndex = this._getItemIndex(nextElement);
1325
+ const triggerEvent = eventName => {
1326
+ return EventHandler.trigger(this._element, eventName, {
1327
+ relatedTarget: nextElement,
1328
+ direction: this._orderToDirection(order),
1329
+ from: this._getItemIndex(activeElement),
1330
+ to: nextElementIndex
1331
+ });
1332
+ };
1333
+ const slideEvent = triggerEvent(EVENT_SLIDE);
1334
+ if (slideEvent.defaultPrevented) {
1335
+ return;
1336
+ }
1337
+ if (!activeElement || !nextElement) {
1338
+ // Some weirdness is happening, so we bail
1339
+ // TODO: change tests that use empty divs to avoid this check
1340
+ return;
1341
+ }
1342
+ const isCycling = Boolean(this._interval);
1343
+ this.pause();
1344
+ this._isSliding = true;
1345
+ this._setActiveIndicatorElement(nextElementIndex);
1346
+ this._activeElement = nextElement;
1347
+ const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END;
1348
+ const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV;
1349
+ nextElement.classList.add(orderClassName);
1350
+ reflow(nextElement);
1351
+ activeElement.classList.add(directionalClassName);
1352
+ nextElement.classList.add(directionalClassName);
1353
+ const completeCallBack = () => {
1354
+ nextElement.classList.remove(directionalClassName, orderClassName);
1355
+ nextElement.classList.add(CLASS_NAME_ACTIVE$2);
1356
+ activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName);
1357
+ this._isSliding = false;
1358
+ triggerEvent(EVENT_SLID);
1359
+ };
1360
+ this._queueCallback(completeCallBack, activeElement, this._isAnimated());
1361
+ if (isCycling) {
1362
+ this.cycle();
1363
+ }
1364
+ }
1365
+ _isAnimated() {
1366
+ return this._element.classList.contains(CLASS_NAME_SLIDE);
1367
+ }
1368
+ _getActive() {
1369
+ return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element);
1370
+ }
1371
+ _getItems() {
1372
+ return SelectorEngine.find(SELECTOR_ITEM, this._element);
1373
+ }
1374
+ _clearInterval() {
1375
+ if (this._interval) {
1376
+ clearInterval(this._interval);
1377
+ this._interval = null;
1378
+ }
1379
+ }
1380
+ _directionToOrder(direction) {
1381
+ if (isRTL()) {
1382
+ return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT;
1383
+ }
1384
+ return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV;
1385
+ }
1386
+ _orderToDirection(order) {
1387
+ if (isRTL()) {
1388
+ return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT;
1389
+ }
1390
+ return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT;
1391
+ }
1392
+
1393
+ // Static
1394
+ static jQueryInterface(config) {
1395
+ return this.each(function () {
1396
+ const data = Carousel.getOrCreateInstance(this, config);
1397
+ if (typeof config === 'number') {
1398
+ data.to(config);
1399
+ return;
1400
+ }
1401
+ if (typeof config === 'string') {
1402
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
1403
+ throw new TypeError(`No method named "${config}"`);
1404
+ }
1405
+ data[config]();
1406
+ }
1407
+ });
1408
+ }
1409
+ }
1410
+
1411
+ /**
1412
+ * Data API implementation
1413
+ */
1414
+
1415
+ EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) {
1416
+ const target = SelectorEngine.getElementFromSelector(this);
1417
+ if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) {
1418
+ return;
1419
+ }
1420
+ event.preventDefault();
1421
+ const carousel = Carousel.getOrCreateInstance(target);
1422
+ const slideIndex = this.getAttribute('data-bs-slide-to');
1423
+ if (slideIndex) {
1424
+ carousel.to(slideIndex);
1425
+ carousel._maybeEnableCycle();
1426
+ return;
1427
+ }
1428
+ if (Manipulator.getDataAttribute(this, 'slide') === 'next') {
1429
+ carousel.next();
1430
+ carousel._maybeEnableCycle();
1431
+ return;
1432
+ }
1433
+ carousel.prev();
1434
+ carousel._maybeEnableCycle();
1435
+ });
1436
+ EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => {
1437
+ const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE);
1438
+ for (const carousel of carousels) {
1439
+ Carousel.getOrCreateInstance(carousel);
1440
+ }
1441
+ });
1442
+
1443
+ /**
1444
+ * jQuery
1445
+ */
1446
+
1447
+ defineJQueryPlugin(Carousel);
1448
+
1449
+ /**
1450
+ * --------------------------------------------------------------------------
1451
+ * Bootstrap collapse.js
1452
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1453
+ * --------------------------------------------------------------------------
1454
+ */
1455
+
1456
+
1457
+ /**
1458
+ * Constants
1459
+ */
1460
+
1461
+ const NAME$b = 'collapse';
1462
+ const DATA_KEY$7 = 'bs.collapse';
1463
+ const EVENT_KEY$7 = `.${DATA_KEY$7}`;
1464
+ const DATA_API_KEY$4 = '.data-api';
1465
+ const EVENT_SHOW$6 = `show${EVENT_KEY$7}`;
1466
+ const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`;
1467
+ const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`;
1468
+ const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`;
1469
+ const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`;
1470
+ const CLASS_NAME_SHOW$7 = 'show';
1471
+ const CLASS_NAME_COLLAPSE = 'collapse';
1472
+ const CLASS_NAME_COLLAPSING = 'collapsing';
1473
+ const CLASS_NAME_COLLAPSED = 'collapsed';
1474
+ const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`;
1475
+ const CLASS_NAME_HORIZONTAL = 'collapse-horizontal';
1476
+ const WIDTH = 'width';
1477
+ const HEIGHT = 'height';
1478
+ const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing';
1479
+ const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]';
1480
+ const Default$a = {
1481
+ parent: null,
1482
+ toggle: true
1483
+ };
1484
+ const DefaultType$a = {
1485
+ parent: '(null|element)',
1486
+ toggle: 'boolean'
1487
+ };
1488
+
1489
+ /**
1490
+ * Class definition
1491
+ */
1492
+
1493
+ class Collapse extends BaseComponent {
1494
+ constructor(element, config) {
1495
+ super(element, config);
1496
+ this._isTransitioning = false;
1497
+ this._triggerArray = [];
1498
+ const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4);
1499
+ for (const elem of toggleList) {
1500
+ const selector = SelectorEngine.getSelectorFromElement(elem);
1501
+ const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element);
1502
+ if (selector !== null && filterElement.length) {
1503
+ this._triggerArray.push(elem);
1504
+ }
1505
+ }
1506
+ this._initializeChildren();
1507
+ if (!this._config.parent) {
1508
+ this._addAriaAndCollapsedClass(this._triggerArray, this._isShown());
1509
+ }
1510
+ if (this._config.toggle) {
1511
+ this.toggle();
1512
+ }
1513
+ }
1514
+
1515
+ // Getters
1516
+ static get Default() {
1517
+ return Default$a;
1518
+ }
1519
+ static get DefaultType() {
1520
+ return DefaultType$a;
1521
+ }
1522
+ static get NAME() {
1523
+ return NAME$b;
1524
+ }
1525
+
1526
+ // Public
1527
+ toggle() {
1528
+ if (this._isShown()) {
1529
+ this.hide();
1530
+ } else {
1531
+ this.show();
1532
+ }
1533
+ }
1534
+ show() {
1535
+ if (this._isTransitioning || this._isShown()) {
1536
+ return;
1537
+ }
1538
+ let activeChildren = [];
1539
+
1540
+ // find active children
1541
+ if (this._config.parent) {
1542
+ activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, {
1543
+ toggle: false
1544
+ }));
1545
+ }
1546
+ if (activeChildren.length && activeChildren[0]._isTransitioning) {
1547
+ return;
1548
+ }
1549
+ const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6);
1550
+ if (startEvent.defaultPrevented) {
1551
+ return;
1552
+ }
1553
+ for (const activeInstance of activeChildren) {
1554
+ activeInstance.hide();
1555
+ }
1556
+ const dimension = this._getDimension();
1557
+ this._element.classList.remove(CLASS_NAME_COLLAPSE);
1558
+ this._element.classList.add(CLASS_NAME_COLLAPSING);
1559
+ this._element.style[dimension] = 0;
1560
+ this._addAriaAndCollapsedClass(this._triggerArray, true);
1561
+ this._isTransitioning = true;
1562
+ const complete = () => {
1563
+ this._isTransitioning = false;
1564
+ this._element.classList.remove(CLASS_NAME_COLLAPSING);
1565
+ this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1566
+ this._element.style[dimension] = '';
1567
+ EventHandler.trigger(this._element, EVENT_SHOWN$6);
1568
+ };
1569
+ const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1);
1570
+ const scrollSize = `scroll${capitalizedDimension}`;
1571
+ this._queueCallback(complete, this._element, true);
1572
+ this._element.style[dimension] = `${this._element[scrollSize]}px`;
1573
+ }
1574
+ hide() {
1575
+ if (this._isTransitioning || !this._isShown()) {
1576
+ return;
1577
+ }
1578
+ const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6);
1579
+ if (startEvent.defaultPrevented) {
1580
+ return;
1581
+ }
1582
+ const dimension = this._getDimension();
1583
+ this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`;
1584
+ reflow(this._element);
1585
+ this._element.classList.add(CLASS_NAME_COLLAPSING);
1586
+ this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7);
1587
+ for (const trigger of this._triggerArray) {
1588
+ const element = SelectorEngine.getElementFromSelector(trigger);
1589
+ if (element && !this._isShown(element)) {
1590
+ this._addAriaAndCollapsedClass([trigger], false);
1591
+ }
1592
+ }
1593
+ this._isTransitioning = true;
1594
+ const complete = () => {
1595
+ this._isTransitioning = false;
1596
+ this._element.classList.remove(CLASS_NAME_COLLAPSING);
1597
+ this._element.classList.add(CLASS_NAME_COLLAPSE);
1598
+ EventHandler.trigger(this._element, EVENT_HIDDEN$6);
1599
+ };
1600
+ this._element.style[dimension] = '';
1601
+ this._queueCallback(complete, this._element, true);
1602
+ }
1603
+ _isShown(element = this._element) {
1604
+ return element.classList.contains(CLASS_NAME_SHOW$7);
1605
+ }
1606
+
1607
+ // Private
1608
+ _configAfterMerge(config) {
1609
+ config.toggle = Boolean(config.toggle); // Coerce string values
1610
+ config.parent = getElement(config.parent);
1611
+ return config;
1612
+ }
1613
+ _getDimension() {
1614
+ return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT;
1615
+ }
1616
+ _initializeChildren() {
1617
+ if (!this._config.parent) {
1618
+ return;
1619
+ }
1620
+ const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4);
1621
+ for (const element of children) {
1622
+ const selected = SelectorEngine.getElementFromSelector(element);
1623
+ if (selected) {
1624
+ this._addAriaAndCollapsedClass([element], this._isShown(selected));
1625
+ }
1626
+ }
1627
+ }
1628
+ _getFirstLevelChildren(selector) {
1629
+ const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent);
1630
+ // remove children if greater depth
1631
+ return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element));
1632
+ }
1633
+ _addAriaAndCollapsedClass(triggerArray, isOpen) {
1634
+ if (!triggerArray.length) {
1635
+ return;
1636
+ }
1637
+ for (const element of triggerArray) {
1638
+ element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen);
1639
+ element.setAttribute('aria-expanded', isOpen);
1640
+ }
1641
+ }
1642
+
1643
+ // Static
1644
+ static jQueryInterface(config) {
1645
+ const _config = {};
1646
+ if (typeof config === 'string' && /show|hide/.test(config)) {
1647
+ _config.toggle = false;
1648
+ }
1649
+ return this.each(function () {
1650
+ const data = Collapse.getOrCreateInstance(this, _config);
1651
+ if (typeof config === 'string') {
1652
+ if (typeof data[config] === 'undefined') {
1653
+ throw new TypeError(`No method named "${config}"`);
1654
+ }
1655
+ data[config]();
1656
+ }
1657
+ });
1658
+ }
1659
+ }
1660
+
1661
+ /**
1662
+ * Data API implementation
1663
+ */
1664
+
1665
+ EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) {
1666
+ // preventDefault only for <a> elements (which change the URL) not inside the collapsible element
1667
+ if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') {
1668
+ event.preventDefault();
1669
+ }
1670
+ for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) {
1671
+ Collapse.getOrCreateInstance(element, {
1672
+ toggle: false
1673
+ }).toggle();
1674
+ }
1675
+ });
1676
+
1677
+ /**
1678
+ * jQuery
1679
+ */
1680
+
1681
+ defineJQueryPlugin(Collapse);
1682
+
1683
+ /**
1684
+ * --------------------------------------------------------------------------
1685
+ * Bootstrap dropdown.js
1686
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
1687
+ * --------------------------------------------------------------------------
1688
+ */
1689
+
1690
+
1691
+ /**
1692
+ * Constants
1693
+ */
1694
+
1695
+ const NAME$a = 'dropdown';
1696
+ const DATA_KEY$6 = 'bs.dropdown';
1697
+ const EVENT_KEY$6 = `.${DATA_KEY$6}`;
1698
+ const DATA_API_KEY$3 = '.data-api';
1699
+ const ESCAPE_KEY$2 = 'Escape';
1700
+ const TAB_KEY$1 = 'Tab';
1701
+ const ARROW_UP_KEY$1 = 'ArrowUp';
1702
+ const ARROW_DOWN_KEY$1 = 'ArrowDown';
1703
+ const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button
1704
+
1705
+ const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`;
1706
+ const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`;
1707
+ const EVENT_SHOW$5 = `show${EVENT_KEY$6}`;
1708
+ const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`;
1709
+ const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`;
1710
+ const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`;
1711
+ const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`;
1712
+ const CLASS_NAME_SHOW$6 = 'show';
1713
+ const CLASS_NAME_DROPUP = 'dropup';
1714
+ const CLASS_NAME_DROPEND = 'dropend';
1715
+ const CLASS_NAME_DROPSTART = 'dropstart';
1716
+ const CLASS_NAME_DROPUP_CENTER = 'dropup-center';
1717
+ const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center';
1718
+ const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)';
1719
+ const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`;
1720
+ const SELECTOR_MENU = '.dropdown-menu';
1721
+ const SELECTOR_NAVBAR = '.navbar';
1722
+ const SELECTOR_NAVBAR_NAV = '.navbar-nav';
1723
+ const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)';
1724
+ const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start';
1725
+ const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end';
1726
+ const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start';
1727
+ const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end';
1728
+ const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start';
1729
+ const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start';
1730
+ const PLACEMENT_TOPCENTER = 'top';
1731
+ const PLACEMENT_BOTTOMCENTER = 'bottom';
1732
+ const Default$9 = {
1733
+ autoClose: true,
1734
+ boundary: 'clippingParents',
1735
+ display: 'dynamic',
1736
+ offset: [0, 2],
1737
+ popperConfig: null,
1738
+ reference: 'toggle'
1739
+ };
1740
+ const DefaultType$9 = {
1741
+ autoClose: '(boolean|string)',
1742
+ boundary: '(string|element)',
1743
+ display: 'string',
1744
+ offset: '(array|string|function)',
1745
+ popperConfig: '(null|object|function)',
1746
+ reference: '(string|element|object)'
1747
+ };
1748
+
1749
+ /**
1750
+ * Class definition
1751
+ */
1752
+
1753
+ class Dropdown extends BaseComponent {
1754
+ constructor(element, config) {
1755
+ super(element, config);
1756
+ this._popper = null;
1757
+ this._parent = this._element.parentNode; // dropdown wrapper
1758
+ // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
1759
+ this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent);
1760
+ this._inNavbar = this._detectNavbar();
1761
+ }
1762
+
1763
+ // Getters
1764
+ static get Default() {
1765
+ return Default$9;
1766
+ }
1767
+ static get DefaultType() {
1768
+ return DefaultType$9;
1769
+ }
1770
+ static get NAME() {
1771
+ return NAME$a;
1772
+ }
1773
+
1774
+ // Public
1775
+ toggle() {
1776
+ return this._isShown() ? this.hide() : this.show();
1777
+ }
1778
+ show() {
1779
+ if (isDisabled(this._element) || this._isShown()) {
1780
+ return;
1781
+ }
1782
+ const relatedTarget = {
1783
+ relatedTarget: this._element
1784
+ };
1785
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget);
1786
+ if (showEvent.defaultPrevented) {
1787
+ return;
1788
+ }
1789
+ this._createPopper();
1790
+
1791
+ // If this is a touch-enabled device we add extra
1792
+ // empty mouseover listeners to the body's immediate children;
1793
+ // only needed because of broken event delegation on iOS
1794
+ // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
1795
+ if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) {
1796
+ for (const element of [].concat(...document.body.children)) {
1797
+ EventHandler.on(element, 'mouseover', noop);
1798
+ }
1799
+ }
1800
+ this._element.focus();
1801
+ this._element.setAttribute('aria-expanded', true);
1802
+ this._menu.classList.add(CLASS_NAME_SHOW$6);
1803
+ this._element.classList.add(CLASS_NAME_SHOW$6);
1804
+ EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget);
1805
+ }
1806
+ hide() {
1807
+ if (isDisabled(this._element) || !this._isShown()) {
1808
+ return;
1809
+ }
1810
+ const relatedTarget = {
1811
+ relatedTarget: this._element
1812
+ };
1813
+ this._completeHide(relatedTarget);
1814
+ }
1815
+ dispose() {
1816
+ if (this._popper) {
1817
+ this._popper.destroy();
1818
+ }
1819
+ super.dispose();
1820
+ }
1821
+ update() {
1822
+ this._inNavbar = this._detectNavbar();
1823
+ if (this._popper) {
1824
+ this._popper.update();
1825
+ }
1826
+ }
1827
+
1828
+ // Private
1829
+ _completeHide(relatedTarget) {
1830
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget);
1831
+ if (hideEvent.defaultPrevented) {
1832
+ return;
1833
+ }
1834
+
1835
+ // If this is a touch-enabled device we remove the extra
1836
+ // empty mouseover listeners we added for iOS support
1837
+ if ('ontouchstart' in document.documentElement) {
1838
+ for (const element of [].concat(...document.body.children)) {
1839
+ EventHandler.off(element, 'mouseover', noop);
1840
+ }
1841
+ }
1842
+ if (this._popper) {
1843
+ this._popper.destroy();
1844
+ }
1845
+ this._menu.classList.remove(CLASS_NAME_SHOW$6);
1846
+ this._element.classList.remove(CLASS_NAME_SHOW$6);
1847
+ this._element.setAttribute('aria-expanded', 'false');
1848
+ Manipulator.removeDataAttribute(this._menu, 'popper');
1849
+ EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget);
1850
+ }
1851
+ _getConfig(config) {
1852
+ config = super._getConfig(config);
1853
+ if (typeof config.reference === 'object' && !isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') {
1854
+ // Popper virtual elements require a getBoundingClientRect method
1855
+ throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`);
1856
+ }
1857
+ return config;
1858
+ }
1859
+ _createPopper() {
1860
+ if (typeof Popper === 'undefined') {
1861
+ throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)');
1862
+ }
1863
+ let referenceElement = this._element;
1864
+ if (this._config.reference === 'parent') {
1865
+ referenceElement = this._parent;
1866
+ } else if (isElement(this._config.reference)) {
1867
+ referenceElement = getElement(this._config.reference);
1868
+ } else if (typeof this._config.reference === 'object') {
1869
+ referenceElement = this._config.reference;
1870
+ }
1871
+ const popperConfig = this._getPopperConfig();
1872
+ this._popper = Popper.createPopper(referenceElement, this._menu, popperConfig);
1873
+ }
1874
+ _isShown() {
1875
+ return this._menu.classList.contains(CLASS_NAME_SHOW$6);
1876
+ }
1877
+ _getPlacement() {
1878
+ const parentDropdown = this._parent;
1879
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) {
1880
+ return PLACEMENT_RIGHT;
1881
+ }
1882
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) {
1883
+ return PLACEMENT_LEFT;
1884
+ }
1885
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) {
1886
+ return PLACEMENT_TOPCENTER;
1887
+ }
1888
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) {
1889
+ return PLACEMENT_BOTTOMCENTER;
1890
+ }
1891
+
1892
+ // We need to trim the value because custom properties can also include spaces
1893
+ const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end';
1894
+ if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) {
1895
+ return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP;
1896
+ }
1897
+ return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM;
1898
+ }
1899
+ _detectNavbar() {
1900
+ return this._element.closest(SELECTOR_NAVBAR) !== null;
1901
+ }
1902
+ _getOffset() {
1903
+ const {
1904
+ offset
1905
+ } = this._config;
1906
+ if (typeof offset === 'string') {
1907
+ return offset.split(',').map(value => Number.parseInt(value, 10));
1908
+ }
1909
+ if (typeof offset === 'function') {
1910
+ return popperData => offset(popperData, this._element);
1911
+ }
1912
+ return offset;
1913
+ }
1914
+ _getPopperConfig() {
1915
+ const defaultBsPopperConfig = {
1916
+ placement: this._getPlacement(),
1917
+ modifiers: [{
1918
+ name: 'preventOverflow',
1919
+ options: {
1920
+ boundary: this._config.boundary
1921
+ }
1922
+ }, {
1923
+ name: 'offset',
1924
+ options: {
1925
+ offset: this._getOffset()
1926
+ }
1927
+ }]
1928
+ };
1929
+
1930
+ // Disable Popper if we have a static display or Dropdown is in Navbar
1931
+ if (this._inNavbar || this._config.display === 'static') {
1932
+ Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove
1933
+ defaultBsPopperConfig.modifiers = [{
1934
+ name: 'applyStyles',
1935
+ enabled: false
1936
+ }];
1937
+ }
1938
+ return {
1939
+ ...defaultBsPopperConfig,
1940
+ ...execute(this._config.popperConfig, [defaultBsPopperConfig])
1941
+ };
1942
+ }
1943
+ _selectMenuItem({
1944
+ key,
1945
+ target
1946
+ }) {
1947
+ const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element));
1948
+ if (!items.length) {
1949
+ return;
1950
+ }
1951
+
1952
+ // if target isn't included in items (e.g. when expanding the dropdown)
1953
+ // allow cycling to get the last item in case key equals ARROW_UP_KEY
1954
+ getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus();
1955
+ }
1956
+
1957
+ // Static
1958
+ static jQueryInterface(config) {
1959
+ return this.each(function () {
1960
+ const data = Dropdown.getOrCreateInstance(this, config);
1961
+ if (typeof config !== 'string') {
1962
+ return;
1963
+ }
1964
+ if (typeof data[config] === 'undefined') {
1965
+ throw new TypeError(`No method named "${config}"`);
1966
+ }
1967
+ data[config]();
1968
+ });
1969
+ }
1970
+ static clearMenus(event) {
1971
+ if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) {
1972
+ return;
1973
+ }
1974
+ const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN);
1975
+ for (const toggle of openToggles) {
1976
+ const context = Dropdown.getInstance(toggle);
1977
+ if (!context || context._config.autoClose === false) {
1978
+ continue;
1979
+ }
1980
+ const composedPath = event.composedPath();
1981
+ const isMenuTarget = composedPath.includes(context._menu);
1982
+ if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) {
1983
+ continue;
1984
+ }
1985
+
1986
+ // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu
1987
+ if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) {
1988
+ continue;
1989
+ }
1990
+ const relatedTarget = {
1991
+ relatedTarget: context._element
1992
+ };
1993
+ if (event.type === 'click') {
1994
+ relatedTarget.clickEvent = event;
1995
+ }
1996
+ context._completeHide(relatedTarget);
1997
+ }
1998
+ }
1999
+ static dataApiKeydownHandler(event) {
2000
+ // If not an UP | DOWN | ESCAPE key => not a dropdown command
2001
+ // If input/textarea && if key is other than ESCAPE => not a dropdown command
2002
+
2003
+ const isInput = /input|textarea/i.test(event.target.tagName);
2004
+ const isEscapeEvent = event.key === ESCAPE_KEY$2;
2005
+ const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key);
2006
+ if (!isUpOrDownEvent && !isEscapeEvent) {
2007
+ return;
2008
+ }
2009
+ if (isInput && !isEscapeEvent) {
2010
+ return;
2011
+ }
2012
+ event.preventDefault();
2013
+
2014
+ // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/
2015
+ const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode);
2016
+ const instance = Dropdown.getOrCreateInstance(getToggleButton);
2017
+ if (isUpOrDownEvent) {
2018
+ event.stopPropagation();
2019
+ instance.show();
2020
+ instance._selectMenuItem(event);
2021
+ return;
2022
+ }
2023
+ if (instance._isShown()) {
2024
+ // else is escape and we check if it is shown
2025
+ event.stopPropagation();
2026
+ instance.hide();
2027
+ getToggleButton.focus();
2028
+ }
2029
+ }
2030
+ }
2031
+
2032
+ /**
2033
+ * Data API implementation
2034
+ */
2035
+
2036
+ EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler);
2037
+ EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler);
2038
+ EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus);
2039
+ EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus);
2040
+ EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) {
2041
+ event.preventDefault();
2042
+ Dropdown.getOrCreateInstance(this).toggle();
2043
+ });
2044
+
2045
+ /**
2046
+ * jQuery
2047
+ */
2048
+
2049
+ defineJQueryPlugin(Dropdown);
2050
+
2051
+ /**
2052
+ * --------------------------------------------------------------------------
2053
+ * Bootstrap util/backdrop.js
2054
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2055
+ * --------------------------------------------------------------------------
2056
+ */
2057
+
2058
+
2059
+ /**
2060
+ * Constants
2061
+ */
2062
+
2063
+ const NAME$9 = 'backdrop';
2064
+ const CLASS_NAME_FADE$4 = 'fade';
2065
+ const CLASS_NAME_SHOW$5 = 'show';
2066
+ const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`;
2067
+ const Default$8 = {
2068
+ className: 'modal-backdrop',
2069
+ clickCallback: null,
2070
+ isAnimated: false,
2071
+ isVisible: true,
2072
+ // if false, we use the backdrop helper without adding any element to the dom
2073
+ rootElement: 'body' // give the choice to place backdrop under different elements
2074
+ };
2075
+ const DefaultType$8 = {
2076
+ className: 'string',
2077
+ clickCallback: '(function|null)',
2078
+ isAnimated: 'boolean',
2079
+ isVisible: 'boolean',
2080
+ rootElement: '(element|string)'
2081
+ };
2082
+
2083
+ /**
2084
+ * Class definition
2085
+ */
2086
+
2087
+ class Backdrop extends Config {
2088
+ constructor(config) {
2089
+ super();
2090
+ this._config = this._getConfig(config);
2091
+ this._isAppended = false;
2092
+ this._element = null;
2093
+ }
2094
+
2095
+ // Getters
2096
+ static get Default() {
2097
+ return Default$8;
2098
+ }
2099
+ static get DefaultType() {
2100
+ return DefaultType$8;
2101
+ }
2102
+ static get NAME() {
2103
+ return NAME$9;
2104
+ }
2105
+
2106
+ // Public
2107
+ show(callback) {
2108
+ if (!this._config.isVisible) {
2109
+ execute(callback);
2110
+ return;
2111
+ }
2112
+ this._append();
2113
+ const element = this._getElement();
2114
+ if (this._config.isAnimated) {
2115
+ reflow(element);
2116
+ }
2117
+ element.classList.add(CLASS_NAME_SHOW$5);
2118
+ this._emulateAnimation(() => {
2119
+ execute(callback);
2120
+ });
2121
+ }
2122
+ hide(callback) {
2123
+ if (!this._config.isVisible) {
2124
+ execute(callback);
2125
+ return;
2126
+ }
2127
+ this._getElement().classList.remove(CLASS_NAME_SHOW$5);
2128
+ this._emulateAnimation(() => {
2129
+ this.dispose();
2130
+ execute(callback);
2131
+ });
2132
+ }
2133
+ dispose() {
2134
+ if (!this._isAppended) {
2135
+ return;
2136
+ }
2137
+ EventHandler.off(this._element, EVENT_MOUSEDOWN);
2138
+ this._element.remove();
2139
+ this._isAppended = false;
2140
+ }
2141
+
2142
+ // Private
2143
+ _getElement() {
2144
+ if (!this._element) {
2145
+ const backdrop = document.createElement('div');
2146
+ backdrop.className = this._config.className;
2147
+ if (this._config.isAnimated) {
2148
+ backdrop.classList.add(CLASS_NAME_FADE$4);
2149
+ }
2150
+ this._element = backdrop;
2151
+ }
2152
+ return this._element;
2153
+ }
2154
+ _configAfterMerge(config) {
2155
+ // use getElement() with the default "body" to get a fresh Element on each instantiation
2156
+ config.rootElement = getElement(config.rootElement);
2157
+ return config;
2158
+ }
2159
+ _append() {
2160
+ if (this._isAppended) {
2161
+ return;
2162
+ }
2163
+ const element = this._getElement();
2164
+ this._config.rootElement.append(element);
2165
+ EventHandler.on(element, EVENT_MOUSEDOWN, () => {
2166
+ execute(this._config.clickCallback);
2167
+ });
2168
+ this._isAppended = true;
2169
+ }
2170
+ _emulateAnimation(callback) {
2171
+ executeAfterTransition(callback, this._getElement(), this._config.isAnimated);
2172
+ }
2173
+ }
2174
+
2175
+ /**
2176
+ * --------------------------------------------------------------------------
2177
+ * Bootstrap util/focustrap.js
2178
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2179
+ * --------------------------------------------------------------------------
2180
+ */
2181
+
2182
+
2183
+ /**
2184
+ * Constants
2185
+ */
2186
+
2187
+ const NAME$8 = 'focustrap';
2188
+ const DATA_KEY$5 = 'bs.focustrap';
2189
+ const EVENT_KEY$5 = `.${DATA_KEY$5}`;
2190
+ const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`;
2191
+ const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`;
2192
+ const TAB_KEY = 'Tab';
2193
+ const TAB_NAV_FORWARD = 'forward';
2194
+ const TAB_NAV_BACKWARD = 'backward';
2195
+ const Default$7 = {
2196
+ autofocus: true,
2197
+ trapElement: null // The element to trap focus inside of
2198
+ };
2199
+ const DefaultType$7 = {
2200
+ autofocus: 'boolean',
2201
+ trapElement: 'element'
2202
+ };
2203
+
2204
+ /**
2205
+ * Class definition
2206
+ */
2207
+
2208
+ class FocusTrap extends Config {
2209
+ constructor(config) {
2210
+ super();
2211
+ this._config = this._getConfig(config);
2212
+ this._isActive = false;
2213
+ this._lastTabNavDirection = null;
2214
+ }
2215
+
2216
+ // Getters
2217
+ static get Default() {
2218
+ return Default$7;
2219
+ }
2220
+ static get DefaultType() {
2221
+ return DefaultType$7;
2222
+ }
2223
+ static get NAME() {
2224
+ return NAME$8;
2225
+ }
2226
+
2227
+ // Public
2228
+ activate() {
2229
+ if (this._isActive) {
2230
+ return;
2231
+ }
2232
+ if (this._config.autofocus) {
2233
+ this._config.trapElement.focus();
2234
+ }
2235
+ EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop
2236
+ EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event));
2237
+ EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event));
2238
+ this._isActive = true;
2239
+ }
2240
+ deactivate() {
2241
+ if (!this._isActive) {
2242
+ return;
2243
+ }
2244
+ this._isActive = false;
2245
+ EventHandler.off(document, EVENT_KEY$5);
2246
+ }
2247
+
2248
+ // Private
2249
+ _handleFocusin(event) {
2250
+ const {
2251
+ trapElement
2252
+ } = this._config;
2253
+ if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) {
2254
+ return;
2255
+ }
2256
+ const elements = SelectorEngine.focusableChildren(trapElement);
2257
+ if (elements.length === 0) {
2258
+ trapElement.focus();
2259
+ } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) {
2260
+ elements[elements.length - 1].focus();
2261
+ } else {
2262
+ elements[0].focus();
2263
+ }
2264
+ }
2265
+ _handleKeydown(event) {
2266
+ if (event.key !== TAB_KEY) {
2267
+ return;
2268
+ }
2269
+ this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD;
2270
+ }
2271
+ }
2272
+
2273
+ /**
2274
+ * --------------------------------------------------------------------------
2275
+ * Bootstrap util/scrollBar.js
2276
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2277
+ * --------------------------------------------------------------------------
2278
+ */
2279
+
2280
+
2281
+ /**
2282
+ * Constants
2283
+ */
2284
+
2285
+ const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
2286
+ const SELECTOR_STICKY_CONTENT = '.sticky-top';
2287
+ const PROPERTY_PADDING = 'padding-right';
2288
+ const PROPERTY_MARGIN = 'margin-right';
2289
+
2290
+ /**
2291
+ * Class definition
2292
+ */
2293
+
2294
+ class ScrollBarHelper {
2295
+ constructor() {
2296
+ this._element = document.body;
2297
+ }
2298
+
2299
+ // Public
2300
+ getWidth() {
2301
+ // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
2302
+ const documentWidth = document.documentElement.clientWidth;
2303
+ return Math.abs(window.innerWidth - documentWidth);
2304
+ }
2305
+ hide() {
2306
+ const width = this.getWidth();
2307
+ this._disableOverFlow();
2308
+ // give padding to element to balance the hidden scrollbar width
2309
+ this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
2310
+ // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth
2311
+ this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width);
2312
+ this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width);
2313
+ }
2314
+ reset() {
2315
+ this._resetElementAttributes(this._element, 'overflow');
2316
+ this._resetElementAttributes(this._element, PROPERTY_PADDING);
2317
+ this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING);
2318
+ this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN);
2319
+ }
2320
+ isOverflowing() {
2321
+ return this.getWidth() > 0;
2322
+ }
2323
+
2324
+ // Private
2325
+ _disableOverFlow() {
2326
+ this._saveInitialAttribute(this._element, 'overflow');
2327
+ this._element.style.overflow = 'hidden';
2328
+ }
2329
+ _setElementAttributes(selector, styleProperty, callback) {
2330
+ const scrollbarWidth = this.getWidth();
2331
+ const manipulationCallBack = element => {
2332
+ if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) {
2333
+ return;
2334
+ }
2335
+ this._saveInitialAttribute(element, styleProperty);
2336
+ const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty);
2337
+ element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`);
2338
+ };
2339
+ this._applyManipulationCallback(selector, manipulationCallBack);
2340
+ }
2341
+ _saveInitialAttribute(element, styleProperty) {
2342
+ const actualValue = element.style.getPropertyValue(styleProperty);
2343
+ if (actualValue) {
2344
+ Manipulator.setDataAttribute(element, styleProperty, actualValue);
2345
+ }
2346
+ }
2347
+ _resetElementAttributes(selector, styleProperty) {
2348
+ const manipulationCallBack = element => {
2349
+ const value = Manipulator.getDataAttribute(element, styleProperty);
2350
+ // We only want to remove the property if the value is `null`; the value can also be zero
2351
+ if (value === null) {
2352
+ element.style.removeProperty(styleProperty);
2353
+ return;
2354
+ }
2355
+ Manipulator.removeDataAttribute(element, styleProperty);
2356
+ element.style.setProperty(styleProperty, value);
2357
+ };
2358
+ this._applyManipulationCallback(selector, manipulationCallBack);
2359
+ }
2360
+ _applyManipulationCallback(selector, callBack) {
2361
+ if (isElement(selector)) {
2362
+ callBack(selector);
2363
+ return;
2364
+ }
2365
+ for (const sel of SelectorEngine.find(selector, this._element)) {
2366
+ callBack(sel);
2367
+ }
2368
+ }
2369
+ }
2370
+
2371
+ /**
2372
+ * --------------------------------------------------------------------------
2373
+ * Bootstrap modal.js
2374
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2375
+ * --------------------------------------------------------------------------
2376
+ */
2377
+
2378
+
2379
+ /**
2380
+ * Constants
2381
+ */
2382
+
2383
+ const NAME$7 = 'modal';
2384
+ const DATA_KEY$4 = 'bs.modal';
2385
+ const EVENT_KEY$4 = `.${DATA_KEY$4}`;
2386
+ const DATA_API_KEY$2 = '.data-api';
2387
+ const ESCAPE_KEY$1 = 'Escape';
2388
+ const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`;
2389
+ const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`;
2390
+ const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`;
2391
+ const EVENT_SHOW$4 = `show${EVENT_KEY$4}`;
2392
+ const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`;
2393
+ const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`;
2394
+ const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`;
2395
+ const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`;
2396
+ const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`;
2397
+ const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`;
2398
+ const CLASS_NAME_OPEN = 'modal-open';
2399
+ const CLASS_NAME_FADE$3 = 'fade';
2400
+ const CLASS_NAME_SHOW$4 = 'show';
2401
+ const CLASS_NAME_STATIC = 'modal-static';
2402
+ const OPEN_SELECTOR$1 = '.modal.show';
2403
+ const SELECTOR_DIALOG = '.modal-dialog';
2404
+ const SELECTOR_MODAL_BODY = '.modal-body';
2405
+ const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]';
2406
+ const Default$6 = {
2407
+ backdrop: true,
2408
+ focus: true,
2409
+ keyboard: true
2410
+ };
2411
+ const DefaultType$6 = {
2412
+ backdrop: '(boolean|string)',
2413
+ focus: 'boolean',
2414
+ keyboard: 'boolean'
2415
+ };
2416
+
2417
+ /**
2418
+ * Class definition
2419
+ */
2420
+
2421
+ class Modal extends BaseComponent {
2422
+ constructor(element, config) {
2423
+ super(element, config);
2424
+ this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element);
2425
+ this._backdrop = this._initializeBackDrop();
2426
+ this._focustrap = this._initializeFocusTrap();
2427
+ this._isShown = false;
2428
+ this._isTransitioning = false;
2429
+ this._scrollBar = new ScrollBarHelper();
2430
+ this._addEventListeners();
2431
+ }
2432
+
2433
+ // Getters
2434
+ static get Default() {
2435
+ return Default$6;
2436
+ }
2437
+ static get DefaultType() {
2438
+ return DefaultType$6;
2439
+ }
2440
+ static get NAME() {
2441
+ return NAME$7;
2442
+ }
2443
+
2444
+ // Public
2445
+ toggle(relatedTarget) {
2446
+ return this._isShown ? this.hide() : this.show(relatedTarget);
2447
+ }
2448
+ show(relatedTarget) {
2449
+ if (this._isShown || this._isTransitioning) {
2450
+ return;
2451
+ }
2452
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, {
2453
+ relatedTarget
2454
+ });
2455
+ if (showEvent.defaultPrevented) {
2456
+ return;
2457
+ }
2458
+ this._isShown = true;
2459
+ this._isTransitioning = true;
2460
+ this._scrollBar.hide();
2461
+ document.body.classList.add(CLASS_NAME_OPEN);
2462
+ this._adjustDialog();
2463
+ this._backdrop.show(() => this._showElement(relatedTarget));
2464
+ }
2465
+ hide() {
2466
+ if (!this._isShown || this._isTransitioning) {
2467
+ return;
2468
+ }
2469
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4);
2470
+ if (hideEvent.defaultPrevented) {
2471
+ return;
2472
+ }
2473
+ this._isShown = false;
2474
+ this._isTransitioning = true;
2475
+ this._focustrap.deactivate();
2476
+ this._element.classList.remove(CLASS_NAME_SHOW$4);
2477
+ this._queueCallback(() => this._hideModal(), this._element, this._isAnimated());
2478
+ }
2479
+ dispose() {
2480
+ EventHandler.off(window, EVENT_KEY$4);
2481
+ EventHandler.off(this._dialog, EVENT_KEY$4);
2482
+ this._backdrop.dispose();
2483
+ this._focustrap.deactivate();
2484
+ super.dispose();
2485
+ }
2486
+ handleUpdate() {
2487
+ this._adjustDialog();
2488
+ }
2489
+
2490
+ // Private
2491
+ _initializeBackDrop() {
2492
+ return new Backdrop({
2493
+ isVisible: Boolean(this._config.backdrop),
2494
+ // 'static' option will be translated to true, and booleans will keep their value,
2495
+ isAnimated: this._isAnimated()
2496
+ });
2497
+ }
2498
+ _initializeFocusTrap() {
2499
+ return new FocusTrap({
2500
+ trapElement: this._element
2501
+ });
2502
+ }
2503
+ _showElement(relatedTarget) {
2504
+ // try to append dynamic modal
2505
+ if (!document.body.contains(this._element)) {
2506
+ document.body.append(this._element);
2507
+ }
2508
+ this._element.style.display = 'block';
2509
+ this._element.removeAttribute('aria-hidden');
2510
+ this._element.setAttribute('aria-modal', true);
2511
+ this._element.setAttribute('role', 'dialog');
2512
+ this._element.scrollTop = 0;
2513
+ const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog);
2514
+ if (modalBody) {
2515
+ modalBody.scrollTop = 0;
2516
+ }
2517
+ reflow(this._element);
2518
+ this._element.classList.add(CLASS_NAME_SHOW$4);
2519
+ const transitionComplete = () => {
2520
+ if (this._config.focus) {
2521
+ this._focustrap.activate();
2522
+ }
2523
+ this._isTransitioning = false;
2524
+ EventHandler.trigger(this._element, EVENT_SHOWN$4, {
2525
+ relatedTarget
2526
+ });
2527
+ };
2528
+ this._queueCallback(transitionComplete, this._dialog, this._isAnimated());
2529
+ }
2530
+ _addEventListeners() {
2531
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => {
2532
+ if (event.key !== ESCAPE_KEY$1) {
2533
+ return;
2534
+ }
2535
+ if (this._config.keyboard) {
2536
+ this.hide();
2537
+ return;
2538
+ }
2539
+ this._triggerBackdropTransition();
2540
+ });
2541
+ EventHandler.on(window, EVENT_RESIZE$1, () => {
2542
+ if (this._isShown && !this._isTransitioning) {
2543
+ this._adjustDialog();
2544
+ }
2545
+ });
2546
+ EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => {
2547
+ // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks
2548
+ EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => {
2549
+ if (this._element !== event.target || this._element !== event2.target) {
2550
+ return;
2551
+ }
2552
+ if (this._config.backdrop === 'static') {
2553
+ this._triggerBackdropTransition();
2554
+ return;
2555
+ }
2556
+ if (this._config.backdrop) {
2557
+ this.hide();
2558
+ }
2559
+ });
2560
+ });
2561
+ }
2562
+ _hideModal() {
2563
+ this._element.style.display = 'none';
2564
+ this._element.setAttribute('aria-hidden', true);
2565
+ this._element.removeAttribute('aria-modal');
2566
+ this._element.removeAttribute('role');
2567
+ this._isTransitioning = false;
2568
+ this._backdrop.hide(() => {
2569
+ document.body.classList.remove(CLASS_NAME_OPEN);
2570
+ this._resetAdjustments();
2571
+ this._scrollBar.reset();
2572
+ EventHandler.trigger(this._element, EVENT_HIDDEN$4);
2573
+ });
2574
+ }
2575
+ _isAnimated() {
2576
+ return this._element.classList.contains(CLASS_NAME_FADE$3);
2577
+ }
2578
+ _triggerBackdropTransition() {
2579
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1);
2580
+ if (hideEvent.defaultPrevented) {
2581
+ return;
2582
+ }
2583
+ const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2584
+ const initialOverflowY = this._element.style.overflowY;
2585
+ // return if the following background transition hasn't yet completed
2586
+ if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) {
2587
+ return;
2588
+ }
2589
+ if (!isModalOverflowing) {
2590
+ this._element.style.overflowY = 'hidden';
2591
+ }
2592
+ this._element.classList.add(CLASS_NAME_STATIC);
2593
+ this._queueCallback(() => {
2594
+ this._element.classList.remove(CLASS_NAME_STATIC);
2595
+ this._queueCallback(() => {
2596
+ this._element.style.overflowY = initialOverflowY;
2597
+ }, this._dialog);
2598
+ }, this._dialog);
2599
+ this._element.focus();
2600
+ }
2601
+
2602
+ /**
2603
+ * The following methods are used to handle overflowing modals
2604
+ */
2605
+
2606
+ _adjustDialog() {
2607
+ const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight;
2608
+ const scrollbarWidth = this._scrollBar.getWidth();
2609
+ const isBodyOverflowing = scrollbarWidth > 0;
2610
+ if (isBodyOverflowing && !isModalOverflowing) {
2611
+ const property = isRTL() ? 'paddingLeft' : 'paddingRight';
2612
+ this._element.style[property] = `${scrollbarWidth}px`;
2613
+ }
2614
+ if (!isBodyOverflowing && isModalOverflowing) {
2615
+ const property = isRTL() ? 'paddingRight' : 'paddingLeft';
2616
+ this._element.style[property] = `${scrollbarWidth}px`;
2617
+ }
2618
+ }
2619
+ _resetAdjustments() {
2620
+ this._element.style.paddingLeft = '';
2621
+ this._element.style.paddingRight = '';
2622
+ }
2623
+
2624
+ // Static
2625
+ static jQueryInterface(config, relatedTarget) {
2626
+ return this.each(function () {
2627
+ const data = Modal.getOrCreateInstance(this, config);
2628
+ if (typeof config !== 'string') {
2629
+ return;
2630
+ }
2631
+ if (typeof data[config] === 'undefined') {
2632
+ throw new TypeError(`No method named "${config}"`);
2633
+ }
2634
+ data[config](relatedTarget);
2635
+ });
2636
+ }
2637
+ }
2638
+
2639
+ /**
2640
+ * Data API implementation
2641
+ */
2642
+
2643
+ EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) {
2644
+ const target = SelectorEngine.getElementFromSelector(this);
2645
+ if (['A', 'AREA'].includes(this.tagName)) {
2646
+ event.preventDefault();
2647
+ }
2648
+ EventHandler.one(target, EVENT_SHOW$4, showEvent => {
2649
+ if (showEvent.defaultPrevented) {
2650
+ // only register focus restorer if modal will actually get shown
2651
+ return;
2652
+ }
2653
+ EventHandler.one(target, EVENT_HIDDEN$4, () => {
2654
+ if (isVisible(this)) {
2655
+ this.focus();
2656
+ }
2657
+ });
2658
+ });
2659
+
2660
+ // avoid conflict when clicking modal toggler while another one is open
2661
+ const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1);
2662
+ if (alreadyOpen) {
2663
+ Modal.getInstance(alreadyOpen).hide();
2664
+ }
2665
+ const data = Modal.getOrCreateInstance(target);
2666
+ data.toggle(this);
2667
+ });
2668
+ enableDismissTrigger(Modal);
2669
+
2670
+ /**
2671
+ * jQuery
2672
+ */
2673
+
2674
+ defineJQueryPlugin(Modal);
2675
+
2676
+ /**
2677
+ * --------------------------------------------------------------------------
2678
+ * Bootstrap offcanvas.js
2679
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2680
+ * --------------------------------------------------------------------------
2681
+ */
2682
+
2683
+
2684
+ /**
2685
+ * Constants
2686
+ */
2687
+
2688
+ const NAME$6 = 'offcanvas';
2689
+ const DATA_KEY$3 = 'bs.offcanvas';
2690
+ const EVENT_KEY$3 = `.${DATA_KEY$3}`;
2691
+ const DATA_API_KEY$1 = '.data-api';
2692
+ const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`;
2693
+ const ESCAPE_KEY = 'Escape';
2694
+ const CLASS_NAME_SHOW$3 = 'show';
2695
+ const CLASS_NAME_SHOWING$1 = 'showing';
2696
+ const CLASS_NAME_HIDING = 'hiding';
2697
+ const CLASS_NAME_BACKDROP = 'offcanvas-backdrop';
2698
+ const OPEN_SELECTOR = '.offcanvas.show';
2699
+ const EVENT_SHOW$3 = `show${EVENT_KEY$3}`;
2700
+ const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`;
2701
+ const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`;
2702
+ const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`;
2703
+ const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`;
2704
+ const EVENT_RESIZE = `resize${EVENT_KEY$3}`;
2705
+ const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`;
2706
+ const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`;
2707
+ const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]';
2708
+ const Default$5 = {
2709
+ backdrop: true,
2710
+ keyboard: true,
2711
+ scroll: false
2712
+ };
2713
+ const DefaultType$5 = {
2714
+ backdrop: '(boolean|string)',
2715
+ keyboard: 'boolean',
2716
+ scroll: 'boolean'
2717
+ };
2718
+
2719
+ /**
2720
+ * Class definition
2721
+ */
2722
+
2723
+ class Offcanvas extends BaseComponent {
2724
+ constructor(element, config) {
2725
+ super(element, config);
2726
+ this._isShown = false;
2727
+ this._backdrop = this._initializeBackDrop();
2728
+ this._focustrap = this._initializeFocusTrap();
2729
+ this._addEventListeners();
2730
+ }
2731
+
2732
+ // Getters
2733
+ static get Default() {
2734
+ return Default$5;
2735
+ }
2736
+ static get DefaultType() {
2737
+ return DefaultType$5;
2738
+ }
2739
+ static get NAME() {
2740
+ return NAME$6;
2741
+ }
2742
+
2743
+ // Public
2744
+ toggle(relatedTarget) {
2745
+ return this._isShown ? this.hide() : this.show(relatedTarget);
2746
+ }
2747
+ show(relatedTarget) {
2748
+ if (this._isShown) {
2749
+ return;
2750
+ }
2751
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, {
2752
+ relatedTarget
2753
+ });
2754
+ if (showEvent.defaultPrevented) {
2755
+ return;
2756
+ }
2757
+ this._isShown = true;
2758
+ this._backdrop.show();
2759
+ if (!this._config.scroll) {
2760
+ new ScrollBarHelper().hide();
2761
+ }
2762
+ this._element.setAttribute('aria-modal', true);
2763
+ this._element.setAttribute('role', 'dialog');
2764
+ this._element.classList.add(CLASS_NAME_SHOWING$1);
2765
+ const completeCallBack = () => {
2766
+ if (!this._config.scroll || this._config.backdrop) {
2767
+ this._focustrap.activate();
2768
+ }
2769
+ this._element.classList.add(CLASS_NAME_SHOW$3);
2770
+ this._element.classList.remove(CLASS_NAME_SHOWING$1);
2771
+ EventHandler.trigger(this._element, EVENT_SHOWN$3, {
2772
+ relatedTarget
2773
+ });
2774
+ };
2775
+ this._queueCallback(completeCallBack, this._element, true);
2776
+ }
2777
+ hide() {
2778
+ if (!this._isShown) {
2779
+ return;
2780
+ }
2781
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3);
2782
+ if (hideEvent.defaultPrevented) {
2783
+ return;
2784
+ }
2785
+ this._focustrap.deactivate();
2786
+ this._element.blur();
2787
+ this._isShown = false;
2788
+ this._element.classList.add(CLASS_NAME_HIDING);
2789
+ this._backdrop.hide();
2790
+ const completeCallback = () => {
2791
+ this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING);
2792
+ this._element.removeAttribute('aria-modal');
2793
+ this._element.removeAttribute('role');
2794
+ if (!this._config.scroll) {
2795
+ new ScrollBarHelper().reset();
2796
+ }
2797
+ EventHandler.trigger(this._element, EVENT_HIDDEN$3);
2798
+ };
2799
+ this._queueCallback(completeCallback, this._element, true);
2800
+ }
2801
+ dispose() {
2802
+ this._backdrop.dispose();
2803
+ this._focustrap.deactivate();
2804
+ super.dispose();
2805
+ }
2806
+
2807
+ // Private
2808
+ _initializeBackDrop() {
2809
+ const clickCallback = () => {
2810
+ if (this._config.backdrop === 'static') {
2811
+ EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
2812
+ return;
2813
+ }
2814
+ this.hide();
2815
+ };
2816
+
2817
+ // 'static' option will be translated to true, and booleans will keep their value
2818
+ const isVisible = Boolean(this._config.backdrop);
2819
+ return new Backdrop({
2820
+ className: CLASS_NAME_BACKDROP,
2821
+ isVisible,
2822
+ isAnimated: true,
2823
+ rootElement: this._element.parentNode,
2824
+ clickCallback: isVisible ? clickCallback : null
2825
+ });
2826
+ }
2827
+ _initializeFocusTrap() {
2828
+ return new FocusTrap({
2829
+ trapElement: this._element
2830
+ });
2831
+ }
2832
+ _addEventListeners() {
2833
+ EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => {
2834
+ if (event.key !== ESCAPE_KEY) {
2835
+ return;
2836
+ }
2837
+ if (this._config.keyboard) {
2838
+ this.hide();
2839
+ return;
2840
+ }
2841
+ EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED);
2842
+ });
2843
+ }
2844
+
2845
+ // Static
2846
+ static jQueryInterface(config) {
2847
+ return this.each(function () {
2848
+ const data = Offcanvas.getOrCreateInstance(this, config);
2849
+ if (typeof config !== 'string') {
2850
+ return;
2851
+ }
2852
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
2853
+ throw new TypeError(`No method named "${config}"`);
2854
+ }
2855
+ data[config](this);
2856
+ });
2857
+ }
2858
+ }
2859
+
2860
+ /**
2861
+ * Data API implementation
2862
+ */
2863
+
2864
+ EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) {
2865
+ const target = SelectorEngine.getElementFromSelector(this);
2866
+ if (['A', 'AREA'].includes(this.tagName)) {
2867
+ event.preventDefault();
2868
+ }
2869
+ if (isDisabled(this)) {
2870
+ return;
2871
+ }
2872
+ EventHandler.one(target, EVENT_HIDDEN$3, () => {
2873
+ // focus on trigger when it is closed
2874
+ if (isVisible(this)) {
2875
+ this.focus();
2876
+ }
2877
+ });
2878
+
2879
+ // avoid conflict when clicking a toggler of an offcanvas, while another is open
2880
+ const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR);
2881
+ if (alreadyOpen && alreadyOpen !== target) {
2882
+ Offcanvas.getInstance(alreadyOpen).hide();
2883
+ }
2884
+ const data = Offcanvas.getOrCreateInstance(target);
2885
+ data.toggle(this);
2886
+ });
2887
+ EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => {
2888
+ for (const selector of SelectorEngine.find(OPEN_SELECTOR)) {
2889
+ Offcanvas.getOrCreateInstance(selector).show();
2890
+ }
2891
+ });
2892
+ EventHandler.on(window, EVENT_RESIZE, () => {
2893
+ for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) {
2894
+ if (getComputedStyle(element).position !== 'fixed') {
2895
+ Offcanvas.getOrCreateInstance(element).hide();
2896
+ }
2897
+ }
2898
+ });
2899
+ enableDismissTrigger(Offcanvas);
2900
+
2901
+ /**
2902
+ * jQuery
2903
+ */
2904
+
2905
+ defineJQueryPlugin(Offcanvas);
2906
+
2907
+ /**
2908
+ * --------------------------------------------------------------------------
2909
+ * Bootstrap util/sanitizer.js
2910
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
2911
+ * --------------------------------------------------------------------------
2912
+ */
2913
+
2914
+ // js-docs-start allow-list
2915
+ const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
2916
+ const DefaultAllowlist = {
2917
+ // Global attributes allowed on any supplied element below.
2918
+ '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
2919
+ a: ['target', 'href', 'title', 'rel'],
2920
+ area: [],
2921
+ b: [],
2922
+ br: [],
2923
+ col: [],
2924
+ code: [],
2925
+ dd: [],
2926
+ div: [],
2927
+ dl: [],
2928
+ dt: [],
2929
+ em: [],
2930
+ hr: [],
2931
+ h1: [],
2932
+ h2: [],
2933
+ h3: [],
2934
+ h4: [],
2935
+ h5: [],
2936
+ h6: [],
2937
+ i: [],
2938
+ img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
2939
+ li: [],
2940
+ ol: [],
2941
+ p: [],
2942
+ pre: [],
2943
+ s: [],
2944
+ small: [],
2945
+ span: [],
2946
+ sub: [],
2947
+ sup: [],
2948
+ strong: [],
2949
+ u: [],
2950
+ ul: []
2951
+ };
2952
+ // js-docs-end allow-list
2953
+
2954
+ const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']);
2955
+
2956
+ /**
2957
+ * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation
2958
+ * contexts.
2959
+ *
2960
+ * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38
2961
+ */
2962
+ // eslint-disable-next-line unicorn/better-regex
2963
+ const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i;
2964
+ const allowedAttribute = (attribute, allowedAttributeList) => {
2965
+ const attributeName = attribute.nodeName.toLowerCase();
2966
+ if (allowedAttributeList.includes(attributeName)) {
2967
+ if (uriAttributes.has(attributeName)) {
2968
+ return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue));
2969
+ }
2970
+ return true;
2971
+ }
2972
+
2973
+ // Check if a regular expression validates the attribute.
2974
+ return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName));
2975
+ };
2976
+ function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) {
2977
+ if (!unsafeHtml.length) {
2978
+ return unsafeHtml;
2979
+ }
2980
+ if (sanitizeFunction && typeof sanitizeFunction === 'function') {
2981
+ return sanitizeFunction(unsafeHtml);
2982
+ }
2983
+ const domParser = new window.DOMParser();
2984
+ const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
2985
+ const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
2986
+ for (const element of elements) {
2987
+ const elementName = element.nodeName.toLowerCase();
2988
+ if (!Object.keys(allowList).includes(elementName)) {
2989
+ element.remove();
2990
+ continue;
2991
+ }
2992
+ const attributeList = [].concat(...element.attributes);
2993
+ const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []);
2994
+ for (const attribute of attributeList) {
2995
+ if (!allowedAttribute(attribute, allowedAttributes)) {
2996
+ element.removeAttribute(attribute.nodeName);
2997
+ }
2998
+ }
2999
+ }
3000
+ return createdDocument.body.innerHTML;
3001
+ }
3002
+
3003
+ /**
3004
+ * --------------------------------------------------------------------------
3005
+ * Bootstrap util/template-factory.js
3006
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3007
+ * --------------------------------------------------------------------------
3008
+ */
3009
+
3010
+
3011
+ /**
3012
+ * Constants
3013
+ */
3014
+
3015
+ const NAME$5 = 'TemplateFactory';
3016
+ const Default$4 = {
3017
+ allowList: DefaultAllowlist,
3018
+ content: {},
3019
+ // { selector : text , selector2 : text2 , }
3020
+ extraClass: '',
3021
+ html: false,
3022
+ sanitize: true,
3023
+ sanitizeFn: null,
3024
+ template: '<div></div>'
3025
+ };
3026
+ const DefaultType$4 = {
3027
+ allowList: 'object',
3028
+ content: 'object',
3029
+ extraClass: '(string|function)',
3030
+ html: 'boolean',
3031
+ sanitize: 'boolean',
3032
+ sanitizeFn: '(null|function)',
3033
+ template: 'string'
3034
+ };
3035
+ const DefaultContentType = {
3036
+ entry: '(string|element|function|null)',
3037
+ selector: '(string|element)'
3038
+ };
3039
+
3040
+ /**
3041
+ * Class definition
3042
+ */
3043
+
3044
+ class TemplateFactory extends Config {
3045
+ constructor(config) {
3046
+ super();
3047
+ this._config = this._getConfig(config);
3048
+ }
3049
+
3050
+ // Getters
3051
+ static get Default() {
3052
+ return Default$4;
3053
+ }
3054
+ static get DefaultType() {
3055
+ return DefaultType$4;
3056
+ }
3057
+ static get NAME() {
3058
+ return NAME$5;
3059
+ }
3060
+
3061
+ // Public
3062
+ getContent() {
3063
+ return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean);
3064
+ }
3065
+ hasContent() {
3066
+ return this.getContent().length > 0;
3067
+ }
3068
+ changeContent(content) {
3069
+ this._checkContent(content);
3070
+ this._config.content = {
3071
+ ...this._config.content,
3072
+ ...content
3073
+ };
3074
+ return this;
3075
+ }
3076
+ toHtml() {
3077
+ const templateWrapper = document.createElement('div');
3078
+ templateWrapper.innerHTML = this._maybeSanitize(this._config.template);
3079
+ for (const [selector, text] of Object.entries(this._config.content)) {
3080
+ this._setContent(templateWrapper, text, selector);
3081
+ }
3082
+ const template = templateWrapper.children[0];
3083
+ const extraClass = this._resolvePossibleFunction(this._config.extraClass);
3084
+ if (extraClass) {
3085
+ template.classList.add(...extraClass.split(' '));
3086
+ }
3087
+ return template;
3088
+ }
3089
+
3090
+ // Private
3091
+ _typeCheckConfig(config) {
3092
+ super._typeCheckConfig(config);
3093
+ this._checkContent(config.content);
3094
+ }
3095
+ _checkContent(arg) {
3096
+ for (const [selector, content] of Object.entries(arg)) {
3097
+ super._typeCheckConfig({
3098
+ selector,
3099
+ entry: content
3100
+ }, DefaultContentType);
3101
+ }
3102
+ }
3103
+ _setContent(template, content, selector) {
3104
+ const templateElement = SelectorEngine.findOne(selector, template);
3105
+ if (!templateElement) {
3106
+ return;
3107
+ }
3108
+ content = this._resolvePossibleFunction(content);
3109
+ if (!content) {
3110
+ templateElement.remove();
3111
+ return;
3112
+ }
3113
+ if (isElement(content)) {
3114
+ this._putElementInTemplate(getElement(content), templateElement);
3115
+ return;
3116
+ }
3117
+ if (this._config.html) {
3118
+ templateElement.innerHTML = this._maybeSanitize(content);
3119
+ return;
3120
+ }
3121
+ templateElement.textContent = content;
3122
+ }
3123
+ _maybeSanitize(arg) {
3124
+ return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;
3125
+ }
3126
+ _resolvePossibleFunction(arg) {
3127
+ return execute(arg, [this]);
3128
+ }
3129
+ _putElementInTemplate(element, templateElement) {
3130
+ if (this._config.html) {
3131
+ templateElement.innerHTML = '';
3132
+ templateElement.append(element);
3133
+ return;
3134
+ }
3135
+ templateElement.textContent = element.textContent;
3136
+ }
3137
+ }
3138
+
3139
+ /**
3140
+ * --------------------------------------------------------------------------
3141
+ * Bootstrap tooltip.js
3142
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3143
+ * --------------------------------------------------------------------------
3144
+ */
3145
+
3146
+
3147
+ /**
3148
+ * Constants
3149
+ */
3150
+
3151
+ const NAME$4 = 'tooltip';
3152
+ const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']);
3153
+ const CLASS_NAME_FADE$2 = 'fade';
3154
+ const CLASS_NAME_MODAL = 'modal';
3155
+ const CLASS_NAME_SHOW$2 = 'show';
3156
+ const SELECTOR_TOOLTIP_INNER = '.tooltip-inner';
3157
+ const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`;
3158
+ const EVENT_MODAL_HIDE = 'hide.bs.modal';
3159
+ const TRIGGER_HOVER = 'hover';
3160
+ const TRIGGER_FOCUS = 'focus';
3161
+ const TRIGGER_CLICK = 'click';
3162
+ const TRIGGER_MANUAL = 'manual';
3163
+ const EVENT_HIDE$2 = 'hide';
3164
+ const EVENT_HIDDEN$2 = 'hidden';
3165
+ const EVENT_SHOW$2 = 'show';
3166
+ const EVENT_SHOWN$2 = 'shown';
3167
+ const EVENT_INSERTED = 'inserted';
3168
+ const EVENT_CLICK$1 = 'click';
3169
+ const EVENT_FOCUSIN$1 = 'focusin';
3170
+ const EVENT_FOCUSOUT$1 = 'focusout';
3171
+ const EVENT_MOUSEENTER = 'mouseenter';
3172
+ const EVENT_MOUSELEAVE = 'mouseleave';
3173
+ const AttachmentMap = {
3174
+ AUTO: 'auto',
3175
+ TOP: 'top',
3176
+ RIGHT: isRTL() ? 'left' : 'right',
3177
+ BOTTOM: 'bottom',
3178
+ LEFT: isRTL() ? 'right' : 'left'
3179
+ };
3180
+ const Default$3 = {
3181
+ allowList: DefaultAllowlist,
3182
+ animation: true,
3183
+ boundary: 'clippingParents',
3184
+ container: false,
3185
+ customClass: '',
3186
+ delay: 0,
3187
+ fallbackPlacements: ['top', 'right', 'bottom', 'left'],
3188
+ html: false,
3189
+ offset: [0, 6],
3190
+ placement: 'top',
3191
+ popperConfig: null,
3192
+ sanitize: true,
3193
+ sanitizeFn: null,
3194
+ selector: false,
3195
+ template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>',
3196
+ title: '',
3197
+ trigger: 'hover focus'
3198
+ };
3199
+ const DefaultType$3 = {
3200
+ allowList: 'object',
3201
+ animation: 'boolean',
3202
+ boundary: '(string|element)',
3203
+ container: '(string|element|boolean)',
3204
+ customClass: '(string|function)',
3205
+ delay: '(number|object)',
3206
+ fallbackPlacements: 'array',
3207
+ html: 'boolean',
3208
+ offset: '(array|string|function)',
3209
+ placement: '(string|function)',
3210
+ popperConfig: '(null|object|function)',
3211
+ sanitize: 'boolean',
3212
+ sanitizeFn: '(null|function)',
3213
+ selector: '(string|boolean)',
3214
+ template: 'string',
3215
+ title: '(string|element|function)',
3216
+ trigger: 'string'
3217
+ };
3218
+
3219
+ /**
3220
+ * Class definition
3221
+ */
3222
+
3223
+ class Tooltip extends BaseComponent {
3224
+ constructor(element, config) {
3225
+ if (typeof Popper === 'undefined') {
3226
+ throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)');
3227
+ }
3228
+ super(element, config);
3229
+
3230
+ // Private
3231
+ this._isEnabled = true;
3232
+ this._timeout = 0;
3233
+ this._isHovered = null;
3234
+ this._activeTrigger = {};
3235
+ this._popper = null;
3236
+ this._templateFactory = null;
3237
+ this._newContent = null;
3238
+
3239
+ // Protected
3240
+ this.tip = null;
3241
+ this._setListeners();
3242
+ if (!this._config.selector) {
3243
+ this._fixTitle();
3244
+ }
3245
+ }
3246
+
3247
+ // Getters
3248
+ static get Default() {
3249
+ return Default$3;
3250
+ }
3251
+ static get DefaultType() {
3252
+ return DefaultType$3;
3253
+ }
3254
+ static get NAME() {
3255
+ return NAME$4;
3256
+ }
3257
+
3258
+ // Public
3259
+ enable() {
3260
+ this._isEnabled = true;
3261
+ }
3262
+ disable() {
3263
+ this._isEnabled = false;
3264
+ }
3265
+ toggleEnabled() {
3266
+ this._isEnabled = !this._isEnabled;
3267
+ }
3268
+ toggle() {
3269
+ if (!this._isEnabled) {
3270
+ return;
3271
+ }
3272
+ this._activeTrigger.click = !this._activeTrigger.click;
3273
+ if (this._isShown()) {
3274
+ this._leave();
3275
+ return;
3276
+ }
3277
+ this._enter();
3278
+ }
3279
+ dispose() {
3280
+ clearTimeout(this._timeout);
3281
+ EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
3282
+ if (this._element.getAttribute('data-bs-original-title')) {
3283
+ this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title'));
3284
+ }
3285
+ this._disposePopper();
3286
+ super.dispose();
3287
+ }
3288
+ show() {
3289
+ if (this._element.style.display === 'none') {
3290
+ throw new Error('Please use show on visible elements');
3291
+ }
3292
+ if (!(this._isWithContent() && this._isEnabled)) {
3293
+ return;
3294
+ }
3295
+ const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2));
3296
+ const shadowRoot = findShadowRoot(this._element);
3297
+ const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element);
3298
+ if (showEvent.defaultPrevented || !isInTheDom) {
3299
+ return;
3300
+ }
3301
+
3302
+ // TODO: v6 remove this or make it optional
3303
+ this._disposePopper();
3304
+ const tip = this._getTipElement();
3305
+ this._element.setAttribute('aria-describedby', tip.getAttribute('id'));
3306
+ const {
3307
+ container
3308
+ } = this._config;
3309
+ if (!this._element.ownerDocument.documentElement.contains(this.tip)) {
3310
+ container.append(tip);
3311
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED));
3312
+ }
3313
+ this._popper = this._createPopper(tip);
3314
+ tip.classList.add(CLASS_NAME_SHOW$2);
3315
+
3316
+ // If this is a touch-enabled device we add extra
3317
+ // empty mouseover listeners to the body's immediate children;
3318
+ // only needed because of broken event delegation on iOS
3319
+ // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html
3320
+ if ('ontouchstart' in document.documentElement) {
3321
+ for (const element of [].concat(...document.body.children)) {
3322
+ EventHandler.on(element, 'mouseover', noop);
3323
+ }
3324
+ }
3325
+ const complete = () => {
3326
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2));
3327
+ if (this._isHovered === false) {
3328
+ this._leave();
3329
+ }
3330
+ this._isHovered = false;
3331
+ };
3332
+ this._queueCallback(complete, this.tip, this._isAnimated());
3333
+ }
3334
+ hide() {
3335
+ if (!this._isShown()) {
3336
+ return;
3337
+ }
3338
+ const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2));
3339
+ if (hideEvent.defaultPrevented) {
3340
+ return;
3341
+ }
3342
+ const tip = this._getTipElement();
3343
+ tip.classList.remove(CLASS_NAME_SHOW$2);
3344
+
3345
+ // If this is a touch-enabled device we remove the extra
3346
+ // empty mouseover listeners we added for iOS support
3347
+ if ('ontouchstart' in document.documentElement) {
3348
+ for (const element of [].concat(...document.body.children)) {
3349
+ EventHandler.off(element, 'mouseover', noop);
3350
+ }
3351
+ }
3352
+ this._activeTrigger[TRIGGER_CLICK] = false;
3353
+ this._activeTrigger[TRIGGER_FOCUS] = false;
3354
+ this._activeTrigger[TRIGGER_HOVER] = false;
3355
+ this._isHovered = null; // it is a trick to support manual triggering
3356
+
3357
+ const complete = () => {
3358
+ if (this._isWithActiveTrigger()) {
3359
+ return;
3360
+ }
3361
+ if (!this._isHovered) {
3362
+ this._disposePopper();
3363
+ }
3364
+ this._element.removeAttribute('aria-describedby');
3365
+ EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2));
3366
+ };
3367
+ this._queueCallback(complete, this.tip, this._isAnimated());
3368
+ }
3369
+ update() {
3370
+ if (this._popper) {
3371
+ this._popper.update();
3372
+ }
3373
+ }
3374
+
3375
+ // Protected
3376
+ _isWithContent() {
3377
+ return Boolean(this._getTitle());
3378
+ }
3379
+ _getTipElement() {
3380
+ if (!this.tip) {
3381
+ this.tip = this._createTipElement(this._newContent || this._getContentForTemplate());
3382
+ }
3383
+ return this.tip;
3384
+ }
3385
+ _createTipElement(content) {
3386
+ const tip = this._getTemplateFactory(content).toHtml();
3387
+
3388
+ // TODO: remove this check in v6
3389
+ if (!tip) {
3390
+ return null;
3391
+ }
3392
+ tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2);
3393
+ // TODO: v6 the following can be achieved with CSS only
3394
+ tip.classList.add(`bs-${this.constructor.NAME}-auto`);
3395
+ const tipId = getUID(this.constructor.NAME).toString();
3396
+ tip.setAttribute('id', tipId);
3397
+ if (this._isAnimated()) {
3398
+ tip.classList.add(CLASS_NAME_FADE$2);
3399
+ }
3400
+ return tip;
3401
+ }
3402
+ setContent(content) {
3403
+ this._newContent = content;
3404
+ if (this._isShown()) {
3405
+ this._disposePopper();
3406
+ this.show();
3407
+ }
3408
+ }
3409
+ _getTemplateFactory(content) {
3410
+ if (this._templateFactory) {
3411
+ this._templateFactory.changeContent(content);
3412
+ } else {
3413
+ this._templateFactory = new TemplateFactory({
3414
+ ...this._config,
3415
+ // the `content` var has to be after `this._config`
3416
+ // to override config.content in case of popover
3417
+ content,
3418
+ extraClass: this._resolvePossibleFunction(this._config.customClass)
3419
+ });
3420
+ }
3421
+ return this._templateFactory;
3422
+ }
3423
+ _getContentForTemplate() {
3424
+ return {
3425
+ [SELECTOR_TOOLTIP_INNER]: this._getTitle()
3426
+ };
3427
+ }
3428
+ _getTitle() {
3429
+ return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title');
3430
+ }
3431
+
3432
+ // Private
3433
+ _initializeOnDelegatedTarget(event) {
3434
+ return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig());
3435
+ }
3436
+ _isAnimated() {
3437
+ return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2);
3438
+ }
3439
+ _isShown() {
3440
+ return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2);
3441
+ }
3442
+ _createPopper(tip) {
3443
+ const placement = execute(this._config.placement, [this, tip, this._element]);
3444
+ const attachment = AttachmentMap[placement.toUpperCase()];
3445
+ return Popper.createPopper(this._element, tip, this._getPopperConfig(attachment));
3446
+ }
3447
+ _getOffset() {
3448
+ const {
3449
+ offset
3450
+ } = this._config;
3451
+ if (typeof offset === 'string') {
3452
+ return offset.split(',').map(value => Number.parseInt(value, 10));
3453
+ }
3454
+ if (typeof offset === 'function') {
3455
+ return popperData => offset(popperData, this._element);
3456
+ }
3457
+ return offset;
3458
+ }
3459
+ _resolvePossibleFunction(arg) {
3460
+ return execute(arg, [this._element]);
3461
+ }
3462
+ _getPopperConfig(attachment) {
3463
+ const defaultBsPopperConfig = {
3464
+ placement: attachment,
3465
+ modifiers: [{
3466
+ name: 'flip',
3467
+ options: {
3468
+ fallbackPlacements: this._config.fallbackPlacements
3469
+ }
3470
+ }, {
3471
+ name: 'offset',
3472
+ options: {
3473
+ offset: this._getOffset()
3474
+ }
3475
+ }, {
3476
+ name: 'preventOverflow',
3477
+ options: {
3478
+ boundary: this._config.boundary
3479
+ }
3480
+ }, {
3481
+ name: 'arrow',
3482
+ options: {
3483
+ element: `.${this.constructor.NAME}-arrow`
3484
+ }
3485
+ }, {
3486
+ name: 'preSetPlacement',
3487
+ enabled: true,
3488
+ phase: 'beforeMain',
3489
+ fn: data => {
3490
+ // Pre-set Popper's placement attribute in order to read the arrow sizes properly.
3491
+ // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement
3492
+ this._getTipElement().setAttribute('data-popper-placement', data.state.placement);
3493
+ }
3494
+ }]
3495
+ };
3496
+ return {
3497
+ ...defaultBsPopperConfig,
3498
+ ...execute(this._config.popperConfig, [defaultBsPopperConfig])
3499
+ };
3500
+ }
3501
+ _setListeners() {
3502
+ const triggers = this._config.trigger.split(' ');
3503
+ for (const trigger of triggers) {
3504
+ if (trigger === 'click') {
3505
+ EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => {
3506
+ const context = this._initializeOnDelegatedTarget(event);
3507
+ context.toggle();
3508
+ });
3509
+ } else if (trigger !== TRIGGER_MANUAL) {
3510
+ const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1);
3511
+ const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1);
3512
+ EventHandler.on(this._element, eventIn, this._config.selector, event => {
3513
+ const context = this._initializeOnDelegatedTarget(event);
3514
+ context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true;
3515
+ context._enter();
3516
+ });
3517
+ EventHandler.on(this._element, eventOut, this._config.selector, event => {
3518
+ const context = this._initializeOnDelegatedTarget(event);
3519
+ context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget);
3520
+ context._leave();
3521
+ });
3522
+ }
3523
+ }
3524
+ this._hideModalHandler = () => {
3525
+ if (this._element) {
3526
+ this.hide();
3527
+ }
3528
+ };
3529
+ EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler);
3530
+ }
3531
+ _fixTitle() {
3532
+ const title = this._element.getAttribute('title');
3533
+ if (!title) {
3534
+ return;
3535
+ }
3536
+ if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) {
3537
+ this._element.setAttribute('aria-label', title);
3538
+ }
3539
+ this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility
3540
+ this._element.removeAttribute('title');
3541
+ }
3542
+ _enter() {
3543
+ if (this._isShown() || this._isHovered) {
3544
+ this._isHovered = true;
3545
+ return;
3546
+ }
3547
+ this._isHovered = true;
3548
+ this._setTimeout(() => {
3549
+ if (this._isHovered) {
3550
+ this.show();
3551
+ }
3552
+ }, this._config.delay.show);
3553
+ }
3554
+ _leave() {
3555
+ if (this._isWithActiveTrigger()) {
3556
+ return;
3557
+ }
3558
+ this._isHovered = false;
3559
+ this._setTimeout(() => {
3560
+ if (!this._isHovered) {
3561
+ this.hide();
3562
+ }
3563
+ }, this._config.delay.hide);
3564
+ }
3565
+ _setTimeout(handler, timeout) {
3566
+ clearTimeout(this._timeout);
3567
+ this._timeout = setTimeout(handler, timeout);
3568
+ }
3569
+ _isWithActiveTrigger() {
3570
+ return Object.values(this._activeTrigger).includes(true);
3571
+ }
3572
+ _getConfig(config) {
3573
+ const dataAttributes = Manipulator.getDataAttributes(this._element);
3574
+ for (const dataAttribute of Object.keys(dataAttributes)) {
3575
+ if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) {
3576
+ delete dataAttributes[dataAttribute];
3577
+ }
3578
+ }
3579
+ config = {
3580
+ ...dataAttributes,
3581
+ ...(typeof config === 'object' && config ? config : {})
3582
+ };
3583
+ config = this._mergeConfigObj(config);
3584
+ config = this._configAfterMerge(config);
3585
+ this._typeCheckConfig(config);
3586
+ return config;
3587
+ }
3588
+ _configAfterMerge(config) {
3589
+ config.container = config.container === false ? document.body : getElement(config.container);
3590
+ if (typeof config.delay === 'number') {
3591
+ config.delay = {
3592
+ show: config.delay,
3593
+ hide: config.delay
3594
+ };
3595
+ }
3596
+ if (typeof config.title === 'number') {
3597
+ config.title = config.title.toString();
3598
+ }
3599
+ if (typeof config.content === 'number') {
3600
+ config.content = config.content.toString();
3601
+ }
3602
+ return config;
3603
+ }
3604
+ _getDelegateConfig() {
3605
+ const config = {};
3606
+ for (const [key, value] of Object.entries(this._config)) {
3607
+ if (this.constructor.Default[key] !== value) {
3608
+ config[key] = value;
3609
+ }
3610
+ }
3611
+ config.selector = false;
3612
+ config.trigger = 'manual';
3613
+
3614
+ // In the future can be replaced with:
3615
+ // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]])
3616
+ // `Object.fromEntries(keysWithDifferentValues)`
3617
+ return config;
3618
+ }
3619
+ _disposePopper() {
3620
+ if (this._popper) {
3621
+ this._popper.destroy();
3622
+ this._popper = null;
3623
+ }
3624
+ if (this.tip) {
3625
+ this.tip.remove();
3626
+ this.tip = null;
3627
+ }
3628
+ }
3629
+
3630
+ // Static
3631
+ static jQueryInterface(config) {
3632
+ return this.each(function () {
3633
+ const data = Tooltip.getOrCreateInstance(this, config);
3634
+ if (typeof config !== 'string') {
3635
+ return;
3636
+ }
3637
+ if (typeof data[config] === 'undefined') {
3638
+ throw new TypeError(`No method named "${config}"`);
3639
+ }
3640
+ data[config]();
3641
+ });
3642
+ }
3643
+ }
3644
+
3645
+ /**
3646
+ * jQuery
3647
+ */
3648
+
3649
+ defineJQueryPlugin(Tooltip);
3650
+
3651
+ /**
3652
+ * --------------------------------------------------------------------------
3653
+ * Bootstrap popover.js
3654
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3655
+ * --------------------------------------------------------------------------
3656
+ */
3657
+
3658
+
3659
+ /**
3660
+ * Constants
3661
+ */
3662
+
3663
+ const NAME$3 = 'popover';
3664
+ const SELECTOR_TITLE = '.popover-header';
3665
+ const SELECTOR_CONTENT = '.popover-body';
3666
+ const Default$2 = {
3667
+ ...Tooltip.Default,
3668
+ content: '',
3669
+ offset: [0, 8],
3670
+ placement: 'right',
3671
+ template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>',
3672
+ trigger: 'click'
3673
+ };
3674
+ const DefaultType$2 = {
3675
+ ...Tooltip.DefaultType,
3676
+ content: '(null|string|element|function)'
3677
+ };
3678
+
3679
+ /**
3680
+ * Class definition
3681
+ */
3682
+
3683
+ class Popover extends Tooltip {
3684
+ // Getters
3685
+ static get Default() {
3686
+ return Default$2;
3687
+ }
3688
+ static get DefaultType() {
3689
+ return DefaultType$2;
3690
+ }
3691
+ static get NAME() {
3692
+ return NAME$3;
3693
+ }
3694
+
3695
+ // Overrides
3696
+ _isWithContent() {
3697
+ return this._getTitle() || this._getContent();
3698
+ }
3699
+
3700
+ // Private
3701
+ _getContentForTemplate() {
3702
+ return {
3703
+ [SELECTOR_TITLE]: this._getTitle(),
3704
+ [SELECTOR_CONTENT]: this._getContent()
3705
+ };
3706
+ }
3707
+ _getContent() {
3708
+ return this._resolvePossibleFunction(this._config.content);
3709
+ }
3710
+
3711
+ // Static
3712
+ static jQueryInterface(config) {
3713
+ return this.each(function () {
3714
+ const data = Popover.getOrCreateInstance(this, config);
3715
+ if (typeof config !== 'string') {
3716
+ return;
3717
+ }
3718
+ if (typeof data[config] === 'undefined') {
3719
+ throw new TypeError(`No method named "${config}"`);
3720
+ }
3721
+ data[config]();
3722
+ });
3723
+ }
3724
+ }
3725
+
3726
+ /**
3727
+ * jQuery
3728
+ */
3729
+
3730
+ defineJQueryPlugin(Popover);
3731
+
3732
+ /**
3733
+ * --------------------------------------------------------------------------
3734
+ * Bootstrap scrollspy.js
3735
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3736
+ * --------------------------------------------------------------------------
3737
+ */
3738
+
3739
+
3740
+ /**
3741
+ * Constants
3742
+ */
3743
+
3744
+ const NAME$2 = 'scrollspy';
3745
+ const DATA_KEY$2 = 'bs.scrollspy';
3746
+ const EVENT_KEY$2 = `.${DATA_KEY$2}`;
3747
+ const DATA_API_KEY = '.data-api';
3748
+ const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`;
3749
+ const EVENT_CLICK = `click${EVENT_KEY$2}`;
3750
+ const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`;
3751
+ const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item';
3752
+ const CLASS_NAME_ACTIVE$1 = 'active';
3753
+ const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]';
3754
+ const SELECTOR_TARGET_LINKS = '[href]';
3755
+ const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group';
3756
+ const SELECTOR_NAV_LINKS = '.nav-link';
3757
+ const SELECTOR_NAV_ITEMS = '.nav-item';
3758
+ const SELECTOR_LIST_ITEMS = '.list-group-item';
3759
+ const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`;
3760
+ const SELECTOR_DROPDOWN = '.dropdown';
3761
+ const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle';
3762
+ const Default$1 = {
3763
+ offset: null,
3764
+ // TODO: v6 @deprecated, keep it for backwards compatibility reasons
3765
+ rootMargin: '0px 0px -25%',
3766
+ smoothScroll: false,
3767
+ target: null,
3768
+ threshold: [0.1, 0.5, 1]
3769
+ };
3770
+ const DefaultType$1 = {
3771
+ offset: '(number|null)',
3772
+ // TODO v6 @deprecated, keep it for backwards compatibility reasons
3773
+ rootMargin: 'string',
3774
+ smoothScroll: 'boolean',
3775
+ target: 'element',
3776
+ threshold: 'array'
3777
+ };
3778
+
3779
+ /**
3780
+ * Class definition
3781
+ */
3782
+
3783
+ class ScrollSpy extends BaseComponent {
3784
+ constructor(element, config) {
3785
+ super(element, config);
3786
+
3787
+ // this._element is the observablesContainer and config.target the menu links wrapper
3788
+ this._targetLinks = new Map();
3789
+ this._observableSections = new Map();
3790
+ this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element;
3791
+ this._activeTarget = null;
3792
+ this._observer = null;
3793
+ this._previousScrollData = {
3794
+ visibleEntryTop: 0,
3795
+ parentScrollTop: 0
3796
+ };
3797
+ this.refresh(); // initialize
3798
+ }
3799
+
3800
+ // Getters
3801
+ static get Default() {
3802
+ return Default$1;
3803
+ }
3804
+ static get DefaultType() {
3805
+ return DefaultType$1;
3806
+ }
3807
+ static get NAME() {
3808
+ return NAME$2;
3809
+ }
3810
+
3811
+ // Public
3812
+ refresh() {
3813
+ this._initializeTargetsAndObservables();
3814
+ this._maybeEnableSmoothScroll();
3815
+ if (this._observer) {
3816
+ this._observer.disconnect();
3817
+ } else {
3818
+ this._observer = this._getNewObserver();
3819
+ }
3820
+ for (const section of this._observableSections.values()) {
3821
+ this._observer.observe(section);
3822
+ }
3823
+ }
3824
+ dispose() {
3825
+ this._observer.disconnect();
3826
+ super.dispose();
3827
+ }
3828
+
3829
+ // Private
3830
+ _configAfterMerge(config) {
3831
+ // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case
3832
+ config.target = getElement(config.target) || document.body;
3833
+
3834
+ // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only
3835
+ config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin;
3836
+ if (typeof config.threshold === 'string') {
3837
+ config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value));
3838
+ }
3839
+ return config;
3840
+ }
3841
+ _maybeEnableSmoothScroll() {
3842
+ if (!this._config.smoothScroll) {
3843
+ return;
3844
+ }
3845
+
3846
+ // unregister any previous listeners
3847
+ EventHandler.off(this._config.target, EVENT_CLICK);
3848
+ EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => {
3849
+ const observableSection = this._observableSections.get(event.target.hash);
3850
+ if (observableSection) {
3851
+ event.preventDefault();
3852
+ const root = this._rootElement || window;
3853
+ const height = observableSection.offsetTop - this._element.offsetTop;
3854
+ if (root.scrollTo) {
3855
+ root.scrollTo({
3856
+ top: height,
3857
+ behavior: 'smooth'
3858
+ });
3859
+ return;
3860
+ }
3861
+
3862
+ // Chrome 60 doesn't support `scrollTo`
3863
+ root.scrollTop = height;
3864
+ }
3865
+ });
3866
+ }
3867
+ _getNewObserver() {
3868
+ const options = {
3869
+ root: this._rootElement,
3870
+ threshold: this._config.threshold,
3871
+ rootMargin: this._config.rootMargin
3872
+ };
3873
+ return new IntersectionObserver(entries => this._observerCallback(entries), options);
3874
+ }
3875
+
3876
+ // The logic of selection
3877
+ _observerCallback(entries) {
3878
+ const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`);
3879
+ const activate = entry => {
3880
+ this._previousScrollData.visibleEntryTop = entry.target.offsetTop;
3881
+ this._process(targetElement(entry));
3882
+ };
3883
+ const parentScrollTop = (this._rootElement || document.documentElement).scrollTop;
3884
+ const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop;
3885
+ this._previousScrollData.parentScrollTop = parentScrollTop;
3886
+ for (const entry of entries) {
3887
+ if (!entry.isIntersecting) {
3888
+ this._activeTarget = null;
3889
+ this._clearActiveClass(targetElement(entry));
3890
+ continue;
3891
+ }
3892
+ const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop;
3893
+ // if we are scrolling down, pick the bigger offsetTop
3894
+ if (userScrollsDown && entryIsLowerThanPrevious) {
3895
+ activate(entry);
3896
+ // if parent isn't scrolled, let's keep the first visible item, breaking the iteration
3897
+ if (!parentScrollTop) {
3898
+ return;
3899
+ }
3900
+ continue;
3901
+ }
3902
+
3903
+ // if we are scrolling up, pick the smallest offsetTop
3904
+ if (!userScrollsDown && !entryIsLowerThanPrevious) {
3905
+ activate(entry);
3906
+ }
3907
+ }
3908
+ }
3909
+ _initializeTargetsAndObservables() {
3910
+ this._targetLinks = new Map();
3911
+ this._observableSections = new Map();
3912
+ const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target);
3913
+ for (const anchor of targetLinks) {
3914
+ // ensure that the anchor has an id and is not disabled
3915
+ if (!anchor.hash || isDisabled(anchor)) {
3916
+ continue;
3917
+ }
3918
+ const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element);
3919
+
3920
+ // ensure that the observableSection exists & is visible
3921
+ if (isVisible(observableSection)) {
3922
+ this._targetLinks.set(decodeURI(anchor.hash), anchor);
3923
+ this._observableSections.set(anchor.hash, observableSection);
3924
+ }
3925
+ }
3926
+ }
3927
+ _process(target) {
3928
+ if (this._activeTarget === target) {
3929
+ return;
3930
+ }
3931
+ this._clearActiveClass(this._config.target);
3932
+ this._activeTarget = target;
3933
+ target.classList.add(CLASS_NAME_ACTIVE$1);
3934
+ this._activateParents(target);
3935
+ EventHandler.trigger(this._element, EVENT_ACTIVATE, {
3936
+ relatedTarget: target
3937
+ });
3938
+ }
3939
+ _activateParents(target) {
3940
+ // Activate dropdown parents
3941
+ if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) {
3942
+ SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1);
3943
+ return;
3944
+ }
3945
+ for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) {
3946
+ // Set triggered links parents as active
3947
+ // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor
3948
+ for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) {
3949
+ item.classList.add(CLASS_NAME_ACTIVE$1);
3950
+ }
3951
+ }
3952
+ }
3953
+ _clearActiveClass(parent) {
3954
+ parent.classList.remove(CLASS_NAME_ACTIVE$1);
3955
+ const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent);
3956
+ for (const node of activeNodes) {
3957
+ node.classList.remove(CLASS_NAME_ACTIVE$1);
3958
+ }
3959
+ }
3960
+
3961
+ // Static
3962
+ static jQueryInterface(config) {
3963
+ return this.each(function () {
3964
+ const data = ScrollSpy.getOrCreateInstance(this, config);
3965
+ if (typeof config !== 'string') {
3966
+ return;
3967
+ }
3968
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
3969
+ throw new TypeError(`No method named "${config}"`);
3970
+ }
3971
+ data[config]();
3972
+ });
3973
+ }
3974
+ }
3975
+
3976
+ /**
3977
+ * Data API implementation
3978
+ */
3979
+
3980
+ EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => {
3981
+ for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) {
3982
+ ScrollSpy.getOrCreateInstance(spy);
3983
+ }
3984
+ });
3985
+
3986
+ /**
3987
+ * jQuery
3988
+ */
3989
+
3990
+ defineJQueryPlugin(ScrollSpy);
3991
+
3992
+ /**
3993
+ * --------------------------------------------------------------------------
3994
+ * Bootstrap tab.js
3995
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
3996
+ * --------------------------------------------------------------------------
3997
+ */
3998
+
3999
+
4000
+ /**
4001
+ * Constants
4002
+ */
4003
+
4004
+ const NAME$1 = 'tab';
4005
+ const DATA_KEY$1 = 'bs.tab';
4006
+ const EVENT_KEY$1 = `.${DATA_KEY$1}`;
4007
+ const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`;
4008
+ const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`;
4009
+ const EVENT_SHOW$1 = `show${EVENT_KEY$1}`;
4010
+ const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`;
4011
+ const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`;
4012
+ const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`;
4013
+ const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`;
4014
+ const ARROW_LEFT_KEY = 'ArrowLeft';
4015
+ const ARROW_RIGHT_KEY = 'ArrowRight';
4016
+ const ARROW_UP_KEY = 'ArrowUp';
4017
+ const ARROW_DOWN_KEY = 'ArrowDown';
4018
+ const HOME_KEY = 'Home';
4019
+ const END_KEY = 'End';
4020
+ const CLASS_NAME_ACTIVE = 'active';
4021
+ const CLASS_NAME_FADE$1 = 'fade';
4022
+ const CLASS_NAME_SHOW$1 = 'show';
4023
+ const CLASS_DROPDOWN = 'dropdown';
4024
+ const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle';
4025
+ const SELECTOR_DROPDOWN_MENU = '.dropdown-menu';
4026
+ const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`;
4027
+ const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]';
4028
+ const SELECTOR_OUTER = '.nav-item, .list-group-item';
4029
+ const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`;
4030
+ const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // TODO: could only be `tab` in v6
4031
+ const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`;
4032
+ const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`;
4033
+
4034
+ /**
4035
+ * Class definition
4036
+ */
4037
+
4038
+ class Tab extends BaseComponent {
4039
+ constructor(element) {
4040
+ super(element);
4041
+ this._parent = this._element.closest(SELECTOR_TAB_PANEL);
4042
+ if (!this._parent) {
4043
+ return;
4044
+ // TODO: should throw exception in v6
4045
+ // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`)
4046
+ }
4047
+
4048
+ // Set up initial aria attributes
4049
+ this._setInitialAttributes(this._parent, this._getChildren());
4050
+ EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event));
4051
+ }
4052
+
4053
+ // Getters
4054
+ static get NAME() {
4055
+ return NAME$1;
4056
+ }
4057
+
4058
+ // Public
4059
+ show() {
4060
+ // Shows this elem and deactivate the active sibling if exists
4061
+ const innerElem = this._element;
4062
+ if (this._elemIsActive(innerElem)) {
4063
+ return;
4064
+ }
4065
+
4066
+ // Search for active tab on same parent to deactivate it
4067
+ const active = this._getActiveElem();
4068
+ const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, {
4069
+ relatedTarget: innerElem
4070
+ }) : null;
4071
+ const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, {
4072
+ relatedTarget: active
4073
+ });
4074
+ if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) {
4075
+ return;
4076
+ }
4077
+ this._deactivate(active, innerElem);
4078
+ this._activate(innerElem, active);
4079
+ }
4080
+
4081
+ // Private
4082
+ _activate(element, relatedElem) {
4083
+ if (!element) {
4084
+ return;
4085
+ }
4086
+ element.classList.add(CLASS_NAME_ACTIVE);
4087
+ this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section
4088
+
4089
+ const complete = () => {
4090
+ if (element.getAttribute('role') !== 'tab') {
4091
+ element.classList.add(CLASS_NAME_SHOW$1);
4092
+ return;
4093
+ }
4094
+ element.removeAttribute('tabindex');
4095
+ element.setAttribute('aria-selected', true);
4096
+ this._toggleDropDown(element, true);
4097
+ EventHandler.trigger(element, EVENT_SHOWN$1, {
4098
+ relatedTarget: relatedElem
4099
+ });
4100
+ };
4101
+ this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4102
+ }
4103
+ _deactivate(element, relatedElem) {
4104
+ if (!element) {
4105
+ return;
4106
+ }
4107
+ element.classList.remove(CLASS_NAME_ACTIVE);
4108
+ element.blur();
4109
+ this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too
4110
+
4111
+ const complete = () => {
4112
+ if (element.getAttribute('role') !== 'tab') {
4113
+ element.classList.remove(CLASS_NAME_SHOW$1);
4114
+ return;
4115
+ }
4116
+ element.setAttribute('aria-selected', false);
4117
+ element.setAttribute('tabindex', '-1');
4118
+ this._toggleDropDown(element, false);
4119
+ EventHandler.trigger(element, EVENT_HIDDEN$1, {
4120
+ relatedTarget: relatedElem
4121
+ });
4122
+ };
4123
+ this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1));
4124
+ }
4125
+ _keydown(event) {
4126
+ if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) {
4127
+ return;
4128
+ }
4129
+ event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page
4130
+ event.preventDefault();
4131
+ const children = this._getChildren().filter(element => !isDisabled(element));
4132
+ let nextActiveElement;
4133
+ if ([HOME_KEY, END_KEY].includes(event.key)) {
4134
+ nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1];
4135
+ } else {
4136
+ const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key);
4137
+ nextActiveElement = getNextActiveElement(children, event.target, isNext, true);
4138
+ }
4139
+ if (nextActiveElement) {
4140
+ nextActiveElement.focus({
4141
+ preventScroll: true
4142
+ });
4143
+ Tab.getOrCreateInstance(nextActiveElement).show();
4144
+ }
4145
+ }
4146
+ _getChildren() {
4147
+ // collection of inner elements
4148
+ return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent);
4149
+ }
4150
+ _getActiveElem() {
4151
+ return this._getChildren().find(child => this._elemIsActive(child)) || null;
4152
+ }
4153
+ _setInitialAttributes(parent, children) {
4154
+ this._setAttributeIfNotExists(parent, 'role', 'tablist');
4155
+ for (const child of children) {
4156
+ this._setInitialAttributesOnChild(child);
4157
+ }
4158
+ }
4159
+ _setInitialAttributesOnChild(child) {
4160
+ child = this._getInnerElement(child);
4161
+ const isActive = this._elemIsActive(child);
4162
+ const outerElem = this._getOuterElement(child);
4163
+ child.setAttribute('aria-selected', isActive);
4164
+ if (outerElem !== child) {
4165
+ this._setAttributeIfNotExists(outerElem, 'role', 'presentation');
4166
+ }
4167
+ if (!isActive) {
4168
+ child.setAttribute('tabindex', '-1');
4169
+ }
4170
+ this._setAttributeIfNotExists(child, 'role', 'tab');
4171
+
4172
+ // set attributes to the related panel too
4173
+ this._setInitialAttributesOnTargetPanel(child);
4174
+ }
4175
+ _setInitialAttributesOnTargetPanel(child) {
4176
+ const target = SelectorEngine.getElementFromSelector(child);
4177
+ if (!target) {
4178
+ return;
4179
+ }
4180
+ this._setAttributeIfNotExists(target, 'role', 'tabpanel');
4181
+ if (child.id) {
4182
+ this._setAttributeIfNotExists(target, 'aria-labelledby', `${child.id}`);
4183
+ }
4184
+ }
4185
+ _toggleDropDown(element, open) {
4186
+ const outerElem = this._getOuterElement(element);
4187
+ if (!outerElem.classList.contains(CLASS_DROPDOWN)) {
4188
+ return;
4189
+ }
4190
+ const toggle = (selector, className) => {
4191
+ const element = SelectorEngine.findOne(selector, outerElem);
4192
+ if (element) {
4193
+ element.classList.toggle(className, open);
4194
+ }
4195
+ };
4196
+ toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE);
4197
+ toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1);
4198
+ outerElem.setAttribute('aria-expanded', open);
4199
+ }
4200
+ _setAttributeIfNotExists(element, attribute, value) {
4201
+ if (!element.hasAttribute(attribute)) {
4202
+ element.setAttribute(attribute, value);
4203
+ }
4204
+ }
4205
+ _elemIsActive(elem) {
4206
+ return elem.classList.contains(CLASS_NAME_ACTIVE);
4207
+ }
4208
+
4209
+ // Try to get the inner element (usually the .nav-link)
4210
+ _getInnerElement(elem) {
4211
+ return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem);
4212
+ }
4213
+
4214
+ // Try to get the outer element (usually the .nav-item)
4215
+ _getOuterElement(elem) {
4216
+ return elem.closest(SELECTOR_OUTER) || elem;
4217
+ }
4218
+
4219
+ // Static
4220
+ static jQueryInterface(config) {
4221
+ return this.each(function () {
4222
+ const data = Tab.getOrCreateInstance(this);
4223
+ if (typeof config !== 'string') {
4224
+ return;
4225
+ }
4226
+ if (data[config] === undefined || config.startsWith('_') || config === 'constructor') {
4227
+ throw new TypeError(`No method named "${config}"`);
4228
+ }
4229
+ data[config]();
4230
+ });
4231
+ }
4232
+ }
4233
+
4234
+ /**
4235
+ * Data API implementation
4236
+ */
4237
+
4238
+ EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) {
4239
+ if (['A', 'AREA'].includes(this.tagName)) {
4240
+ event.preventDefault();
4241
+ }
4242
+ if (isDisabled(this)) {
4243
+ return;
4244
+ }
4245
+ Tab.getOrCreateInstance(this).show();
4246
+ });
4247
+
4248
+ /**
4249
+ * Initialize on focus
4250
+ */
4251
+ EventHandler.on(window, EVENT_LOAD_DATA_API, () => {
4252
+ for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) {
4253
+ Tab.getOrCreateInstance(element);
4254
+ }
4255
+ });
4256
+ /**
4257
+ * jQuery
4258
+ */
4259
+
4260
+ defineJQueryPlugin(Tab);
4261
+
4262
+ /**
4263
+ * --------------------------------------------------------------------------
4264
+ * Bootstrap toast.js
4265
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
4266
+ * --------------------------------------------------------------------------
4267
+ */
4268
+
4269
+
4270
+ /**
4271
+ * Constants
4272
+ */
4273
+
4274
+ const NAME = 'toast';
4275
+ const DATA_KEY = 'bs.toast';
4276
+ const EVENT_KEY = `.${DATA_KEY}`;
4277
+ const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`;
4278
+ const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`;
4279
+ const EVENT_FOCUSIN = `focusin${EVENT_KEY}`;
4280
+ const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`;
4281
+ const EVENT_HIDE = `hide${EVENT_KEY}`;
4282
+ const EVENT_HIDDEN = `hidden${EVENT_KEY}`;
4283
+ const EVENT_SHOW = `show${EVENT_KEY}`;
4284
+ const EVENT_SHOWN = `shown${EVENT_KEY}`;
4285
+ const CLASS_NAME_FADE = 'fade';
4286
+ const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility
4287
+ const CLASS_NAME_SHOW = 'show';
4288
+ const CLASS_NAME_SHOWING = 'showing';
4289
+ const DefaultType = {
4290
+ animation: 'boolean',
4291
+ autohide: 'boolean',
4292
+ delay: 'number'
4293
+ };
4294
+ const Default = {
4295
+ animation: true,
4296
+ autohide: true,
4297
+ delay: 5000
4298
+ };
4299
+
4300
+ /**
4301
+ * Class definition
4302
+ */
4303
+
4304
+ class Toast extends BaseComponent {
4305
+ constructor(element, config) {
4306
+ super(element, config);
4307
+ this._timeout = null;
4308
+ this._hasMouseInteraction = false;
4309
+ this._hasKeyboardInteraction = false;
4310
+ this._setListeners();
4311
+ }
4312
+
4313
+ // Getters
4314
+ static get Default() {
4315
+ return Default;
4316
+ }
4317
+ static get DefaultType() {
4318
+ return DefaultType;
4319
+ }
4320
+ static get NAME() {
4321
+ return NAME;
4322
+ }
4323
+
4324
+ // Public
4325
+ show() {
4326
+ const showEvent = EventHandler.trigger(this._element, EVENT_SHOW);
4327
+ if (showEvent.defaultPrevented) {
4328
+ return;
4329
+ }
4330
+ this._clearTimeout();
4331
+ if (this._config.animation) {
4332
+ this._element.classList.add(CLASS_NAME_FADE);
4333
+ }
4334
+ const complete = () => {
4335
+ this._element.classList.remove(CLASS_NAME_SHOWING);
4336
+ EventHandler.trigger(this._element, EVENT_SHOWN);
4337
+ this._maybeScheduleHide();
4338
+ };
4339
+ this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated
4340
+ reflow(this._element);
4341
+ this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING);
4342
+ this._queueCallback(complete, this._element, this._config.animation);
4343
+ }
4344
+ hide() {
4345
+ if (!this.isShown()) {
4346
+ return;
4347
+ }
4348
+ const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE);
4349
+ if (hideEvent.defaultPrevented) {
4350
+ return;
4351
+ }
4352
+ const complete = () => {
4353
+ this._element.classList.add(CLASS_NAME_HIDE); // @deprecated
4354
+ this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW);
4355
+ EventHandler.trigger(this._element, EVENT_HIDDEN);
4356
+ };
4357
+ this._element.classList.add(CLASS_NAME_SHOWING);
4358
+ this._queueCallback(complete, this._element, this._config.animation);
4359
+ }
4360
+ dispose() {
4361
+ this._clearTimeout();
4362
+ if (this.isShown()) {
4363
+ this._element.classList.remove(CLASS_NAME_SHOW);
4364
+ }
4365
+ super.dispose();
4366
+ }
4367
+ isShown() {
4368
+ return this._element.classList.contains(CLASS_NAME_SHOW);
4369
+ }
4370
+
4371
+ // Private
4372
+
4373
+ _maybeScheduleHide() {
4374
+ if (!this._config.autohide) {
4375
+ return;
4376
+ }
4377
+ if (this._hasMouseInteraction || this._hasKeyboardInteraction) {
4378
+ return;
4379
+ }
4380
+ this._timeout = setTimeout(() => {
4381
+ this.hide();
4382
+ }, this._config.delay);
4383
+ }
4384
+ _onInteraction(event, isInteracting) {
4385
+ switch (event.type) {
4386
+ case 'mouseover':
4387
+ case 'mouseout':
4388
+ {
4389
+ this._hasMouseInteraction = isInteracting;
4390
+ break;
4391
+ }
4392
+ case 'focusin':
4393
+ case 'focusout':
4394
+ {
4395
+ this._hasKeyboardInteraction = isInteracting;
4396
+ break;
4397
+ }
4398
+ }
4399
+ if (isInteracting) {
4400
+ this._clearTimeout();
4401
+ return;
4402
+ }
4403
+ const nextElement = event.relatedTarget;
4404
+ if (this._element === nextElement || this._element.contains(nextElement)) {
4405
+ return;
4406
+ }
4407
+ this._maybeScheduleHide();
4408
+ }
4409
+ _setListeners() {
4410
+ EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true));
4411
+ EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false));
4412
+ EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true));
4413
+ EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false));
4414
+ }
4415
+ _clearTimeout() {
4416
+ clearTimeout(this._timeout);
4417
+ this._timeout = null;
4418
+ }
4419
+
4420
+ // Static
4421
+ static jQueryInterface(config) {
4422
+ return this.each(function () {
4423
+ const data = Toast.getOrCreateInstance(this, config);
4424
+ if (typeof config === 'string') {
4425
+ if (typeof data[config] === 'undefined') {
4426
+ throw new TypeError(`No method named "${config}"`);
4427
+ }
4428
+ data[config](this);
4429
+ }
4430
+ });
4431
+ }
4432
+ }
4433
+
4434
+ /**
4435
+ * Data API implementation
4436
+ */
4437
+
4438
+ enableDismissTrigger(Toast);
4439
+
4440
+ /**
4441
+ * jQuery
4442
+ */
4443
+
4444
+ defineJQueryPlugin(Toast);
4445
+
4446
+ export { Alert, Button, Carousel, Collapse, Dropdown, Modal, Offcanvas, Popover, ScrollSpy, Tab, Toast, Tooltip };
4447
+ //# sourceMappingURL=bootstrap.esm.js.map