mp-design-system 2.0.43 → 2.0.44

package/dist/assets/js/mp-www.js

@@ -0,0 +1,875 @@
+(() => {
+  // src/assets/js/imports/accordion.js
+  function Accordion() {
+    const accordions = Array.from(document.querySelectorAll(".c-accordion__title"));
+    accordions.forEach(setupAccordions);
+  }
+  function setupAccordions(title) {
+    title.addEventListener("click", titleClick());
+  }
+  function titleClick() {
+    return (event) => {
+      var item = event.currentTarget.parentElement;
+      item.classList.toggle("c-accordion__item--open");
+    };
+  }
+  var accordion_default = Accordion;
+
+  // src/assets/js/imports/carousel.js
+  function Carousel() {
+    let current = 0;
+    const bgSlides = document.querySelectorAll(".c-hero__image-bg");
+    const fgSlides = document.querySelectorAll(".c-hero__image-fg");
+    if (fgSlides.length > 0) {
+      setInterval(() => {
+        for (var bgSlide of bgSlides) {
+          bgSlide.style.opacity = 0;
+        }
+        current = current != bgSlides.length - 1 ? current + 1 : 0;
+        bgSlides[current].style.opacity = 1;
+        for (var fgSlide of fgSlides) {
+          fgSlide.style.opacity = 0;
+        }
+        fgSlides[current].style.opacity = 1;
+      }, 5e3);
+    }
+  }
+  var carousel_default = Carousel;
+
+  // src/assets/js/imports/clear-form.js
+  function ClearForm() {
+    const formClear = document.getElementById("clearForm");
+    if (formClear) {
+      formClear.addEventListener("click", function() {
+        const fields = this.closest("form").elements;
+        fields.forEach((field) => {
+          if (field.value != "") {
+            if (field.type.toLowerCase() == "text" || field.type.toLowerCase() == "email" || field.type.toLowerCase() == "tel" || field.type.toLowerCase() == "select-one" || field.type.toLowerCase() == "textarea") {
+              field.value = "";
+              return;
+            } else if (field.type.toLowerCase() == "checkbox") {
+              field.checked = false;
+              return;
+            }
+          }
+        });
+      });
+    }
+    ;
+  }
+  var clear_form_default = ClearForm;
+
+  // src/assets/js/imports/comparison.js
+  function Comparison() {
+    document.querySelectorAll(".c-comparison-table").forEach(extractMobileComparison);
+  }
+  function extractMobileComparison(container) {
+    const parent = container.parentNode.parentNode;
+    const body = parent.querySelector(".c-comparison-table tbody");
+    const head = parent.querySelector(".c-comparison-table thead");
+    const mobile = parent.parentElement.querySelector(".c-comparison-table__mobile");
+    if (!body || !head || !mobile) return;
+    const productsInfo = Array.from(head.children[0].children).filter((x, i) => i).map((x) => ({ info: x.innerHTML }));
+    const productsButtons = Array.from(head.children[1].children).filter((x, i) => i).map((x) => ({ buttons: x.innerHTML }));
+    const products = productsInfo.map((info, index) => ({ ...info, ...productsButtons[index], table: [] }));
+    Array.from(body.children).forEach((row) => {
+      if (row.classList.contains("c-comparison-table__title")) {
+        products.forEach((x) => {
+          x.table.push({ type: "title", title: row.children[0].textContent });
+        });
+      } else {
+        const cells = Array.from(row.children);
+        const firstCell = cells.shift();
+        cells.forEach((el, index) => {
+          products[index].table.push({
+            type: "row",
+            key: firstCell.textContent,
+            value: el.innerHTML
+          });
+        });
+      }
+    });
+    products.forEach((product) => {
+      const el = createMobileProduct(product);
+      mobile.appendChild(el);
+    });
+  }
+  function createMobileProduct(product) {
+    const parent = document.createElement("article");
+    parent.innerHTML = `${product.info}${product.buttons}
+  <table class="c-comparison-table">
+    ${product.table.map((x) => {
+      if (x.type === "title") {
+        return `<tr class="c-comparison-table__title"><th><span>${x.title}</span></th><th></th></tr>`;
+      } else {
+        return `<tr>
+          <td>${x.key}</td>
+          <td>${x.value}</td>
+        </tr>`;
+      }
+    }).join("")}
+  </table>`;
+    return parent;
+  }
+  var comparison_default = Comparison;
+
+  // src/assets/js/imports/facet.js
+  function Facet() {
+    const facetAccordions = Array.from(document.querySelectorAll(".c-facet__toggle"));
+    facetAccordions.forEach(setupFacetAccordions);
+  }
+  function setupFacetAccordions(toggle) {
+    toggle.addEventListener("click", titleClick2());
+  }
+  function titleClick2() {
+    return (event) => {
+      event.preventDefault();
+      var toggle = event.currentTarget;
+      var facet = toggle.parentElement;
+      facet.classList.toggle("c-facet--open");
+      const expanded = facet.classList.contains("c-facet--open") ? "true" : "false";
+      toggle.setAttribute("aria-expanded", expanded);
+    };
+  }
+  var facet_default = Facet;
+
+  // src/assets/js/imports/gallery.js
+  function Gallery() {
+    const mainSlides = document.querySelectorAll(".c-gallery__main .c-gallery__slide");
+    const thumbnailSlides = document.querySelectorAll(".c-gallery__thumbnails .c-gallery__slide");
+    thumbnailSlides.forEach((thumbnailSlide) => thumbnailSlide.addEventListener("click", function(e) {
+      thumbnailSlides.forEach(function(thumbnail) {
+        if (thumbnail != e.target.parentNode) {
+          thumbnail.classList.remove("active");
+        }
+      });
+      e.target.parentNode.classList.add("active");
+      mainSlides.forEach(function(mainSlide) {
+        if (mainSlide.dataset.slide == thumbnailSlide.dataset.slide) {
+          mainSlide.classList.add("active");
+        } else {
+          mainSlide.classList.remove("active");
+        }
+      });
+    }));
+    mainSlides.forEach(function(mainSlide) {
+      if (!mainSlide.classList.contains("c-gallery__video")) {
+        mainSlide.addEventListener("click", lightboxTrigger);
+      }
+    });
+    function lightboxTrigger() {
+      const lightbox = document.querySelector(".c-gallery__main").cloneNode(true);
+      lightbox.classList.remove("c-gallery__main");
+      lightbox.classList.add("c-lightbox");
+      lightbox.querySelectorAll(".c-gallery__slide").forEach(function(slide) {
+        if (slide.classList.contains("c-gallery__video")) {
+          slide.remove();
+        }
+        if (!slide.classList.contains("c-gallery__video")) {
+          var slideImg = slide.querySelector("img");
+          if (slideImg.srcset != "") {
+            slideImg.removeAttribute("srcset");
+          }
+          var slideImgSrc = slideImg.getAttribute("src");
+          if (slideImgSrc) {
+            if (slideImgSrc.indexOf("?") !== -1) {
+              slideImg.setAttribute("src", slideImgSrc.split("?")[0] + "?quality=90&width=2176");
+            } else {
+              slideImg.setAttribute("src", slideImgSrc + "?quality=90&width=2176");
+            }
+          } else {
+            console.log(slideImg);
+            console.log("has no src defined...");
+          }
+        }
+        slide.classList.add("c-lightbox__slide");
+        slide.classList.remove("c-gallery__slide");
+      });
+      document.body.appendChild(lightbox);
+      lightbox.insertAdjacentHTML("beforeend", '<a class="c-lightbox__prev"></a><a class="c-lightbox__next"></a>');
+      lightbox.querySelector(".c-lightbox__prev").addEventListener("click", function() {
+        const lightboxActive = lightbox.querySelector(".active");
+        const prevImage = lightbox.querySelector('[data-slide="' + (parseInt(lightboxActive.dataset.slide) - 1) + '"]');
+        if (prevImage != null) {
+          lightboxActive.classList.remove("active");
+          prevImage.classList.add("active");
+        }
+      });
+      lightbox.querySelector(".c-lightbox__next").addEventListener("click", function() {
+        const lightboxActive = lightbox.querySelector(".active");
+        const nextImage = lightbox.querySelector('[data-slide="' + (parseInt(lightboxActive.dataset.slide) + 1) + '"]');
+        if (nextImage != null) {
+          lightboxActive.classList.remove("active");
+          nextImage.classList.add("active");
+        }
+      });
+      lightbox.addEventListener("click", function(e) {
+        if (e.target !== e.currentTarget) {
+          return;
+        } else {
+          lightbox.remove();
+        }
+      });
+    }
+  }
+  var gallery_default = Gallery;
+
+  // src/assets/js/imports/utilities.js
+  function shuffle(array) {
+    const arr = [...array];
+    for (let i = arr.length - 1; i > 0; i--) {
+      let j = Math.floor(Math.random() * (i + 1));
+      [arr[i], arr[j]] = [arr[j], arr[i]];
+    }
+    return arr;
+  }
+  function userPrefersReducedMotion() {
+    const QUERY = "(prefers-reduced-motion: no-preference)";
+    const mediaQueryList = window.matchMedia(QUERY);
+    const prefersReducedMotion = !mediaQueryList.matches;
+    return prefersReducedMotion;
+  }
+  var debounce = (func, limit) => {
+    let wait = false;
+    return () => {
+      if (wait) return;
+      func();
+      wait = true;
+      setTimeout(() => wait = false, limit);
+    };
+  };
+  var lerp = (x, y, a) => x * (1 - a) + y * a;
+  var clamp = (a, min = 0, max = 1) => Math.min(max, Math.max(min, a));
+  var invlerp = (x, y, a) => clamp((a - x) / (y - x));
+  var range = (x1, y1, x2, y2, a) => lerp(x2, y2, invlerp(x1, y1, a));
+
+  // src/assets/js/imports/hero-pattern.js
+  function HeroPattern() {
+    let time = 0;
+    const c = document.querySelector(".c-hero__canvas");
+    if (!c) return;
+    const ctx = c.getContext("2d");
+    const sineColour = "rgb(19,170,19)";
+    const reduceMotion = userPrefersReducedMotion();
+    const crossGap = 147;
+    const minimumOpacity = 0;
+    const maximumOpacity = 0.5;
+    const crossSpeed = 0.25;
+    let width;
+    let height;
+    let across;
+    let down;
+    let crosses = [];
+    let totalPoints;
+    function draw() {
+      time = time + 5e-3;
+      ctx.clearRect(0, 0, c.width, c.height);
+      ctx.beginPath();
+      for (let cnt = c.width; cnt > 0; cnt--) {
+        ctx.lineTo(cnt, c.height * 0.5 - Math.cos(time + cnt / 5 * 0.03) * (height * 0.3));
+      }
+      ctx.lineWidth = 0.5;
+      ctx.strokeStyle = sineColour;
+      ctx.stroke();
+      crosses.forEach((cross) => {
+        drawCross(cross.x, cross.y, range(0, crosses.length, minimumOpacity, maximumOpacity, cross.counter));
+        cross.counter += cross.direction;
+        if (cross.counter >= crosses.length) cross.direction = -1 * crossSpeed;
+        if (cross.counter < 0) cross.direction = crossSpeed;
+      });
+      if (!reduceMotion) {
+        window.requestAnimationFrame(draw);
+      }
+    }
+    function onResize() {
+      width = c.scrollWidth;
+      height = c.scrollHeight;
+      ctx.canvas.width = width;
+      ctx.canvas.height = height;
+      across = Math.ceil(width / crossGap);
+      down = Math.ceil(height / crossGap);
+      totalPoints = (across + 1) * (down + 1);
+      const ids = shuffle(Array.from({ length: totalPoints }, (_, i) => i));
+      crosses = [];
+      for (let x = 0; x <= across; x++) {
+        for (let y = 0; y <= down; y++) {
+          crosses.push({
+            counter: ids.shift(),
+            direction: Math.random() > 0.5 ? crossSpeed : -1 * crossSpeed,
+            x: crossGap * (x + 1) - crossGap / 1,
+            y: crossGap * (y + 1) - crossGap / 2
+          });
+        }
+      }
+    }
+    function drawCross(x, y, opacity) {
+      ctx.beginPath();
+      ctx.moveTo(x - 14, y);
+      ctx.lineTo(x + 14, y);
+      ctx.strokeStyle = `rgba(255, 255, 255, ${opacity}`;
+      ctx.moveTo(x, y - 14);
+      ctx.lineTo(x, y + 14);
+      ctx.stroke();
+    }
+    window.addEventListener("resize", onResize);
+    onResize();
+    draw();
+  }
+  var hero_pattern_default = HeroPattern;
+
+  // src/assets/js/imports/hero-video.js
+  function HeroVideo() {
+    document.addEventListener("DOMContentLoaded", () => {
+      const videoBackground = document.getElementById("videoBackground");
+      if (typeof videoBackground != "undefined" && videoBackground != null) {
+        let checkVideos = function() {
+          if (lightboxContainer.classList.contains("u-hidden")) {
+            if (videoBackground.paused) {
+              videoBackground.play();
+            }
+            if (!lightboxVideo.paused) {
+              lightboxVideo.pause();
+            }
+          } else {
+            if (!videoBackground.paused) {
+              videoBackground.pause();
+            }
+          }
+        };
+        const reducedMotion = window.matchMedia("(prefers-reduced-motion: reduce)");
+        if (!reducedMotion || reducedMotion.matches) {
+          videoBackground.pause();
+        }
+        const lightboxTrigger = document.getElementById("playVideo");
+        const lightboxContainer = document.getElementById("lightboxVideo");
+        const lightboxVideo = lightboxContainer.querySelector(".c-lightbox__video");
+        lightboxTrigger.addEventListener("click", (e) => {
+          videoBackground.pause();
+          lightboxContainer.classList.remove("u-hidden");
+          checkVideos();
+        });
+        lightboxContainer.addEventListener("click", (e) => {
+          if (!e.target.classList.contains("c-lightbox__video")) {
+            videoBackground.setAttribute("autoplay", "");
+            lightboxContainer.classList.add("u-hidden");
+            checkVideos();
+          }
+        });
+        window.addEventListener("keydown", function(e) {
+          if (e.key == "Escape") {
+            videoBackground.setAttribute("autoplay", "");
+            lightboxContainer.classList.add("u-hidden");
+            checkVideos();
+          }
+        });
+      }
+    });
+  }
+  var hero_video_default = HeroVideo;
+
+  // src/assets/js/imports/hotspot-image.js
+  function HotspotImage() {
+    setTimeout(function() {
+      const tooltips = document.querySelectorAll(".c-hotspot-image__button");
+      tooltips.forEach((button) => {
+        button.addEventListener("click", handleTooltipToggle);
+      });
+      document.addEventListener("keydown", handleKeyDown);
+      document.addEventListener("click", handleClickOutside);
+    }, 2e3);
+  }
+  function handleTooltipToggle(event) {
+    event.preventDefault();
+    const button = event.currentTarget;
+    const tooltipId = button.getAttribute("aria-controls");
+    const tooltip = document.getElementById(tooltipId);
+    if (tooltip.classList.contains("c-hotspot-image__tooltip--open")) {
+      closeTooltip(button, tooltip);
+    } else {
+      openTooltip(button, tooltip);
+    }
+  }
+  function openTooltip(button, tooltip) {
+    tooltip.classList.add("c-hotspot-image__tooltip--open");
+    tooltip.setAttribute("aria-hidden", "false");
+    button.setAttribute("aria-expanded", "true");
+    document.addEventListener("click", handleClickOutside);
+  }
+  function closeTooltip(button, tooltip) {
+    tooltip.classList.remove("c-hotspot-image__tooltip--open");
+    tooltip.setAttribute("aria-hidden", "true");
+    button.setAttribute("aria-expanded", "false");
+    document.removeEventListener("click", handleClickOutside);
+  }
+  function handleKeyDown(event) {
+    if (event.key === "Escape") {
+      const activeTooltip = document.querySelector(
+        ".c-hotspot-image__tooltip--open"
+      );
+      if (activeTooltip) {
+        const button = document.querySelector(
+          `[aria-controls="${activeTooltip.id}"]`
+        );
+        closeTooltip(button, activeTooltip);
+      }
+    }
+  }
+  function handleClickOutside(event) {
+    const activeTooltip = document.querySelector(
+      ".c-hotspot-image__tooltip--open"
+    );
+    if (activeTooltip && !activeTooltip.contains(event.target) && !event.target.closest(".c-hotspot-image__button")) {
+      const button = document.querySelector(
+        `[aria-controls="${activeTooltip.id}"]`
+      );
+      closeTooltip(button, activeTooltip);
+    }
+  }
+  var hotspot_image_default = HotspotImage;
+
+  // src/assets/js/imports/internal-nav.js
+  function InternalNav() {
+    const internalNav = document.querySelector(".c-internal-nav--sticky");
+    if (!internalNav) {
+      return;
+    }
+    const observerOptions = {
+      root: null,
+      rootMargin: "0px",
+      threshold: 1
+    };
+    const intersectionCallback = (entries, observer2) => {
+      const isIntersecting = entries[0].isIntersecting;
+      internalNav.classList.toggle("c-internal-nav--stuck", !isIntersecting);
+    };
+    const observer = new IntersectionObserver(intersectionCallback, observerOptions);
+    observer.observe(internalNav);
+    let internalNavHeight = internalNav.offsetHeight;
+    const updateInternalNavHeight = () => {
+      internalNavHeight = internalNav.offsetHeight;
+      const anchors = Array.from(internalNav.querySelectorAll("a"));
+      anchors.forEach((anchor) => {
+        const id = anchor.getAttribute("href").replace("#", "");
+        const target = document.getElementById(id);
+        if (target) {
+          target.style.scrollMarginTop = `${internalNavHeight}px`;
+        }
+      });
+    };
+    window.addEventListener("resize", updateInternalNavHeight);
+    updateInternalNavHeight();
+  }
+  var internal_nav_default = InternalNav;
+
+  // src/assets/js/imports/mobile-nav.js
+  function MobileNav() {
+    const openButton = document.querySelector(".c-navicon--open");
+    const closeButton = document.querySelector(".c-navicon--close");
+    const overlay = document.querySelector(".c-header__overlay");
+    if (!openButton || !closeButton || !overlay) return;
+    if (!overlay.id) overlay.id = "overlay-menu";
+    openButton.setAttribute("aria-controls", overlay.id);
+    openButton.setAttribute("aria-expanded", "false");
+    overlay.setAttribute("aria-hidden", "true");
+    setupNavToggle(openButton, closeButton, overlay);
+  }
+  function setupNavToggle(openButton, closeButton, overlay) {
+    const focusableSelectors = 'a[href], button:not([disabled]), input:not([disabled]), textarea:not([disabled]), select:not([disabled]), [tabindex]:not([tabindex="-1"])';
+    const focusableElements = () => overlay.querySelectorAll(focusableSelectors);
+    const trapFocus = (e) => {
+      const elements = focusableElements();
+      if (!elements.length) return;
+      const first = elements[0];
+      const last = elements[elements.length - 1];
+      if (e.key === "Tab") {
+        if (e.shiftKey && document.activeElement === first) {
+          e.preventDefault();
+          last.focus();
+        } else if (!e.shiftKey && document.activeElement === last) {
+          e.preventDefault();
+          first.focus();
+        }
+      }
+    };
+    const onOpen = () => {
+      openButton.setAttribute("aria-expanded", "true");
+      overlay.setAttribute("aria-hidden", "false");
+      overlay.setAttribute("aria-modal", "true");
+      overlay.classList.add("active");
+      document.body.classList.add("u-no-scroll");
+      document.addEventListener("keydown", onEscapePress);
+      document.addEventListener("keydown", trapFocus);
+      const firstFocusable = focusableElements()[0];
+      if (firstFocusable) firstFocusable.focus();
+    };
+    const onClose = () => {
+      openButton.setAttribute("aria-expanded", "false");
+      overlay.setAttribute("aria-hidden", "true");
+      overlay.removeAttribute("aria-modal");
+      overlay.classList.remove("active");
+      document.body.classList.remove("u-no-scroll");
+      document.removeEventListener("keydown", onEscapePress);
+      document.removeEventListener("keydown", trapFocus);
+      openButton.focus();
+    };
+    const onEscapePress = (event) => {
+      if (event.key === "Escape" && overlay.classList.contains("active")) {
+        onClose();
+      }
+    };
+    openButton.addEventListener("click", () => onOpen());
+    closeButton.addEventListener("click", () => onClose());
+  }
+  var mobile_nav_default = MobileNav;
+
+  // src/assets/js/imports/off-canvas.js
+  function OffCanvas() {
+    const toggles = document.querySelectorAll(".c-off-canvas__toggle");
+    if (toggles.length) {
+      toggles.forEach((toggle) => {
+        handleOffCanvas(toggle, isVisible(toggle));
+        toggle.addEventListener("click", () => toggleOffCanvas(toggle));
+      });
+      window.addEventListener("resize", () => {
+        toggles.forEach((toggle) => {
+          handleOffCanvas(toggle, isVisible(toggle));
+        });
+      });
+    }
+  }
+  function isVisible(element) {
+    const style = window.getComputedStyle(element);
+    return style.display !== "none" && style.visibility !== "hidden";
+  }
+  function handleOffCanvas(toggle, isVisible2) {
+    const target = document.getElementById(toggle.getAttribute("data-target"));
+    if (isVisible2 === true) {
+      createOffCanvas(target);
+    } else {
+      removeOffCanvas(target);
+    }
+  }
+  function createOffCanvas(target) {
+    target.classList.add("c-off-canvas");
+    target.setAttribute("tabindex", "-1");
+    target.setAttribute("aria-hidden", "true");
+    const targetHeader = target.querySelector('[data-off-canvas="header"]');
+    const targetMain = target.querySelector('[data-off-canvas="main"]');
+    const targetFooter = target.querySelector('[data-off-canvas="footer"]');
+    const targetHeaderContent = targetHeader !== null ? targetHeader.outerHTML : "";
+    const targetMainContent = targetMain !== null ? targetMain.outerHTML : "";
+    const targetFooterContent = targetFooter !== null ? targetFooter.outerHTML : "";
+    target.innerHTML = `
+    <div class="c-off-canvas__backdrop" role="presentation"></div>
+    <div class="c-off-canvas__content" role="dialog" aria-modal="true" aria-labelledby="offCanvasHeader">
+      <header id="offCanvasHeader" class="c-off-canvas__header">${targetHeaderContent}</header>
+      <main class="c-off-canvas__main">${targetMainContent}</main>
+      <footer class="c-off-canvas__footer">
+        ${targetFooterContent}
+        <button class="mp c-twi c-twi--left c-off-canvas__close" data-off-canvas-close="true" onclick="return false">
+          <span>Cancel</span>
+          <svg role="img" aria-hidden="true" focusable="false" class="mp c-icon c-icon--cross">
+            <use xlink:href="/static/svg/sprite.svg#cross"></use>
+          </svg>
+        </button>
+      </footer>
+    </div>
+  `;
+  }
+  function removeOffCanvas(target) {
+    target.classList.remove("c-off-canvas", "c-off-canvas--active");
+    target.removeAttribute("tabindex");
+    target.removeAttribute("aria-hidden");
+    const targetBackdrop = target.querySelector(".c-off-canvas__backdrop");
+    if (targetBackdrop) {
+      targetBackdrop.remove();
+    }
+    const targetContent = target.querySelector(".c-off-canvas__content");
+    if (targetContent) {
+      while (targetContent.firstChild) {
+        target.insertBefore(targetContent.firstChild, targetContent);
+      }
+      target.removeChild(targetContent);
+    }
+    const targetHeader = target.querySelector(".c-off-canvas__header");
+    if (targetHeader) {
+      while (targetHeader.firstChild) {
+        target.insertBefore(targetHeader.firstChild, targetHeader);
+      }
+      target.removeChild(targetHeader);
+    }
+    const targetMain = target.querySelector(".c-off-canvas__main");
+    if (targetMain) {
+      while (targetMain.firstChild) {
+        target.insertBefore(targetMain.firstChild, targetMain);
+      }
+      target.removeChild(targetMain);
+    }
+    const targetFooter = target.querySelector(".c-off-canvas__footer");
+    if (targetFooter) {
+      while (targetFooter.firstChild) {
+        target.insertBefore(targetFooter.firstChild, targetFooter);
+      }
+      target.removeChild(targetFooter);
+    }
+    const targetClose = target.querySelector(".c-off-canvas__close");
+    if (targetClose) {
+      targetClose.remove();
+    }
+  }
+  function toggleOffCanvas(toggle) {
+    const target = document.getElementById(toggle.getAttribute("data-target"));
+    if (!target.classList.contains("c-off-canvas--active")) {
+      openOffCanvas(toggle, target);
+    } else if (target.classList.contains("c-off-canvas--active")) {
+      closeOffCanvas(target);
+    }
+  }
+  function openOffCanvas(toggle, target) {
+    toggle.setAttribute("aria-expanded", "true");
+    target.classList.add("c-off-canvas--active");
+    target.setAttribute("aria-hidden", "false");
+    const offCanvasBackdrop = target.querySelector(".c-off-canvas__backdrop");
+    if (offCanvasBackdrop) {
+      offCanvasBackdrop.addEventListener("click", handleBackdropClick);
+    }
+    const offCanvasCloseElements = target.querySelectorAll('[data-off-canvas-close="true"]');
+    if (offCanvasCloseElements.length > 0) {
+      offCanvasCloseElements.forEach((offCanvasClose) => {
+        offCanvasClose.addEventListener("click", handleCloseClick);
+      });
+    }
+    document.addEventListener("keydown", handleKeyDown2, { once: true });
+    document.body.style.overflowY = "hidden";
+    const allOffCanvasElementsExceptCurrent = Array.from(document.querySelectorAll(".c-off-canvas")).filter((offCanvas) => offCanvas !== target);
+    if (allOffCanvasElementsExceptCurrent.length > 0) {
+      allOffCanvasElementsExceptCurrent.forEach((offCanvas) => {
+        closeOffCanvas(offCanvas);
+      });
+    }
+  }
+  function closeOffCanvas(target) {
+    document.querySelector('[data-target="' + target.id + '"').setAttribute("aria-expanded", "false");
+    target.classList.remove("c-off-canvas--active");
+    target.setAttribute("aria-hidden", "true");
+    document.body.style.overflowY = "";
+  }
+  function handleBackdropClick() {
+    const offCanvas = this.closest(".c-off-canvas");
+    closeOffCanvas(offCanvas);
+  }
+  function handleKeyDown2(event) {
+    if (event.key === "Escape") {
+      const activeOffCanvas = document.querySelector(".c-off-canvas--active");
+      if (activeOffCanvas) {
+        closeOffCanvas(activeOffCanvas);
+      }
+    }
+  }
+  function handleCloseClick() {
+    const offCanvas = this.closest(".c-off-canvas");
+    closeOffCanvas(offCanvas);
+  }
+  var off_canvas_default = OffCanvas;
+
+  // src/assets/js/imports/responsive-table.js
+  var ResponsiveTable = () => {
+    const tables = Array.from(document.querySelectorAll(".c-table--responsive"));
+    tables.forEach(createResponsiveTable);
+    function createResponsiveTable(table) {
+      const headers = table.querySelectorAll("thead > :first-child th");
+      const breakPoint = Number(table.getAttribute("data-columns")) || 2;
+      if (headers.length < breakPoint) {
+        table.classList.remove("c-table--responsive");
+        return;
+      }
+      ;
+      Array.from(table.querySelectorAll("tbody tr")).forEach((row) => {
+        Array.from(headers).map((x) => x.textContent).forEach((header, index) => {
+          if (row.children[index]) {
+            row.children[index].setAttribute("data-responsive-title", header);
+          }
+        });
+      });
+    }
+  };
+  var responsive_table_default = ResponsiveTable;
+
+  // src/assets/js/imports/scrollbar-width.js
+  function ScrollbarWidth() {
+    setScrollbarWidth();
+    window.addEventListener("resize", debounce(setScrollbarWidth, 250));
+  }
+  function setScrollbarWidth() {
+    document.documentElement.style.setProperty(
+      "--scrollbarWidth",
+      window.innerWidth - document.body.clientWidth + "px"
+    );
+  }
+  var scrollbar_width_default = ScrollbarWidth;
+
+  // src/assets/js/imports/scroll-spy.js
+  function ScrollSpy() {
+    const internalNav = document.querySelector(".c-internal-nav--sticky");
+    const internalNavHeight = internalNav ? internalNav.offsetHeight : 0;
+    const spies = Array.from(document.querySelectorAll(".c-scroll-spy"));
+    spies.forEach((spy) => {
+      setup(spy, internalNavHeight);
+    });
+  }
+  function setup(element, internalNavHeight) {
+    const anchors = Array.from(element.querySelectorAll("a"));
+    const observer = new IntersectionObserver(observation(anchors));
+    anchors.forEach((anchor) => {
+      const id = anchor.getAttribute("href").replace("#", "");
+      const target = document.getElementById(id);
+      if (!target) return;
+      observer.observe(target);
+    });
+    const currentTop = parseFloat(window.getComputedStyle(element).top);
+    element.style.top = `${currentTop + internalNavHeight}px`;
+  }
+  function observation(anchors) {
+    return (results) => {
+      const firstObservation = results.find((x) => x.isIntersecting);
+      if (firstObservation) {
+        anchors.forEach((x) => {
+          x.classList.toggle(
+            "c-scroll-spy-active",
+            x.getAttribute("href") === "#" + firstObservation.target.id
+          );
+        });
+      }
+    };
+  }
+  var scroll_spy_default = ScrollSpy;
+
+  // src/assets/js/imports/tabs.js
+  var resizeTimeout;
+  function Tabs() {
+    const tabs = Array.from(document.querySelectorAll(".c-tabs--anchor, .c-tabs--mobile-accordion"));
+    tabs.forEach((parent) => {
+      setupTabs(parent);
+      window.addEventListener("resize", () => {
+        clearTimeout(resizeTimeout);
+        resizeTimeout = setTimeout(() => handleResize(parent), 100);
+      });
+    });
+  }
+  function setupTabs(parent) {
+    const controls = Array.from(parent.querySelectorAll(".c-tabs__control"));
+    const contents = Array.from(parent.querySelectorAll(".c-tab"));
+    const persist = parent.classList.contains("c-tabs--persist");
+    if (!controls.length || !contents.length) return;
+    handleResize(parent);
+    controls.forEach((control) => {
+      control.addEventListener("click", controlClick(controls, contents, persist));
+    });
+    if (persist && window.location.hash) {
+      const control = parent.querySelector('[href="' + window.location.hash + '"]');
+      if (control) control.dispatchEvent(new Event("click"));
+    }
+  }
+  function handleResize(parent) {
+    const isAccordion = parent.classList.contains("c-tabs--mobile-accordion");
+    const isMobile = window.innerWidth <= 880;
+    if (parent.dataset.viewMode === (isMobile ? "accordion" : "tabs")) {
+      return;
+    }
+    parent.dataset.viewMode = isMobile ? "accordion" : "tabs";
+    if (isAccordion && isMobile) {
+      restructureForAccordion(parent);
+    } else if (isAccordion && !isMobile) {
+      restoreToTabs(parent);
+    }
+  }
+  function restructureForAccordion(parent) {
+    const controlElements = Array.from(parent.querySelectorAll(".c-tabs__control"));
+    const tabElements = Array.from(parent.querySelectorAll(".c-tab"));
+    const controlsElement = parent.querySelector(".c-tabs__controls");
+    if (controlsElement) {
+      controlsElement.remove();
+    }
+    controlElements.forEach((control, index) => {
+      const content = tabElements[index];
+      if (content) {
+        const tabWrapper = document.createElement("div");
+        tabWrapper.classList.add("c-tabs__content");
+        tabWrapper.appendChild(control);
+        tabWrapper.appendChild(content);
+        parent.appendChild(tabWrapper);
+      }
+    });
+  }
+  function restoreToTabs(parent) {
+    const controls = Array.from(parent.querySelectorAll(".c-tabs__control"));
+    const contents = Array.from(parent.querySelectorAll(".c-tab"));
+    if (!controls.length || !contents.length) return;
+    parent.innerHTML = `
+    <nav class="c-tabs__controls">
+      <ul class="c-tabs__controls-list">
+        ${controls.map((control) => `<li>${control.outerHTML}</li>`).join("")}
+      </ul>
+    </nav>
+    <div class="c-tabs__content">
+      ${contents.map((content) => content.outerHTML).join("")}
+    </div>
+  `;
+    setTimeout(() => setupTabs(parent), 0);
+  }
+  function controlClick(controls, contents, persist) {
+    return (event) => {
+      const control = event.currentTarget;
+      const contentId = control.getAttribute("href")?.replace("#", "");
+      const content = contents.find((x) => x.id === contentId);
+      if (!content) return true;
+      event.preventDefault();
+      if (persist) {
+        history.pushState(null, null, control.getAttribute("href"));
+      }
+      if (window.innerWidth <= 880) {
+        const isActive = content.classList.contains("c-tab--active");
+        controls.forEach((c) => c.classList.remove("c-tabs__control--active"));
+        contents.forEach((c) => c.classList.remove("c-tab--active"));
+        if (!isActive) {
+          control.classList.add("c-tabs__control--active");
+          content.classList.add("c-tab--active");
+        }
+      } else {
+        controls.forEach((c) => c.classList.toggle("c-tabs__control--active", c === control));
+        contents.forEach((c) => c.classList.toggle("c-tab--active", c === content));
+      }
+    };
+  }
+  var tabs_default = Tabs;
+
+  // src/assets/js/mp-www.js
+  function initializeApp() {
+    if (window.NodeList && !NodeList.prototype.forEach) {
+      NodeList.prototype.forEach = Array.prototype.forEach;
+    }
+    if (window.HTMLCollection && !HTMLCollection.prototype.forEach) {
+      HTMLCollection.prototype.forEach = Array.prototype.forEach;
+    }
+    accordion_default();
+    carousel_default();
+    clear_form_default();
+    comparison_default();
+    facet_default();
+    gallery_default();
+    hero_pattern_default();
+    hero_video_default();
+    hotspot_image_default();
+    internal_nav_default();
+    mobile_nav_default();
+    off_canvas_default();
+    responsive_table_default();
+    scrollbar_width_default();
+    scroll_spy_default();
+    tabs_default();
+  }
+  if (typeof window !== "undefined") {
+    initializeApp();
+  }
+})();
+//# sourceMappingURL=mp-www.js.map