!(function () {
	// Strict mode
	"use strict";

	/**
	 * @type {Function} Main function
	 * @param {Window} _w Window object
	 * @param {Document} _d Document object
	 * @param {HTMLHtmlElement} _r Root element object
	 * @param {HTMLBodyElement} _b Body element object
	 */
	const main = function (_w, _d, _r, _b) {
		//* handle clicks and scroll on webpage
		const sliderHandler = (function (sliderElements) {
			/**
			 * @type {Function}
			 * @param {HTMLElement} sliderElement
			 * @param {HTMLButtonElement} btnPrev
			 * @param {HTMLButtonElement} btnNext
			 * @param {HTMLElement} sliderTrack
			 * @param {NodeListOf<HTMLElement>} slidesArray
			 * @param {Number} slideDuration
			 * @param {Number} slideDelay
			 */
			const slider = function (
				sliderElement,
				btnPrev,
				btnNext,
				sliderTrack,
				slidesArray,
				slideDuration,
				slideDelay
			) {
				const sliderLoop = function (/** @type {Number} */ slide) {
					if (slide < 1) {
						slide = slidesArray.length;
					} else if (slide > slidesArray.length) {
						slide = 1;
					}

					return slide;
				};

				// slider controls
				const allowTouch =
					sliderElement.getAttribute("data-slider-swipable")?.toLowerCase() === "true" || false;
				const allowControl =
					sliderElement.getAttribute("data-slider-controls")?.toLowerCase() === "true" || false;
				const transitionMode = sliderElement.getAttribute("data-slider-transition")?.toLowerCase();

				const slide = (function () {
					let currentSlide = 1;
					let slideDebounce;

					const setSlide = function (/** @type {String|Number} */ input) {
						currentSlide = sliderLoop(Number(input));

						slidesArray.forEach((slide, index) => {
							if (!(slide instanceof HTMLElement)) return;

							if (index === currentSlide - 1) {
								slide.classList.add("active");
								slide.removeAttribute("tabindex");
								slide.querySelectorAll(":any-link, button, input, [tabindex]").forEach((element) => {
									element.removeAttribute("tabindex");
								});
							} else {
								slide.classList.remove("active");
								slide.querySelectorAll(":any-link, button, input, [tabindex]").forEach((element) => {
									element.setAttribute("tabindex", "-1");
								});
							}
						});

						sliderElement.setAttribute("data-current-slide", String(currentSlide));
						sliderElement.style.setProperty("--current-slide", String(currentSlide));
					};

					return {
						set: function (/** @type {Number} */ input) {
							setSlide(input);
						},
						prev: function () {
							if (!slideDebounce) {
								sliderElement.classList.add("animate-prev");
								slideDebounce = setTimeout(() => {
									slideDebounce = null;
									setSlide(currentSlide - 1);
									sliderElement.classList.remove("animate-prev");
								}, slideDuration * 1.125);
							}
						},
						next: function () {
							if (!slideDebounce) {
								sliderElement.classList.add("animate-next");
								slideDebounce = setTimeout(() => {
									slideDebounce = null;
									setSlide(currentSlide + 1);
									sliderElement.classList.remove("animate-next");
								}, slideDuration * 1.125);
							}
						},
					};
				})();

				// add event listeners to slider buttons
				btnPrev.addEventListener("click", () => slide.prev());
				btnNext.addEventListener("click", () => slide.next());

				// slider setup
				(() => {
					if (transitionMode !== "fade") {
						const lastItemClone = slidesArray[slidesArray.length - 1].cloneNode(true);
						const secondLastItemClone = slidesArray[slidesArray.length - 2].cloneNode(true);
						const firstItemClone = slidesArray[0].cloneNode(true);
						const secondItemClone = slidesArray[1].cloneNode(true);

						if (
							lastItemClone instanceof HTMLElement &&
							secondLastItemClone instanceof HTMLElement &&
							firstItemClone instanceof HTMLElement &&
							secondItemClone instanceof HTMLElement
						) {
							lastItemClone.classList.add("clone");
							secondLastItemClone.classList.add("clone");
							firstItemClone.classList.add("clone");
							secondItemClone.classList.add("clone");
						}

						sliderTrack.append(firstItemClone, secondItemClone);
						sliderTrack.prepend(secondLastItemClone, lastItemClone);
					} else {
						const firstItemClone = slidesArray[0].cloneNode(true);

						if (firstItemClone instanceof HTMLElement) firstItemClone.classList.add("clone");

						sliderTrack.append(firstItemClone);
					}

					sliderTrack.querySelectorAll("img, :any-link").forEach((image) => {
						image.setAttribute("draggable", String(false));
					});

					sliderElement
						.querySelectorAll(".clone :any-link, .clone button, .clone input, .clone [tabindex]")
						.forEach((element) => {
							element.setAttribute("tabindex", "-1");
						});
				})();

				// slider mobile touch
				let isTouch = false;
				let isDragging = false;
				let isPressing = false;
				let startPosX = 0;
				let movement = 0;
				const isMobile = () => {
					return allowTouch && _r.clientWidth < 744;
				};

				if (!allowControl || slideDelay > 0) {
					const automaticSlide = () => {
						setTimeout(() => {
							slide.next();
							automaticSlide();
						}, Number(Math.max(slideDuration, slideDelay)) + Number(slideDuration));
					};
					automaticSlide();
				}

				if (allowControl) {
					["mousedown", "touchstart"].forEach((eventType) => {
						sliderTrack.addEventListener(eventType, (event) => {
							if (!isMobile()) return;

							if (event instanceof MouseEvent) {
								isTouch = false;
								startPosX = event.clientX;
							}
							if (window.TouchEvent && event instanceof TouchEvent) {
								isTouch = true;
								startPosX = event.targetTouches.item(0)?.clientX ?? 0;
							}
							isPressing = true;
						});
					});

					["click", "contextmenu"].forEach((eventType) => {
						sliderTrack.addEventListener(eventType, () => {
							isPressing = false;
						});
					});

					["mousemove", "touchmove"].forEach((eventType) => {
						sliderTrack.addEventListener(eventType, (event) => {
							if (!isMobile() || !isPressing) return;

							if (!isTouch && event instanceof MouseEvent) {
								startSliderDrag(event.clientX);
							}
							if (isTouch && window.TouchEvent && event instanceof TouchEvent) {
								startSliderDrag(event.targetTouches.item(0)?.clientX ?? 0);
							}
							isDragging = true;
						});
					});

					["mouseup", "mouseleave", "touchend", "touchcancel"].forEach((eventType) => {
						sliderTrack.addEventListener(eventType, () => {
							if (!isMobile() || !isDragging || !isPressing) return;

							sliderTrack.classList.add("transition");
							sliderTrack.style.transform = "";
							if (movement > 17.5) slide.prev();
							if (movement < -17.5) slide.next();
							setTimeout(() => sliderTrack.classList.remove("transition"), slideDuration);
							isDragging = false;
							isPressing = false;
						});
					});

					/**
					 * @type {Function}
					 * @param {Number} posX
					 */
					const startSliderDrag = (posX) => {
						movement = Number(((posX - startPosX) / _r.clientWidth).toFixed(5)) * 50;
						if (Math.abs(movement) < 50) sliderTrack.style.transform = `translateX(${movement}%)`;
					};
				} else {
					btnPrev.remove();
					btnNext.remove();
				}

				// slider setup
				sliderElement.style.setProperty("--slider-duration", `${slideDuration}ms`);
				sliderElement.style.setProperty("--slide-offset", `2`);
				slide.set(1);
			};

			sliderElements.forEach((sliderElement) => {
				if (sliderElement instanceof HTMLElement) {
					const slideDuration = sliderElement.getAttribute("data-slider-duration") || 500;
					const slideDelay = sliderElement.getAttribute("data-slider-delay") || 0;
					const btnPrev = sliderElement.querySelector(":scope > .slider-button-prev");
					const btnNext = sliderElement.querySelector(":scope > .slider-button-next");
					const sliderTrack = sliderElement.querySelector(":scope > .slider-track");
					const slidesArray = sliderElement.querySelectorAll(":scope > .slider-track > .slider-item");
					if (btnPrev && btnNext && sliderTrack && slidesArray)
						slider(sliderElement, btnPrev, btnNext, sliderTrack, slidesArray, slideDuration, slideDelay);
				}
			});
		})(_d.querySelectorAll(".slider-element")); /**/

		const accordionHandler = (function (accordionElements) {
			const setAccordionItem = function (button, collapse, state) {
				// toggle button attributes
				button.setAttribute("aria-expanded", String(state));
				// toggle collapse attributes
				collapse.setAttribute("aria-hidden", String(!state));
				// toggle collapse attributes
				collapse.setAttribute("data-state", "");
			};

			/**
			 * @type {Function}
			 * @param {HTMLElement} accordion
			 * @param {NodeListOf<HTMLElement>} array
			 * @param {HTMLElement} item
			 */
			const toggleAccordion = function (accordion, array, item) {
				array.forEach((accordionItem) => {
					if (
						!accordion.parentElement?.classList.contains("accordion-single") &&
						accordionItem !== item.parentElement
					)
						return;

					const button = accordionItem.querySelector(":scope > .accordion-header > .accordion-button");
					const collapse = accordionItem.querySelector(":scope > .accordion-collapse");

					if (!(button instanceof HTMLButtonElement && collapse instanceof HTMLElement)) return;

					const state = function () {
						return accordion === accordionItem && button.getAttribute("aria-expanded") === "false";
					};

					setAccordionItem(button, collapse, state());
				});
			};

			// initialize all accordions
			accordionElements.forEach((accordionElement) => {
				if (!(accordionElement instanceof HTMLElement)) return;

				const accordionArray = accordionElement.querySelectorAll(":scope > .accordion-item");

				accordionArray.forEach((accordionItem) => {
					const button = accordionItem.querySelector(":scope > .accordion-header > .accordion-button");
					const collapse = accordionItem.querySelector(":scope > .accordion-collapse");

					if (!(button instanceof HTMLButtonElement && collapse instanceof HTMLElement)) return;

					button.addEventListener("click", () => {
						const controlElem = _d.getElementById(String(button.getAttribute("aria-controls")));
						if (!(controlElem instanceof HTMLElement)) return;

						toggleAccordion(accordionItem, accordionArray, controlElem);
					});

					// update collapse height on resize and on init
					let lastScrollHeight = 0;
					new ResizeObserver(() => {
						if (lastScrollHeight !== collapse.scrollHeight) {
							collapse.style.setProperty("--item-height", `${collapse.scrollHeight}px`);
						}
						lastScrollHeight = collapse.scrollHeight;
					}).observe(collapse);
				});
			});
		})(_d.querySelectorAll(".accordion"));
	};

	// Run main function when DOM is loaded
	main(window, document, document.documentElement, document.body);

	// End of script
	return 0;
})();

