/* Minification failed. Returning unminified contents.
(578,13-14): run-time error JS1195: Expected expression: .
(578,23-24): run-time error JS1195: Expected expression: >
(580,27-28): run-time error JS1195: Expected expression: )
(580,30-31): run-time error JS1195: Expected expression: >
(582,8-9): run-time error JS1195: Expected expression: ,
(582,17-18): run-time error JS1003: Expected ':': )
(583,5-6): run-time error JS1002: Syntax error: }
(671,37-38): run-time error JS1004: Expected ';': {
(673,4-5): run-time error JS1195: Expected expression: ,
(675,63-64): run-time error JS1004: Expected ';': {
(691,4-5): run-time error JS1195: Expected expression: ,
(676,31-37): run-time error JS1018: 'return' statement outside of function: return
(672,5-90): run-time error JS1018: 'return' statement outside of function: return event instanceof KeyboardEvent || (event.clientX === 0 && event.clientY === 0)
 */
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

(function (global, factory) {
  (typeof exports === "undefined" ? "undefined" : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.LazyLoad = factory();
})(this, function () {
  'use strict';

  var runningOnBrowser = typeof window !== "undefined";
  var isBot = runningOnBrowser && !("onscroll" in window) || typeof navigator !== "undefined" && /(gle|ing|ro)bot|crawl|spider/i.test(navigator.userAgent);
  var supportsIntersectionObserver = runningOnBrowser && "IntersectionObserver" in window && "IntersectionObserverEntry" in window && "intersectionRatio" in window.IntersectionObserverEntry.prototype && "isIntersecting" in window.IntersectionObserverEntry.prototype;
  var supportsClassList = runningOnBrowser && "classList" in document.createElement("p");
  var defaultSettings = {
    elements_selector: "img",
    container: isBot || runningOnBrowser ? document : null,
    threshold: 300,
    thresholds: null,
    data_src: "src",
    data_srcset: "srcset",
    data_sizes: "sizes",
    data_bg: "bg",
    class_loading: "loading",
    class_loaded: "loaded",
    class_error: "error",
    load_delay: 0,
    auto_unobserve: true,
    callback_enter: null,
    callback_exit: null,
    callback_reveal: null,
    callback_loaded: null,
    callback_error: null,
    callback_finish: null,
    use_native: false
  };

  var getInstanceSettings = function getInstanceSettings(customSettings) {
    return _extends({}, defaultSettings, customSettings);
  };
  /* Creates instance and notifies it through the window element */


  var createInstance = function createInstance(classObj, options) {
    var event;
    var eventString = "LazyLoad::Initialized";
    var instance = new classObj(options);

    try {
      // Works in modern browsers
      event = new CustomEvent(eventString, {
        detail: {
          instance: instance
        }
      });
    } catch (err) {
      // Works in Internet Explorer (all versions)
      event = document.createEvent("CustomEvent");
      event.initCustomEvent(eventString, false, false, {
        instance: instance
      });
    }

    window.dispatchEvent(event);
  };
  /* Auto initialization of one or more instances of lazyload, depending on the 
      options passed in (plain object or an array) */


  function autoInitialize(classObj, options) {
    if (!options) {
      return;
    }

    if (!options.length) {
      // Plain object
      createInstance(classObj, options);
    } else {
      // Array of objects
      for (var i = 0, optionsItem; optionsItem = options[i]; i += 1) {
        createInstance(classObj, optionsItem);
      }
    }
  }

  var dataPrefix = "data-";
  var processedDataName = "was-processed";
  var timeoutDataName = "ll-timeout";
  var trueString = "true";

  var getData = function getData(element, attribute) {
    return element.getAttribute(dataPrefix + attribute);
  };

  var setData = function setData(element, attribute, value) {
    var attrName = dataPrefix + attribute;

    if (value === null) {
      element.removeAttribute(attrName);
      return;
    }

    element.setAttribute(attrName, value);
  };

  var setWasProcessedData = function setWasProcessedData(element) {
    return setData(element, processedDataName, trueString);
  };

  var getWasProcessedData = function getWasProcessedData(element) {
    return getData(element, processedDataName) === trueString;
  };

  var setTimeoutData = function setTimeoutData(element, value) {
    return setData(element, timeoutDataName, value);
  };

  var getTimeoutData = function getTimeoutData(element) {
    return getData(element, timeoutDataName);
  };

  var purgeProcessedElements = function purgeProcessedElements(elements) {
    return elements.filter(function (element) {
      return !getWasProcessedData(element);
    });
  };

  var purgeOneElement = function purgeOneElement(elements, elementToPurge) {
    return elements.filter(function (element) {
      return element !== elementToPurge;
    });
  };

  var callbackIfSet = function callbackIfSet(callback, argument) {
    if (callback) {
      callback(argument);
    }
  };

  var updateLoadingCount = function updateLoadingCount(instance, plusMinus) {
    instance._loadingCount += plusMinus;

    if (instance._elements.length === 0 && instance._loadingCount === 0) {
      callbackIfSet(instance._settings.callback_finish);
    }
  };

  var getSourceTags = function getSourceTags(parentTag) {
    var sourceTags = [];

    for (var i = 0, childTag; childTag = parentTag.children[i]; i += 1) {
      if (childTag.tagName === "SOURCE") {
        sourceTags.push(childTag);
      }
    }

    return sourceTags;
  };

  var setAttributeIfValue = function setAttributeIfValue(element, attrName, value) {
    if (!value) {
      return;
    }

    element.setAttribute(attrName, value);
  };

  var setImageAttributes = function setImageAttributes(element, settings) {
    setAttributeIfValue(element, "sizes", getData(element, settings.data_sizes));
    setAttributeIfValue(element, "srcset", getData(element, settings.data_srcset));
    setAttributeIfValue(element, "src", getData(element, settings.data_src));
  };

  var setSourcesImg = function setSourcesImg(element, settings) {
    var parent = element.parentNode;

    if (parent && parent.tagName === "PICTURE") {
      var sourceTags = getSourceTags(parent);
      sourceTags.forEach(function (sourceTag) {
        setImageAttributes(sourceTag, settings);
      });
    }

    setImageAttributes(element, settings);
  };

  var setSourcesIframe = function setSourcesIframe(element, settings) {
    setAttributeIfValue(element, "src", getData(element, settings.data_src));
  };

  var setSourcesVideo = function setSourcesVideo(element, settings) {
    var sourceTags = getSourceTags(element);
    sourceTags.forEach(function (sourceTag) {
      setAttributeIfValue(sourceTag, "src", getData(sourceTag, settings.data_src));
    });
    setAttributeIfValue(element, "src", getData(element, settings.data_src));
    element.load();
  };

  var setSourcesBgImage = function setSourcesBgImage(element, settings) {
    var srcDataValue = getData(element, settings.data_src);
    var bgDataValue = getData(element, settings.data_bg);

    if (srcDataValue) {
      element.style.backgroundImage = "url(\"".concat(srcDataValue, "\")");
    }

    if (bgDataValue) {
      element.style.backgroundImage = bgDataValue;
    }
  };

  var setSourcesFunctions = {
    IMG: setSourcesImg,
    IFRAME: setSourcesIframe,
    VIDEO: setSourcesVideo
  };

  var setSources = function setSources(element, instance) {
    var settings = instance._settings;
    var tagName = element.tagName;
    var setSourcesFunction = setSourcesFunctions[tagName];

    if (setSourcesFunction) {
      setSourcesFunction(element, settings);
      updateLoadingCount(instance, 1);
      instance._elements = purgeOneElement(instance._elements, element);
      return;
    }

    setSourcesBgImage(element, settings);
  };

  var addClass = function addClass(element, className) {
    if (supportsClassList) {
      element.classList.add(className);
      return;
    }

    element.className += (element.className ? " " : "") + className;
  };

  var removeClass = function removeClass(element, className) {
    if (supportsClassList) {
      element.classList.remove(className);
      return;
    }

    element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, "");
  };

  var genericLoadEventName = "load";
  var mediaLoadEventName = "loadeddata";
  var errorEventName = "error";

  var addEventListener = function addEventListener(element, eventName, handler) {
    element.addEventListener(eventName, handler);
  };

  var removeEventListener = function removeEventListener(element, eventName, handler) {
    element.removeEventListener(eventName, handler);
  };

  var addEventListeners = function addEventListeners(element, loadHandler, errorHandler) {
    addEventListener(element, genericLoadEventName, loadHandler);
    addEventListener(element, mediaLoadEventName, loadHandler);
    addEventListener(element, errorEventName, errorHandler);
  };

  var removeEventListeners = function removeEventListeners(element, loadHandler, errorHandler) {
    removeEventListener(element, genericLoadEventName, loadHandler);
    removeEventListener(element, mediaLoadEventName, loadHandler);
    removeEventListener(element, errorEventName, errorHandler);
  };

  var eventHandler = function eventHandler(event, success, instance) {
    var settings = instance._settings;
    var className = success ? settings.class_loaded : settings.class_error;
    var callback = success ? settings.callback_loaded : settings.callback_error;
    var element = event.target;
    removeClass(element, settings.class_loading);
    addClass(element, className);
    callbackIfSet(callback, element);
    updateLoadingCount(instance, -1);
  };

  var addOneShotEventListeners = function addOneShotEventListeners(element, instance) {
    var loadHandler = function loadHandler(event) {
      eventHandler(event, true, instance);
      removeEventListeners(element, loadHandler, errorHandler);
    };

    var errorHandler = function errorHandler(event) {
      eventHandler(event, false, instance);
      removeEventListeners(element, loadHandler, errorHandler);
    };

    addEventListeners(element, loadHandler, errorHandler);
  };

  var managedTags = ["IMG", "IFRAME", "VIDEO"];

  var onEnter = function onEnter(element, instance) {
    var settings = instance._settings;
    callbackIfSet(settings.callback_enter, element);

    if (!settings.load_delay) {
      revealAndUnobserve(element, instance);
      return;
    }

    delayLoad(element, instance);
  };

  var revealAndUnobserve = function revealAndUnobserve(element, instance) {
    var observer = instance._observer;
    revealElement(element, instance);

    if (observer && instance._settings.auto_unobserve) {
      observer.unobserve(element);
    }
  };

  var onExit = function onExit(element, instance) {
    var settings = instance._settings;
    callbackIfSet(settings.callback_exit, element);

    if (!settings.load_delay) {
      return;
    }

    cancelDelayLoad(element);
  };

  var cancelDelayLoad = function cancelDelayLoad(element) {
    var timeoutId = getTimeoutData(element);

    if (!timeoutId) {
      return; // do nothing if timeout doesn't exist
    }

    clearTimeout(timeoutId);
    setTimeoutData(element, null);
  };

  var delayLoad = function delayLoad(element, instance) {
    var loadDelay = instance._settings.load_delay;
    var timeoutId = getTimeoutData(element);

    if (timeoutId) {
      return; // do nothing if timeout already set
    }

    timeoutId = setTimeout(function () {
      revealAndUnobserve(element, instance);
      cancelDelayLoad(element);
    }, loadDelay);
    setTimeoutData(element, timeoutId);
  };

  var revealElement = function revealElement(element, instance, force) {
    var settings = instance._settings;

    if (!force && getWasProcessedData(element)) {
      return; // element has already been processed and force wasn't true
    }

    if (managedTags.indexOf(element.tagName) > -1) {
      addOneShotEventListeners(element, instance);
      addClass(element, settings.class_loading);
    }

    setSources(element, instance);
    setWasProcessedData(element);
    callbackIfSet(settings.callback_reveal, element);
    callbackIfSet(settings.callback_set, element);
  };

  var isIntersecting = function isIntersecting(entry) {
    return entry.isIntersecting || entry.intersectionRatio > 0;
  };

  var getObserverSettings = function getObserverSettings(settings) {
    return {
      root: settings.container === document ? null : settings.container,
      rootMargin: settings.thresholds || settings.threshold + "px"
    };
  };

  var setObserver = function setObserver(instance) {
    if (!supportsIntersectionObserver) {
      return false;
    }

    instance._observer = new IntersectionObserver(function (entries) {
      entries.forEach(function (entry) {
        return isIntersecting(entry) ? onEnter(entry.target, instance) : onExit(entry.target, instance);
      });
    }, getObserverSettings(instance._settings));
    return true;
  };

  var nativeLazyTags = ["IMG", "IFRAME"];

  var shouldUseNative = function shouldUseNative(settings) {
    return settings.use_native && "loading" in HTMLImageElement.prototype;
  };

  var loadAllNative = function loadAllNative(instance) {
    instance._elements.forEach(function (element) {
      if (nativeLazyTags.indexOf(element.tagName) === -1) {
        return;
      }

      element.setAttribute("loading", "lazy");
      revealElement(element, instance);
    });
  };

  var nodeSetToArray = function nodeSetToArray(nodeSet) {
    return Array.prototype.slice.call(nodeSet);
  };

  var queryElements = function queryElements(settings) {
    return settings.container.querySelectorAll(settings.elements_selector);
  };

  var getElements = function getElements(elements, settings) {
    return purgeProcessedElements(nodeSetToArray(elements || queryElements(settings)));
  };

  var LazyLoad = function LazyLoad(customSettings, elements) {
    this._settings = getInstanceSettings(customSettings);
    this._loadingCount = 0;
    setObserver(this);
    this.update(elements);
  };

  LazyLoad.prototype = {
    update: function update(elements) {
      var _this = this;

      var settings = this._settings;
      this._elements = getElements(elements, settings);

      if (isBot || !this._observer) {
        this.loadAll();
        return;
      }

      if (shouldUseNative(settings)) {
        loadAllNative(this);
        this._elements = getElements(elements, settings);
      }

      this._elements.forEach(function (element) {
        _this._observer.observe(element);
      });
    },
    destroy: function destroy() {
      var _this2 = this;

      if (this._observer) {
        this._elements.forEach(function (element) {
          _this2._observer.unobserve(element);
        });

        this._observer = null;
      }

      this._elements = null;
      this._settings = null;
    },
    load: function load(element, force) {
      revealElement(element, this, force);
    },
    loadAll: function loadAll() {
      var _this3 = this;

      this._elements.forEach(function (element) {
        revealAndUnobserve(element, _this3);
      });
    }
  };
  /* Automatic instances creation if required (useful for async script loading) */

  if (runningOnBrowser) {
    autoInitialize(LazyLoad, window.lazyLoadOptions);
  }

  return LazyLoad;
});;
var lazyLoadInstance = new LazyLoad({
    elements_selector: ".lazy"
});

