Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in
Toggle navigation
Menu
Open sidebar
lib
unicaen
app
Commits
47bed7eb
Commit
47bed7eb
authored
Jul 21, 2021
by
Bertrand Gauthier
Browse files
WIP bootstrap 3 => 4
parent
46325956
Pipeline
#10806
passed with stage
in 19 seconds
Changes
152
Pipelines
1
Hide whitespace changes
Inline
Side-by-side
Too many changes to show.
To preserve performance only
20 of 152+
files are displayed.
Plain diff
Email patch
public/unicaen/app/vendor/bootstrap-5.0.2/js/bootstrap.js
0 → 100644
View file @
47bed7eb
Changes suppressed. Click to show.
/*!
* Bootstrap v5.0.2 (https://getbootstrap.com/)
* Copyright 2011-2021 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors)
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
*/
(
function
(
global
,
factory
)
{
typeof
exports
===
'
object
'
&&
typeof
module
!==
'
undefined
'
?
module
.
exports
=
factory
(
require
(
'
@popperjs/core
'
))
:
typeof
define
===
'
function
'
&&
define
.
amd
?
define
([
'
@popperjs/core
'
],
factory
)
:
(
global
=
typeof
globalThis
!==
'
undefined
'
?
globalThis
:
global
||
self
,
global
.
bootstrap
=
factory
(
global
.
Popper
));
}(
this
,
(
function
(
Popper
)
{
'
use strict
'
;
function
_interopNamespace
(
e
)
{
if
(
e
&&
e
.
__esModule
)
return
e
;
var
n
=
Object
.
create
(
null
);
if
(
e
)
{
Object
.
keys
(
e
).
forEach
(
function
(
k
)
{
if
(
k
!==
'
default
'
)
{
var
d
=
Object
.
getOwnPropertyDescriptor
(
e
,
k
);
Object
.
defineProperty
(
n
,
k
,
d
.
get
?
d
:
{
enumerable
:
true
,
get
:
function
()
{
return
e
[
k
];
}
});
}
});
}
n
[
'
default
'
]
=
e
;
return
Object
.
freeze
(
n
);
}
var
Popper__namespace
=
/*#__PURE__*/
_interopNamespace
(
Popper
);
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.0.2): dom/selector-engine.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const
NODE_TEXT
=
3
;
const
SelectorEngine
=
{
find
(
selector
,
element
=
document
.
documentElement
)
{
return
[].
concat
(...
Element
.
prototype
.
querySelectorAll
.
call
(
element
,
selector
));
},
findOne
(
selector
,
element
=
document
.
documentElement
)
{
return
Element
.
prototype
.
querySelector
.
call
(
element
,
selector
);
},
children
(
element
,
selector
)
{
return
[].
concat
(...
element
.
children
).
filter
(
child
=>
child
.
matches
(
selector
));
},
parents
(
element
,
selector
)
{
const
parents
=
[];
let
ancestor
=
element
.
parentNode
;
while
(
ancestor
&&
ancestor
.
nodeType
===
Node
.
ELEMENT_NODE
&&
ancestor
.
nodeType
!==
NODE_TEXT
)
{
if
(
ancestor
.
matches
(
selector
))
{
parents
.
push
(
ancestor
);
}
ancestor
=
ancestor
.
parentNode
;
}
return
parents
;
},
prev
(
element
,
selector
)
{
let
previous
=
element
.
previousElementSibling
;
while
(
previous
)
{
if
(
previous
.
matches
(
selector
))
{
return
[
previous
];
}
previous
=
previous
.
previousElementSibling
;
}
return
[];
},
next
(
element
,
selector
)
{
let
next
=
element
.
nextElementSibling
;
while
(
next
)
{
if
(
next
.
matches
(
selector
))
{
return
[
next
];
}
next
=
next
.
nextElementSibling
;
}
return
[];
}
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.0.2): util/index.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
const
MAX_UID
=
1000000
;
const
MILLISECONDS_MULTIPLIER
=
1000
;
const
TRANSITION_END
=
'
transitionend
'
;
// Shoutout AngusCroll (https://goo.gl/pxwQGp)
const
toType
=
obj
=>
{
if
(
obj
===
null
||
obj
===
undefined
)
{
return
`
${
obj
}
`
;
}
return
{}.
toString
.
call
(
obj
).
match
(
/
\s([
a-z
]
+
)
/i
)[
1
].
toLowerCase
();
};
/**
* --------------------------------------------------------------------------
* Public Util Api
* --------------------------------------------------------------------------
*/
const
getUID
=
prefix
=>
{
do
{
prefix
+=
Math
.
floor
(
Math
.
random
()
*
MAX_UID
);
}
while
(
document
.
getElementById
(
prefix
));
return
prefix
;
};
const
getSelector
=
element
=>
{
let
selector
=
element
.
getAttribute
(
'
data-bs-target
'
);
if
(
!
selector
||
selector
===
'
#
'
)
{
let
hrefAttr
=
element
.
getAttribute
(
'
href
'
);
// The only valid content that could double as a selector are IDs or classes,
// so everything starting with `#` or `.`. If a "real" URL is used as the selector,
// `document.querySelector` will rightfully complain it is invalid.
// See https://github.com/twbs/bootstrap/issues/32273
if
(
!
hrefAttr
||
!
hrefAttr
.
includes
(
'
#
'
)
&&
!
hrefAttr
.
startsWith
(
'
.
'
))
{
return
null
;
}
// Just in case some CMS puts out a full URL with the anchor appended
if
(
hrefAttr
.
includes
(
'
#
'
)
&&
!
hrefAttr
.
startsWith
(
'
#
'
))
{
hrefAttr
=
`#
${
hrefAttr
.
split
(
'
#
'
)[
1
]}
`
;
}
selector
=
hrefAttr
&&
hrefAttr
!==
'
#
'
?
hrefAttr
.
trim
()
:
null
;
}
return
selector
;
};
const
getSelectorFromElement
=
element
=>
{
const
selector
=
getSelector
(
element
);
if
(
selector
)
{
return
document
.
querySelector
(
selector
)
?
selector
:
null
;
}
return
null
;
};
const
getElementFromSelector
=
element
=>
{
const
selector
=
getSelector
(
element
);
return
selector
?
document
.
querySelector
(
selector
)
:
null
;
};
const
getTransitionDurationFromElement
=
element
=>
{
if
(
!
element
)
{
return
0
;
}
// Get transition-duration of the element
let
{
transitionDuration
,
transitionDelay
}
=
window
.
getComputedStyle
(
element
);
const
floatTransitionDuration
=
Number
.
parseFloat
(
transitionDuration
);
const
floatTransitionDelay
=
Number
.
parseFloat
(
transitionDelay
);
// Return 0 if element or transition duration is not found
if
(
!
floatTransitionDuration
&&
!
floatTransitionDelay
)
{
return
0
;
}
// If multiple durations are defined, take the first
transitionDuration
=
transitionDuration
.
split
(
'
,
'
)[
0
];
transitionDelay
=
transitionDelay
.
split
(
'
,
'
)[
0
];
return
(
Number
.
parseFloat
(
transitionDuration
)
+
Number
.
parseFloat
(
transitionDelay
))
*
MILLISECONDS_MULTIPLIER
;
};
const
triggerTransitionEnd
=
element
=>
{
element
.
dispatchEvent
(
new
Event
(
TRANSITION_END
));
};
const
isElement
=
obj
=>
{
if
(
!
obj
||
typeof
obj
!==
'
object
'
)
{
return
false
;
}
if
(
typeof
obj
.
jquery
!==
'
undefined
'
)
{
obj
=
obj
[
0
];
}
return
typeof
obj
.
nodeType
!==
'
undefined
'
;
};
const
getElement
=
obj
=>
{
if
(
isElement
(
obj
))
{
// it's a jQuery object or a node element
return
obj
.
jquery
?
obj
[
0
]
:
obj
;
}
if
(
typeof
obj
===
'
string
'
&&
obj
.
length
>
0
)
{
return
SelectorEngine
.
findOne
(
obj
);
}
return
null
;
};
const
typeCheckConfig
=
(
componentName
,
config
,
configTypes
)
=>
{
Object
.
keys
(
configTypes
).
forEach
(
property
=>
{
const
expectedTypes
=
configTypes
[
property
];
const
value
=
config
[
property
];
const
valueType
=
value
&&
isElement
(
value
)
?
'
element
'
:
toType
(
value
);
if
(
!
new
RegExp
(
expectedTypes
).
test
(
valueType
))
{
throw
new
TypeError
(
`
${
componentName
.
toUpperCase
()}
: Option "
${
property
}
" provided type "
${
valueType
}
" but expected type "
${
expectedTypes
}
".`
);
}
});
};
const
isVisible
=
element
=>
{
if
(
!
isElement
(
element
)
||
element
.
getClientRects
().
length
===
0
)
{
return
false
;
}
return
getComputedStyle
(
element
).
getPropertyValue
(
'
visibility
'
)
===
'
visible
'
;
};
const
isDisabled
=
element
=>
{
if
(
!
element
||
element
.
nodeType
!==
Node
.
ELEMENT_NODE
)
{
return
true
;
}
if
(
element
.
classList
.
contains
(
'
disabled
'
))
{
return
true
;
}
if
(
typeof
element
.
disabled
!==
'
undefined
'
)
{
return
element
.
disabled
;
}
return
element
.
hasAttribute
(
'
disabled
'
)
&&
element
.
getAttribute
(
'
disabled
'
)
!==
'
false
'
;
};
const
findShadowRoot
=
element
=>
{
if
(
!
document
.
documentElement
.
attachShadow
)
{
return
null
;
}
// Can find the shadow root otherwise it'll return the document
if
(
typeof
element
.
getRootNode
===
'
function
'
)
{
const
root
=
element
.
getRootNode
();
return
root
instanceof
ShadowRoot
?
root
:
null
;
}
if
(
element
instanceof
ShadowRoot
)
{
return
element
;
}
// when we don't find a shadow root
if
(
!
element
.
parentNode
)
{
return
null
;
}
return
findShadowRoot
(
element
.
parentNode
);
};
const
noop
=
()
=>
{};
const
reflow
=
element
=>
element
.
offsetHeight
;
const
getjQuery
=
()
=>
{
const
{
jQuery
}
=
window
;
if
(
jQuery
&&
!
document
.
body
.
hasAttribute
(
'
data-bs-no-jquery
'
))
{
return
jQuery
;
}
return
null
;
};
const
DOMContentLoadedCallbacks
=
[];
const
onDOMContentLoaded
=
callback
=>
{
if
(
document
.
readyState
===
'
loading
'
)
{
// add listener on the first call when the document is in loading state
if
(
!
DOMContentLoadedCallbacks
.
length
)
{
document
.
addEventListener
(
'
DOMContentLoaded
'
,
()
=>
{
DOMContentLoadedCallbacks
.
forEach
(
callback
=>
callback
());
});
}
DOMContentLoadedCallbacks
.
push
(
callback
);
}
else
{
callback
();
}
};
const
isRTL
=
()
=>
document
.
documentElement
.
dir
===
'
rtl
'
;
const
defineJQueryPlugin
=
plugin
=>
{
onDOMContentLoaded
(()
=>
{
const
$
=
getjQuery
();
/* istanbul ignore if */
if
(
$
)
{
const
name
=
plugin
.
NAME
;
const
JQUERY_NO_CONFLICT
=
$
.
fn
[
name
];
$
.
fn
[
name
]
=
plugin
.
jQueryInterface
;
$
.
fn
[
name
].
Constructor
=
plugin
;
$
.
fn
[
name
].
noConflict
=
()
=>
{
$
.
fn
[
name
]
=
JQUERY_NO_CONFLICT
;
return
plugin
.
jQueryInterface
;
};
}
});
};
const
execute
=
callback
=>
{
if
(
typeof
callback
===
'
function
'
)
{
callback
();
}
};
const
executeAfterTransition
=
(
callback
,
transitionElement
,
waitForTransition
=
true
)
=>
{
if
(
!
waitForTransition
)
{
execute
(
callback
);
return
;
}
const
durationPadding
=
5
;
const
emulatedDuration
=
getTransitionDurationFromElement
(
transitionElement
)
+
durationPadding
;
let
called
=
false
;
const
handler
=
({
target
})
=>
{
if
(
target
!==
transitionElement
)
{
return
;
}
called
=
true
;
transitionElement
.
removeEventListener
(
TRANSITION_END
,
handler
);
execute
(
callback
);
};
transitionElement
.
addEventListener
(
TRANSITION_END
,
handler
);
setTimeout
(()
=>
{
if
(
!
called
)
{
triggerTransitionEnd
(
transitionElement
);
}
},
emulatedDuration
);
};
/**
* Return the previous/next element of a list.
*
* @param {array} list The list of elements
* @param activeElement The active element
* @param shouldGetNext Choose to get next or previous element
* @param isCycleAllowed
* @return {Element|elem} The proper element
*/
const
getNextActiveElement
=
(
list
,
activeElement
,
shouldGetNext
,
isCycleAllowed
)
=>
{
let
index
=
list
.
indexOf
(
activeElement
);
// if the element does not exist in the list return an element depending on the direction and if cycle is allowed
if
(
index
===
-
1
)
{
return
list
[
!
shouldGetNext
&&
isCycleAllowed
?
list
.
length
-
1
:
0
];
}
const
listLength
=
list
.
length
;
index
+=
shouldGetNext
?
1
:
-
1
;
if
(
isCycleAllowed
)
{
index
=
(
index
+
listLength
)
%
listLength
;
}
return
list
[
Math
.
max
(
0
,
Math
.
min
(
index
,
listLength
-
1
))];
};
/**
* --------------------------------------------------------------------------
* Bootstrap (v5.0.2): dom/event-handler.js
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
* --------------------------------------------------------------------------
*/
/**
* ------------------------------------------------------------------------
* Constants
* ------------------------------------------------------------------------
*/
const
namespaceRegex
=
/
[^
.
]
*
(?=\.
.*
)\.
|.*/
;
const
stripNameRegex
=
/
\.
.*/
;
const
stripUidRegex
=
/::
\d
+$/
;
const
eventRegistry
=
{};
// Events storage
let
uidEvent
=
1
;
const
customEvents
=
{
mouseenter
:
'
mouseover
'
,
mouseleave
:
'
mouseout
'
};
const
customEventsRegex
=
/^
(
mouseenter|mouseleave
)
/i
;
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
'
]);
/**
* ------------------------------------------------------------------------
* Private methods
* ------------------------------------------------------------------------
*/
function
getUidEvent
(
element
,
uid
)
{
return
uid
&&
`
${
uid
}
::
${
uidEvent
++
}
`
||
element
.
uidEvent
||
uidEvent
++
;
}
function
getEvent
(
element
)
{
const
uid
=
getUidEvent
(
element
);
element
.
uidEvent
=
uid
;
eventRegistry
[
uid
]
=
eventRegistry
[
uid
]
||
{};
return
eventRegistry
[
uid
];
}
function
bootstrapHandler
(
element
,
fn
)
{
return
function
handler
(
event
)
{
event
.
delegateTarget
=
element
;
if
(
handler
.
oneOff
)
{
EventHandler
.
off
(
element
,
event
.
type
,
fn
);
}
return
fn
.
apply
(
element
,
[
event
]);
};
}
function
bootstrapDelegationHandler
(
element
,
selector
,
fn
)
{
return
function
handler
(
event
)
{
const
domElements
=
element
.
querySelectorAll
(
selector
);
for
(
let
{
target
}
=
event
;
target
&&
target
!==
this
;
target
=
target
.
parentNode
)
{
for
(
let
i
=
domElements
.
length
;
i
--
;)
{
if
(
domElements
[
i
]
===
target
)
{
event
.
delegateTarget
=
target
;
if
(
handler
.
oneOff
)
{
// eslint-disable-next-line unicorn/consistent-destructuring
EventHandler
.
off
(
element
,
event
.
type
,
selector
,
fn
);
}
return
fn
.
apply
(
target
,
[
event
]);
}
}
}
// To please ESLint
return
null
;
};
}
function
findHandler
(
events
,
handler
,
delegationSelector
=
null
)
{
const
uidEventList
=
Object
.
keys
(
events
);
for
(
let
i
=
0
,
len
=
uidEventList
.
length
;
i
<
len
;
i
++
)
{
const
event
=
events
[
uidEventList
[
i
]];
if
(
event
.
originalHandler
===
handler
&&
event
.
delegationSelector
===
delegationSelector
)
{
return
event
;
}
}
return
null
;
}
function
normalizeParams
(
originalTypeEvent
,
handler
,
delegationFn
)
{
const
delegation
=
typeof
handler
===
'
string
'
;
const
originalHandler
=
delegation
?
delegationFn
:
handler
;
let
typeEvent
=
getTypeEvent
(
originalTypeEvent
);
const
isNative
=
nativeEvents
.
has
(
typeEvent
);
if
(
!
isNative
)
{
typeEvent
=
originalTypeEvent
;
}
return
[
delegation
,
originalHandler
,
typeEvent
];
}
function
addHandler
(
element
,
originalTypeEvent
,
handler
,
delegationFn
,
oneOff
)
{
if
(
typeof
originalTypeEvent
!==
'
string
'
||
!
element
)
{
return
;
}
if
(
!
handler
)
{
handler
=
delegationFn
;
delegationFn
=
null
;
}
// in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position
// this prevents the handler from being dispatched the same way as mouseover or mouseout does
if
(
customEventsRegex
.
test
(
originalTypeEvent
))
{
const
wrapFn
=
fn
=>
{
return
function
(
event
)
{
if
(
!
event
.
relatedTarget
||
event
.
relatedTarget
!==
event
.
delegateTarget
&&
!
event
.
delegateTarget
.
contains
(
event
.
relatedTarget
))
{
return
fn
.
call
(
this
,
event
);
}
};
};
if
(
delegationFn
)
{
delegationFn
=
wrapFn
(
delegationFn
);
}
else
{
handler
=
wrapFn
(
handler
);
}
}
const
[
delegation
,
originalHandler
,
typeEvent
]
=
normalizeParams
(
originalTypeEvent
,
handler
,
delegationFn
);
const
events
=
getEvent
(
element
);
const
handlers
=
events
[
typeEvent
]
||
(
events
[
typeEvent
]
=
{});
const
previousFn
=
findHandler
(
handlers
,
originalHandler
,
delegation
?
handler
:
null
);
if
(
previousFn
)
{
previousFn
.
oneOff
=
previousFn
.
oneOff
&&
oneOff
;
return
;
}
const
uid
=
getUidEvent
(
originalHandler
,
originalTypeEvent
.
replace
(
namespaceRegex
,
''
));
const
fn
=
delegation
?
bootstrapDelegationHandler
(
element
,
handler
,
delegationFn
)
:
bootstrapHandler
(
element
,
handler
);
fn
.
delegationSelector
=
delegation
?
handler
:
null
;
fn
.
originalHandler
=
originalHandler
;
fn
.
oneOff
=
oneOff
;
fn
.
uidEvent
=
uid
;
handlers
[
uid
]
=
fn
;
element
.
addEventListener
(
typeEvent
,
fn
,
delegation
);
}
function
removeHandler
(
element
,
events
,
typeEvent
,
handler
,
delegationSelector
)
{
const
fn
=
findHandler
(
events
[
typeEvent
],
handler
,
delegationSelector
);
if
(
!
fn
)
{
return
;
}
element
.
removeEventListener
(
typeEvent
,
fn
,
Boolean
(
delegationSelector
));
delete
events
[
typeEvent
][
fn
.
uidEvent
];
}
function
removeNamespacedHandlers
(
element
,
events
,
typeEvent
,
namespace
)
{
const
storeElementEvent
=
events
[
typeEvent
]
||
{};
Object
.
keys
(
storeElementEvent
).
forEach
(
handlerKey
=>
{
if
(
handlerKey
.
includes
(
namespace
))
{
const
event
=
storeElementEvent
[
handlerKey
];
removeHandler
(
element
,
events
,
typeEvent
,
event
.
originalHandler
,
event
.
delegationSelector
);
}