void (() => {
	// Strict mode
	"use strict";

	/**
	 * @type {Function} Main function
	 * @param {Window} _w Window object
	 * @param {Document} _d Document object
	 * @param {HTMLHtmlElement} _r Root element object
	 * @param {HTMLBodyElement} _b Body element object
	 */
	const main = function (_w, _d, _r, _b) {
		/** @module site Function to return all needed DOM landmark elements */
		const site = (() => {
			/** @param {String} id Id of the element to fetch from DOM */
			const getLandmarkElement = function (id) {
				const element = _d.getElementById(id) || _d.createElement("NOT-FOUND");
				if (element.tagName === "NOT-FOUND") {
					_r.classList.add(`no-${id.toLowerCase()}`);
					// eslint-disable-next-line no-console
					console.warn(`Warning:\tLandmark element with id "${id}" not found.`);
				}
				return element;
			};

			const config = {
				transitionDuration: 0,
			};

			return {
				landmarks: {
					header: getLandmarkElement("header"),
					hero: getLandmarkElement("hero"),
					content: getLandmarkElement("content"),
					footer: getLandmarkElement("footer"),
				},
				config: {
					/**
					 * @param {String} input Config to adjust
					 * @param {any} value Value to pass through
					 */
					set: (input, value) => {
						config[input] = value;
					},
					/**
					 * @param {String} input Config to return
					 */
					get: (input) => config[input],
				},
			};
		})(); /**/
		// Throw error and stop script execution if element in site.landmarks
		if (Object.values(site.landmarks).some((element) => element.tagName === "NOT-FOUND")) {
			// eslint-disable-next-line no-console
			console.error("Error:\tCould not find landmark element(s) from site Object in DOM!");
			return;
		}

		/** @module matchMedia Use Media Queries instead of resize events */
		const matchMedia = (() => {
			const mediaQueries = {
				sm: "540px",
				md: "744px",
				lg: "960px",
				xl: "1260px",
				xxl: "1620px",
			};

			/**
			 * @type {function} Evaluate Media Query
			 * @param {String} media Media Query in px
			 * @returns {MediaQueryList}
			 */
			const mediaQuery = function (media) {
				return _w.matchMedia(`(min-width: ${mediaQueries[media] || "-1px"})`);
			};

			/**
			 * @param {Function} func Function to add the event listener
			 * @param {String} media Media Query on which to add the function to
			 */
			const addMediaQueryListener = function (func, media) {
				mediaQuery(media).addEventListener("change", func);
			};

			/**
			 * @param {Function} func Function to remove the event listener
			 * @param {String} media Media Query on which to remove the function from
			 */
			const removeMediaQueryListener = function (func, media) {
				mediaQuery(media).removeEventListener("change", func);
			};

			return {
				/**
				 * @param {Function} func Function to remove the event listener
				 * @param {String} media Media Query on which to add the function to
				 */
				add: function (func, media) {
					addMediaQueryListener(func, media);
				},
				/**
				 * @param {Function} func Function to remove the event listener
				 * @param {String} media Media Query on which to remove the function from
				 */
				remove: function (func, media) {
					removeMediaQueryListener(func, media);
				},
				/**
				 * @param {String} media Media Query to evaluate
				 * @return {Boolean}
				 */
				match: function (media) {
					return mediaQuery(media).matches;
				},
			};
		})(); /**/

		/** @module ariaFunction All WAI-ARIA code belongs here */
		const ariaFunction = (() => {
			/**
			 * @type {function} Find all focussable Elements
			 * @param {HTMLElement} startingNode (Optional) Node in which to start searching for focussable elements
			 * @returns {Array<Element>}
			 */
			const getFocusElems = function (startingNode = _b) {
				return Array.from(
					startingNode.querySelectorAll(":any-link, button, input, select, textarea, [tabindex]")
				).filter((element) => {
					const unfocussable = "[disabled], [aria-disabled='true'], [aria-hidden='true']";
					if (!element.matches(`${unfocussable}, [tabindex='-1']`) && !element.closest(unfocussable))
						return element;
				});
			};

			const menuFunction = function (menuButtons) {
				/**
				 * @type {Function}
				 * @param {HTMLElement} menu
				 * @param {Boolean} override
				 * @param {Function} callback
				 * @param {Boolean} multi
				 * @param {HTMLElement} btn
				 */
				const toggleMenu = function (menu, override, callback, multi = false, btn) {
					if (!(menu instanceof HTMLElement)) return;

					// boolean if menu is to be opened or not
					const openMenu = override ?? menu.getAttribute("data-menu-open") !== "true";

					// toggle all menu controllers
					_d.querySelectorAll(`[aria-controls="${menu.id}"]`).forEach((menuController) => {
						if (!(menuController instanceof HTMLElement)) return;
						// set attribute
						menuController.setAttribute("aria-expanded", String(openMenu));
					});

					// set attributes and classes
					menu.setAttribute("aria-hidden", String(!openMenu));
					menu.setAttribute("data-menu-open", String(openMenu));

					// open menu modal
					if (btn && String(btn.getAttribute("data-menu-modal")).toLowerCase() === "true") {
						_r.style.overflow = openMenu ? "hidden" : "";
					}

					// if element is of type collapse (aka has class "collapse")
					if (menu.classList.contains("collapse")) {
						// set height and add transition class
						menu.style.setProperty("height", `${menu.scrollHeight}px`);
						menu.classList.add("transition");
						// start opening transition and focus first element inside
						setTimeout(() => {
							menu.classList.toggle("open", openMenu);
							if (openMenu)
								getFocusElems(menu)[0]?.focus({
									preventScroll: true,
								});
						}, 0);
						// remove height and class after transition is finished
						setTimeout(
							() => {
								menu.style.setProperty("height", "");
								menu.classList.remove("transition");
							},
							openMenu ? 325 : 0
						);
					}

					// if element is subnav
					if (String(menu.getAttribute("data-menu-type")).toLowerCase() === "subnav") {
						if (openMenu && ariaFunction.focussableElements(menu).length)
							ariaFunction.focussableElements(menu)[0].focus({ preventScroll: true });
					}

					// run callback function if one exists
					if (callback && typeof callback === "function") callback(openMenu);
				};

				menuButtons.forEach((button) => {
					if (button instanceof HTMLButtonElement) {
						const controlElem = _d.getElementById(`${button.getAttribute("aria-controls")}`);
						if (!controlElem) return;

						button.addEventListener("click", () => toggleMenu(controlElem, null, null, null, button));

						matchMedia.add(() => toggleMenu(controlElem, false), "lg");
					}
				});
			};
			menuFunction(_d.querySelectorAll("button[aria-controls]:not([aria-controls='']):not(.accordion-button)"));

			const disabledLinks = function (links) {
				links.forEach((link) => {
					if (link instanceof HTMLAnchorElement) {
						// link.title = `${link.title} (deaktiviert)`;
						link.addEventListener("click", (event) => {
							event.preventDefault();
							event.stopPropagation();
							event.stopImmediatePropagation();
							return false;
						});
					}
				});
			};
			disabledLinks(_d.querySelectorAll("a:is([disabled], [aria-disabled='true'])"));

			return {
				/**
				 * @param {HTMLElement} startingNode Node in which to start searching for focussable elements
				 * @return {Array<HTMLElement>}
				 */
				focussableElements: function (startingNode = _b) {
					return getFocusElems(startingNode);
				},
			};
		})(); /**/

		/** @module scrollFunction Code related to scroll events and functions */
		const scrollFunction = (() => {
			/**
			 * @type {Function} Throttled scroll event function
			 */
			const scrollEvent = function () {
				// run all registered scroll event functions
				if (scrollEventFunctions.length)
					scrollEventFunctions.forEach((obj) => {
						obj.func();
					});
			};

			/** @type {{elem: HTMLElement, func: Function}[]} list of all functions to run on scroll */
			const scrollEventFunctions = [];

			const scrollPos = { x: 0, y: 0 };
			let throttleNextScrollEvent = false;
			_d.addEventListener("scroll", () => {
				// set scroll position
				scrollPos.x = _w.scrollX;
				scrollPos.y = _w.scrollY;

				// throttled scroll events
				if (!throttleNextScrollEvent) {
					throttleNextScrollEvent = true;
					_w.requestAnimationFrame(() => {
						scrollEvent();
						throttleNextScrollEvent = false;
					});
				}
			});

			return {
				/** @return {{x: number, y: number}} */
				currentPosition: () => {
					return scrollPos;
				},
				/**
				 * @param {HTMLElement} element
				 * @param {Function} func
				 */
				add: (element, func) => {
					if (scrollEventFunctions.findIndex((obj) => obj.elem === element) >= 0) {
						return;
					}
					scrollEventFunctions.push({
						elem: element,
						func: () => func(element),
					});
					scrollEvent();
				},
				/** @param {HTMLElement} element */
				remove: (element) => {
					if (scrollEventFunctions.findIndex((obj) => obj.elem === element) < 0) {
						return;
					}
					scrollEventFunctions.splice(
						scrollEventFunctions.findIndex((obj) => obj.elem === element),
						1
					);
				},
			};
		})(); /**/

		/** Animate content elements on page load */
		void (function contentAnimations() {
			void (function contentScroll() {
				// make content elements fade in when visible in viewport
				const animDuration = site.config.get("transitionDuration") || 375;
				let elementAnimateIOCount = 0;
				const elementAnimateIO = new IntersectionObserver(
					(entries, observer) => {
						entries.forEach((entry) => {
							if (!(entry.target instanceof HTMLElement && entry.isIntersecting)) return;
							entry.target.style.opacity = "";
							entry.target.style.transform = "";
							setTimeout(() => {
								entry.target.removeAttribute("style");
							}, animDuration);
							// unobserve already faded in elements
							observer.unobserve(entry.target);
							elementAnimateIOCount--;
						});
						// if nothing is observed, disconnect the observer
						if (elementAnimateIOCount <= 0) elementAnimateIO.disconnect();
					},
					{ rootMargin: "-6.75% 0%" }
				);

				_d.querySelectorAll("#content > .frame-section > * > *").forEach((contentElement) => {
					if (contentElement instanceof HTMLElement) {
						contentElement.style.opacity = "0";
						contentElement.style.transform = "translateY(2.5vh)";
						contentElement.style.transition = `opacity ${animDuration}ms ease, transform ${animDuration}ms ease`;
						elementAnimateIO.observe(contentElement);
						elementAnimateIOCount++;
					}
				});
			})();
		})(); /**/

		/** Add parallax effect to certain media elements */
		void (function parallaxFunction() {
			void (function media() {
				/**
				 * Calculate media parallax
				 * @type {Function}
				 * @param {HTMLElement} element Element to calculate parallax for
				 */
				const mediaParallax = function (element) {
					if (!(element instanceof HTMLElement)) return;

					// set up variables
					const parallaxScalar = 0.175;
					const parallaxScaling = 100 + 100 * parallaxScalar;
					const elementVertCenter = element.getBoundingClientRect().top + element.clientHeight / 2;
					const screenVertCenter = _r.clientHeight / 2;
					let value = ((elementVertCenter + screenVertCenter) / _r.clientHeight - 1) * 100 * -parallaxScalar;

					// set css transformation
					element.style.transform = `translateZ(0) translateY(${value}vh) scale(${parallaxScaling}%)`;
				};

				// set up intersection observer
				const io = new IntersectionObserver((entries) => {
					entries.forEach((entry) => {
						if (!(entry.target instanceof HTMLElement)) return;
						if (entry.isIntersecting) {
							scrollFunction.add(entry.target, (input) => mediaParallax(input));
						} else {
							scrollFunction.remove(entry.target);
						}
					});
				});
				// attach parallax behavior to every object with given class
				_d.querySelectorAll(":is(.parallax-media) :is(img, video):not(#hero *)").forEach((mediaElement) => {
					if (mediaElement instanceof HTMLElement) {
						mediaParallax(mediaElement);
						io.observe(mediaElement);
					}
				});
			})();
		})(); /**/

		/** Handle clicks and scroll on webpage */
		void (function clickHandling() {
			/**
			 * @type {Function} Scroll Handler
			 * @param {String} hash Element Id
			 */
			const scrollToHash = function (hash) {
				// define bool for state of scroll
				let handledScroll = false;
				void (() => {
					if (typeof hash !== "string" || !hash.length) return;
					// get element from hash
					const hashElement = _d.getElementById(hash.replace("#", ""));
					if (hashElement === null) return;
					// scroll to element and set flag
					hashElement.scrollIntoView();
					handledScroll = true;
				})();
				// go to top if scroll has not yet been handled
				if (!handledScroll) _w.scrollTo({ top: 0 });
			};

			// scroll on load and hashchange
			if (location.hash) scrollToHash(location.hash);
			//_w.addEventListener("hashchange", () => scrollToHash(location.hash));

			// link handler
			_d.querySelectorAll(":any-link[href]:not([href=''])").forEach((linkElement) => {
				if (!(linkElement instanceof HTMLAnchorElement)) return;

				const url = new URL(linkElement.href);
				if (url.hostname !== _w.location.hostname || url.pathname.includes("/fileadmin")) {
					linkElement.target = "_blank";
				}
			});

			// link click handling
			_d.querySelectorAll(":any-link[href^='/'], :any-link[href*='#']").forEach((linkElement) => {
				linkElement.addEventListener("click", function (event) {
					if (!(linkElement instanceof HTMLAnchorElement)) return;

					// new URL object from link href and check if current page is targeted
					const url = new URL(linkElement.href);
					if (url.pathname !== _w.location.pathname || url.search !== _w.location.search) return;

					// scroll to hash instead of unloading page
					event.preventDefault();
					scrollToHash(String(url.hash));

					// focus element and push history state
					if (_d.activeElement instanceof HTMLElement) _d.activeElement.blur();
					history.pushState({}, "", url.hash);
				});
			});
		})(); /**/

		/** Code that runs ONCE on page load */
		void (function startupFunction() {
			// remove no-js class from root element
			_r.setAttribute("data-loaded", "true");

			// set transitionsDuration config
			_r.style.setProperty("transition-duration", "var(--transition__duration)");
			const transitionDuration = parseFloat(getComputedStyle(_r).transitionDuration) * 1000;
			site.config.set("transitionDuration", transitionDuration * 2);
			// remove style
			_r.style.removeProperty("transition-duration");
			if (!_r.style.length) _r.removeAttribute("style");

			// add scroll event for header
			scrollFunction.add(_r, () => {
				_r.setAttribute(
					"data-user-progressed",
					scrollFunction.currentPosition().y > site.landmarks.header.clientHeight / 2 ? "true" : "false"
				);
			});

			const mainNav = _d.getElementById("main-nav");
			const mainNavList = mainNav?.firstElementChild;
			if (mainNav && mainNavList) {
				mainNavList.addEventListener("scroll", () => {
					mainNav.toggleAttribute("data-before-hint", mainNavList.scrollTop > 24);
					mainNav.toggleAttribute(
						"data-after-hint",
						mainNavList.scrollTop < mainNavList.scrollHeight - mainNav.scrollHeight
					);
				});
				mainNav.setAttribute("data-after-hint", "");
			}

			// move all script elements to head
			_b.querySelectorAll(":scope > script").forEach((scriptElement) => _d.head.append(scriptElement));
		})(); /**/
	};

	// Run main function when DOM is loaded
	document.addEventListener("DOMContentLoaded", () => {
		main(window, document, document.documentElement, document.body);

		//* jQuery code
		((jq) => {
			if (!jq) return;

			// Fancybox code
			jq.extend(jq.fancybox.defaults, {
				//touch: false,
				smallBtn: false,
				//clickContent: false,
				//clickSlide: false,
				//clickOutside: false,
				buttons: ["close"],
			});

			jq(".fancybox").fancybox({
				selector: "a.fancybox",
				caption: (instance, current) => {
					return (
						current.opts.$orig.find(".caption").html() ||
						current.opts.$orig.next("figcaption").find("span").html() ||
						current.opts.$orig.find("img").attr("alt") ||
						current.opts.$orig.find("img").attr("title") ||
						""
					);
				},
				afterLoad: (instance, current) => {
					current.$image.attr("alt", current.opts.$orig.find("img").attr("alt"));
					current.$image.attr("title", current.opts.$orig.find("img").attr("title"));
				},
				thumbs: {
					autoStart: true,
				},
			});
			// @ts-ignore
			// eslint-disable-next-line no-undef
		})(jQuery); /**/
	});
})();