/* ========================================================================
    Polyfills
  ========================================================================== */

if (window.NodeList && !NodeList.prototype.forEach) {
  NodeList.prototype.forEach = Array.prototype.forEach;
}

/* ========================================================================
    Utilities
  ========================================================================== */

const util = {

  onDocumentReady: function (callback) {
    const isReady = document.readyState != null && document.readyState != 'loading';

    if (isReady) {
      callback();
    } else {
      document.addEventListener('DOMContentLoaded', callback);
    }
  },

  getCookie: function (name) {
    let value = '; ' + document.cookie;
    let parts = value.split('; ' + name + '=');
    return parts.length !== 2 ? undefined : parts.pop().split(';').shift();
  },

  setCookie: function (name, value, expiryDays, domain, path) {
    let expirationDate = new Date();
    expirationDate.setDate(expirationDate.getDate() + (expiryDays || 365));

    let cookie = [
      name + '=' + value,
      'Expires=' + expirationDate.toUTCString(),
      'Path=' + (path || '/'),
      'SameSite=Lax',
    ];

    if (domain) {
      cookie.push('Domain=' + domain);
    }

    document.cookie = cookie.join(';');
  },

  deleteCookie: function (name) {
    this.setCookie(name, '', -1);
  },

  isMobile: function () {
    return /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
  },

  isIE: function () {
    // MSIE used to detect old browsers and Trident used to newer ones
    return navigator.userAgent.indexOf('MSIE ') > -1 || navigator.userAgent.indexOf('Trident/') > -1;
  },

  isEdge: function () {
    return navigator.userAgent.indexOf('Edge/') > -1;
  },

  getQueryString: function (name) {
    name = name.replace(/[\[]/, '\\[').replace(/[\]]/, '\\]');
    const regexS = '[\\?&]' + name + '=([^&#]*)';
    const regex = new RegExp(regexS);
    let results = regex.exec(window.location.href);
    if (results === null) {
      return '';
    } else {
      return results[1];
    }
  },

  // https://www.freecodecamp.org/news/javascript-debounce-example/
  debounce: function (func, timeout) {
    timeout = timeout || 250;

    let timer;
    return (...args) => {
      clearTimeout(timer);
      timer = setTimeout(() => {
        func.apply(this, args);
      }, timeout);
    };
  },

  //slideUp: function (target, duration, cb) {
  //  duration = duration || 500;

  //  target.style.transitionProperty = 'height, margin, padding, opacity';
  //  target.style.transitionDuration = duration + 'ms';
  //  target.style.boxSizing = 'border-box';
  //  target.style.height = target.offsetHeight + 'px';
  //  target.offsetHeight;
  //  target.style.overflow = 'hidden';
  //  // target.style.opacity = 0;
  //  target.style.height = 0;
  //  target.style.paddingTop = 0;
  //  target.style.paddingBottom = 0;
  //  target.style.marginTop = 0;
  //  target.style.marginBottom = 0;

  //  window.setTimeout(() => {
  //    target.style.display = 'none';
  //    target.style.visibility = 'hidden';
  //    target.style.removeProperty('height');
  //    target.style.removeProperty('padding-top');
  //    target.style.removeProperty('padding-bottom');
  //    target.style.removeProperty('margin-top');
  //    target.style.removeProperty('margin-bottom');
  //    target.style.removeProperty('overflow');
  //    target.style.removeProperty('transition-duration');
  //    target.style.removeProperty('transition-property');
  //    target.style.removeProperty('box-sizing');
  //    target.style.removeProperty('opacity');
  //  }, duration);

  //  if (typeof cb === 'function') {
  //    window.setTimeout(cb, duration);
  //  }
  //},

  //slideDown: function (target, duration, cb) {
  //  duration = duration || 500;

  //  target.style.removeProperty('display');
  //  let display = window.getComputedStyle(target).display;
  //  if (display === 'none') display = 'block';
  //  target.style.display = display;
  //  let height = target.offsetHeight;
  //  target.style.overflow = 'hidden';
  //  target.style.opacity = 0;
  //  target.style.height = 0;
  //  target.style.paddingTop = 0;
  //  target.style.paddingBottom = 0;
  //  target.style.marginTop = 0;
  //  target.style.marginBottom = 0;
  //  target.offsetHeight;
  //  target.style.boxSizing = 'border-box';
  //  target.style.transitionProperty = 'height, margin, padding, opacity';
  //  target.style.transitionDuration = duration + 'ms';
  //  target.style.height = height + 'px';
  //  target.style.removeProperty('padding-top');
  //  target.style.removeProperty('padding-bottom');
  //  target.style.removeProperty('margin-top');
  //  target.style.removeProperty('margin-bottom');
  //  target.style.opacity = 1;
  //  target.style.visibility = 'visible';

  //  window.setTimeout(() => {
  //    target.style.removeProperty('height');
  //    target.style.removeProperty('overflow');
  //    target.style.removeProperty('transition-duration');
  //    target.style.removeProperty('transition-property');
  //  }, duration);

  //  if (typeof cb === 'function') {
  //    window.setTimeout(cb, duration);
  //  }
  //},

  //slideToggle: function (target, duration, cb) {
  //  duration = duration || 500;

  //  if (window.getComputedStyle(target).display === 'none') {
  //    return slideDown(target, duration, cb);
  //  } else {
  //    return slideUp(target, duration, cb);
  //  }
  //},

  isKeyboardEvent: function (event) {
    return event instanceof KeyboardEvent || (event.clientX === 0 && event.clientY === 0);
  },

  checkCharCount: function (input, maxLength, outputSelector) {
    if (!input || !maxLength) return;

    var inputLength = input.value.length;

    if (inputLength > maxLength) {
      input.value = input.value.substr(0, maxLength);
      inputLength = maxLength;
    }

    var remaining = maxLength - inputLength;

    var output = document.querySelector(outputSelector);
    if (output) {
      output.innerHTML = "Remaining character count: " + remaining.toString();
    }
  },
};

var app = app || {};

/* ========================================================================
    General
  ========================================================================== */

app.general = (function () {
  'use strict';

  let headerMenu = null;

  const updateViewportDimensions = util.debounce(function () {
    document.documentElement.style.setProperty('--vh', window.innerHeight + 'px');
    document.documentElement.style.setProperty('--vw', window.innerWidth + 'px');
  }, 250);

  function initViewportDimensions() {
    updateViewportDimensions();

    // Handle viewport dimensions on resize
    window.addEventListener('resize', updateViewportDimensions, { passive: true });
  }

  const updateWindowScroll = function () {
    let offset = window.innerWidth >= 800 ? 80 : 70;

    if (window.scrollY > offset) {
      headerMenu.setAttribute('data-header-menu', 'fixed');
    } else {
      headerMenu.setAttribute('data-header-menu', '');
    }
  }

  function initWindowScroll() {
    headerMenu = document.querySelector('[data-header-menu]');
    if (!headerMenu) return;

    updateWindowScroll();

    // Handle window scroll event
    window.addEventListener('scroll', updateWindowScroll, { passive: true });
  }

  function initCategoryFilter(category) {
    const categoryFilter = document.querySelector('[data-category-filter]');
    if (!categoryFilter) return;

    categoryFilter.addEventListener('change', function (event) {
      const category = categoryFilter.value;
      if (category === 'all') {
        document.location = '/';
      } else {
        document.location = '/' + category.toString().toLowerCase();
      }
    });
  }

  function init() {
    initViewportDimensions();
    initWindowScroll();
    initCategoryFilter();
  }

  return {
    init: init,
  };
})();

/* ========================================================================
    Tracking
  ========================================================================== */

app.tracking = (function () {
  'use strict';

  function init() {
    const dataTypeLinks = document.querySelectorAll('[data-type]');
    const dataCategoryLinks = document.querySelectorAll('[data-category]');

    dataTypeLinks.forEach(function (link) {
      link.addEventListener('click', function (event) {
        const type = link.getAttribute('data-type');
        const id = link.getAttribute('data-id');

        if (type && id) {
          console.log("type: " + type + ", id: " + id);
          trackClick(type, id);
        }
      });
    });

    dataCategoryLinks.forEach(function (link) {
      link.addEventListener('click', function (event) {
        const category = link.getAttribute('data-category');
        const action = link.getAttribute('data-action');
        const label = link.getAttribute('data-label');

        // https://github.com/jahilldev/minimal-analytics/tree/main/packages/ga4
        if (typeof window.track === 'function' && category && action && label) {
          console.log('category: ' + category + ', action: ' + action + ', label: ' + label);

          //gtag('event', category, {
          //  action: action,
          //  label: label,
          //});

          window.track({
            type: category, event: {
              'ep.action': action,
              'ep.label': label,
            }
          });
        }
      });
    });
  }

  function trackClick(type, id) {
    fetch('/out/' + type + '/' + id + '/?clickonly=1', {
      method: 'GET',
    })
      .catch(function (error) {
        console.warn(error);
      });

    return false;
  }

  return {
    init: init,
    trackClick: trackClick
  };
})();

/* ========================================================================
    Searchbox
  ========================================================================== */

app.searchBox = (function () {
  'use strict';

  function init() {
    const searchBox = document.querySelector('[data-search-box]');
    const searchToggle = document.querySelector('[data-search-toggle]');
/*    const searchButton = document.querySelector('[data-search-button]');*/
    const searchInput = document.querySelector('[data-search-input]');

    if (!searchBox || !searchToggle || !searchInput) {
      return;
    }

    searchToggle.addEventListener('click', function (event) {
      event.preventDefault();

      if (searchToggle.getAttribute('aria-expanded') === 'true') {
        searchToggle.setAttribute('aria-expanded', false);
        searchBox.setAttribute('aria-hidden', true);
      } else {
        searchToggle.setAttribute('aria-expanded', true);
        searchBox.setAttribute('aria-hidden', false);
        searchInput.focus();
      }
    });

    //searchButton.addEventListener('click', function (event) {
    //  event.preventDefault();

    //  const key = searchInput.value.replace(/<\/?[^>]+(>|$)/g, '');

    //  if (key.length > 0) {
    //    document.location = '/search?q=' + encodeURIComponent(key).replace(/%20/g, '+');
    //  }
    //});

    searchInput.addEventListener('keypress', function (event) {
      if (event.keyCode === 13) {
        event.preventDefault();

        const key = searchInput.value.replace(/<\/?[^>]+(>|$)/g, '');

        if (key.length > 0) {
          document.location = '/search?q=' + encodeURIComponent(key).replace(/%20/g, '+');
        }
      }
    });
  }

  return {
    init: init,
  };
})();

/* ========================================================================
    Friends
  ========================================================================== */

app.friends = (function () {
  'use strict';

  let toggles = null;
  let contents = null;
  const mediaQuery = window.matchMedia('(max-width: 799.98px)');

  function init() {
    toggles = document.querySelectorAll('[data-friends-toggle]');
    contents = document.querySelectorAll('[data-friends-content]');

    if (!toggles || !contents) {
      return;
    }

    toggles.forEach(function (toggle, index) {
      toggle.addEventListener('click', function (event) {
        event.preventDefault();
        if (mediaQuery.matches === false) return;

        if (toggle.getAttribute('aria-expanded') === 'false') {
          showContent(index);
        } else {
          hideContent(index);
        }
      });
    });

    mediaQuery.addEventListener('change', function (event) {
      handleMediaChange();
    });

    handleMediaChange();
  }

  function showContent(index) {
    toggles[index].setAttribute('aria-expanded', true);
    contents[index].setAttribute('aria-hidden', false);
  }

  function hideContent(index) {
    toggles[index].setAttribute('aria-expanded', false);
    contents[index].setAttribute('aria-hidden', true);
  }

  function handleMediaChange() {
    if (mediaQuery.matches) {
      // Mobile
      toggles.forEach(function (toggle, index) {
        hideContent(index);
      });
    } else {
      // Desktop
      toggles.forEach(function (toggle, index) {
        showContent(index);
      });
    }
  }

  return {
    init: init,
  };
})();


util.onDocumentReady(function () {
  const body = document.getElementById('body');

  app.general.init();
  app.tracking.init();
  app.searchBox.init();
  app.friends.init();
});;