');
+ }
+
+ item.inlineElement = el;
+ return el;
+ }
+
+ mfp.updateStatus('ready');
+ mfp._parseMarkup(template, {}, item);
+ return template;
+ }
+ }
+ });
+
+ /*>>inline*/
+
+ /*>>ajax*/
+ var AJAX_NS = 'ajax',
+ _ajaxCur,
+ _removeAjaxCursor = function() {
+ if(_ajaxCur) {
+ $(document.body).removeClass(_ajaxCur);
+ }
+ },
+ _destroyAjaxRequest = function() {
+ _removeAjaxCursor();
+ if(mfp.req) {
+ mfp.req.abort();
+ }
+ };
+
+ $.magnificPopup.registerModule(AJAX_NS, {
+
+ options: {
+ settings: null,
+ cursor: 'mfp-ajax-cur',
+ tError: '
The content could not be loaded.'
+ },
+
+ proto: {
+ initAjax: function() {
+ mfp.types.push(AJAX_NS);
+ _ajaxCur = mfp.st.ajax.cursor;
+
+ _mfpOn(CLOSE_EVENT+'.'+AJAX_NS, _destroyAjaxRequest);
+ _mfpOn('BeforeChange.' + AJAX_NS, _destroyAjaxRequest);
+ },
+ getAjax: function(item) {
+
+ if(_ajaxCur) {
+ $(document.body).addClass(_ajaxCur);
+ }
+
+ mfp.updateStatus('loading');
+
+ var opts = $.extend({
+ url: item.src,
+ success: function(data, textStatus, jqXHR) {
+ var temp = {
+ data:data,
+ xhr:jqXHR
+ };
+
+ _mfpTrigger('ParseAjax', temp);
+
+ mfp.appendContent( $(temp.data), AJAX_NS );
+
+ item.finished = true;
+
+ _removeAjaxCursor();
+
+ mfp._setFocus();
+
+ setTimeout(function() {
+ mfp.wrap.addClass(READY_CLASS);
+ }, 16);
+
+ mfp.updateStatus('ready');
+
+ _mfpTrigger('AjaxContentAdded');
+ },
+ error: function() {
+ _removeAjaxCursor();
+ item.finished = item.loadError = true;
+ mfp.updateStatus('error', mfp.st.ajax.tError.replace('%url%', item.src));
+ }
+ }, mfp.st.ajax.settings);
+
+ mfp.req = $.ajax(opts);
+
+ return '';
+ }
+ }
+ });
+
+ /*>>ajax*/
+
+ /*>>image*/
+ var _imgInterval,
+ _getTitle = function(item) {
+ if(item.data && item.data.title !== undefined)
+ return item.data.title;
+
+ var src = mfp.st.image.titleSrc;
+
+ if(src) {
+ if($.isFunction(src)) {
+ return src.call(mfp, item);
+ } else if(item.el) {
+ return item.el.attr(src) || '';
+ }
+ }
+ return '';
+ };
+
+ $.magnificPopup.registerModule('image', {
+
+ options: {
+ markup: '
',
+ cursor: 'mfp-zoom-out-cur',
+ titleSrc: 'title',
+ verticalFit: true,
+ tError: '
The image could not be loaded.'
+ },
+
+ proto: {
+ initImage: function() {
+ var imgSt = mfp.st.image,
+ ns = '.image';
+
+ mfp.types.push('image');
+
+ _mfpOn(OPEN_EVENT+ns, function() {
+ if(mfp.currItem.type === 'image' && imgSt.cursor) {
+ $(document.body).addClass(imgSt.cursor);
+ }
+ });
+
+ _mfpOn(CLOSE_EVENT+ns, function() {
+ if(imgSt.cursor) {
+ $(document.body).removeClass(imgSt.cursor);
+ }
+ _window.off('resize' + EVENT_NS);
+ });
+
+ _mfpOn('Resize'+ns, mfp.resizeImage);
+ if(mfp.isLowIE) {
+ _mfpOn('AfterChange', mfp.resizeImage);
+ }
+ },
+ resizeImage: function() {
+ var item = mfp.currItem;
+ if(!item || !item.img) return;
+
+ if(mfp.st.image.verticalFit) {
+ var decr = 0;
+ // fix box-sizing in ie7/8
+ if(mfp.isLowIE) {
+ decr = parseInt(item.img.css('padding-top'), 10) + parseInt(item.img.css('padding-bottom'),10);
+ }
+ item.img.css('max-height', mfp.wH-decr);
+ }
+ },
+ _onImageHasSize: function(item) {
+ if(item.img) {
+
+ item.hasSize = true;
+
+ if(_imgInterval) {
+ clearInterval(_imgInterval);
+ }
+
+ item.isCheckingImgSize = false;
+
+ _mfpTrigger('ImageHasSize', item);
+
+ if(item.imgHidden) {
+ if(mfp.content)
+ mfp.content.removeClass('mfp-loading');
+
+ item.imgHidden = false;
+ }
+
+ }
+ },
+
+ /**
+ * Function that loops until the image has size to display elements that rely on it asap
+ */
+ findImageSize: function(item) {
+
+ var counter = 0,
+ img = item.img[0],
+ mfpSetInterval = function(delay) {
+
+ if(_imgInterval) {
+ clearInterval(_imgInterval);
+ }
+ // decelerating interval that checks for size of an image
+ _imgInterval = setInterval(function() {
+ if(img.naturalWidth > 0) {
+ mfp._onImageHasSize(item);
+ return;
+ }
+
+ if(counter > 200) {
+ clearInterval(_imgInterval);
+ }
+
+ counter++;
+ if(counter === 3) {
+ mfpSetInterval(10);
+ } else if(counter === 40) {
+ mfpSetInterval(50);
+ } else if(counter === 100) {
+ mfpSetInterval(500);
+ }
+ }, delay);
+ };
+
+ mfpSetInterval(1);
+ },
+
+ getImage: function(item, template) {
+
+ var guard = 0,
+
+ // image load complete handler
+ onLoadComplete = function() {
+ if(item) {
+ if (item.img[0].complete) {
+ item.img.off('.mfploader');
+
+ if(item === mfp.currItem){
+ mfp._onImageHasSize(item);
+
+ mfp.updateStatus('ready');
+ }
+
+ item.hasSize = true;
+ item.loaded = true;
+
+ _mfpTrigger('ImageLoadComplete');
+
+ }
+ else {
+ // if image complete check fails 200 times (20 sec), we assume that there was an error.
+ guard++;
+ if(guard < 200) {
+ setTimeout(onLoadComplete,100);
+ } else {
+ onLoadError();
+ }
+ }
+ }
+ },
+
+ // image error handler
+ onLoadError = function() {
+ if(item) {
+ item.img.off('.mfploader');
+ if(item === mfp.currItem){
+ mfp._onImageHasSize(item);
+ mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) );
+ }
+
+ item.hasSize = true;
+ item.loaded = true;
+ item.loadError = true;
+ }
+ },
+ imgSt = mfp.st.image;
+
+
+ var el = template.find('.mfp-img');
+ if(el.length) {
+ var img = document.createElement('img');
+ img.className = 'mfp-img';
+ if(item.el && item.el.find('img').length) {
+ img.alt = item.el.find('img').attr('alt');
+ }
+ item.img = $(img).on('load.mfploader', onLoadComplete).on('error.mfploader', onLoadError);
+ img.src = item.src;
+
+ // without clone() "error" event is not firing when IMG is replaced by new IMG
+ // TODO: find a way to avoid such cloning
+ if(el.is('img')) {
+ item.img = item.img.clone();
+ }
+
+ img = item.img[0];
+ if(img.naturalWidth > 0) {
+ item.hasSize = true;
+ } else if(!img.width) {
+ item.hasSize = false;
+ }
+ }
+
+ mfp._parseMarkup(template, {
+ title: _getTitle(item),
+ img_replaceWith: item.img
+ }, item);
+
+ mfp.resizeImage();
+
+ if(item.hasSize) {
+ if(_imgInterval) clearInterval(_imgInterval);
+
+ if(item.loadError) {
+ template.addClass('mfp-loading');
+ mfp.updateStatus('error', imgSt.tError.replace('%url%', item.src) );
+ } else {
+ template.removeClass('mfp-loading');
+ mfp.updateStatus('ready');
+ }
+ return template;
+ }
+
+ mfp.updateStatus('loading');
+ item.loading = true;
+
+ if(!item.hasSize) {
+ item.imgHidden = true;
+ template.addClass('mfp-loading');
+ mfp.findImageSize(item);
+ }
+
+ return template;
+ }
+ }
+ });
+
+ /*>>image*/
+
+ /*>>zoom*/
+ var hasMozTransform,
+ getHasMozTransform = function() {
+ if(hasMozTransform === undefined) {
+ hasMozTransform = document.createElement('p').style.MozTransform !== undefined;
+ }
+ return hasMozTransform;
+ };
+
+ $.magnificPopup.registerModule('zoom', {
+
+ options: {
+ enabled: false,
+ easing: 'ease-in-out',
+ duration: 300,
+ opener: function(element) {
+ return element.is('img') ? element : element.find('img');
+ }
+ },
+
+ proto: {
+
+ initZoom: function() {
+ var zoomSt = mfp.st.zoom,
+ ns = '.zoom',
+ image;
+
+ if(!zoomSt.enabled || !mfp.supportsTransition) {
+ return;
+ }
+
+ var duration = zoomSt.duration,
+ getElToAnimate = function(image) {
+ var newImg = image.clone().removeAttr('style').removeAttr('class').addClass('mfp-animated-image'),
+ transition = 'all '+(zoomSt.duration/1000)+'s ' + zoomSt.easing,
+ cssObj = {
+ position: 'fixed',
+ zIndex: 9999,
+ left: 0,
+ top: 0,
+ '-webkit-backface-visibility': 'hidden'
+ },
+ t = 'transition';
+
+ cssObj['-webkit-'+t] = cssObj['-moz-'+t] = cssObj['-o-'+t] = cssObj[t] = transition;
+
+ newImg.css(cssObj);
+ return newImg;
+ },
+ showMainContent = function() {
+ mfp.content.css('visibility', 'visible');
+ },
+ openTimeout,
+ animatedImg;
+
+ _mfpOn('BuildControls'+ns, function() {
+ if(mfp._allowZoom()) {
+
+ clearTimeout(openTimeout);
+ mfp.content.css('visibility', 'hidden');
+
+ // Basically, all code below does is clones existing image, puts in on top of the current one and animated it
+
+ image = mfp._getItemToZoom();
+
+ if(!image) {
+ showMainContent();
+ return;
+ }
+
+ animatedImg = getElToAnimate(image);
+
+ animatedImg.css( mfp._getOffset() );
+
+ mfp.wrap.append(animatedImg);
+
+ openTimeout = setTimeout(function() {
+ animatedImg.css( mfp._getOffset( true ) );
+ openTimeout = setTimeout(function() {
+
+ showMainContent();
+
+ setTimeout(function() {
+ animatedImg.remove();
+ image = animatedImg = null;
+ _mfpTrigger('ZoomAnimationEnded');
+ }, 16); // avoid blink when switching images
+
+ }, duration); // this timeout equals animation duration
+
+ }, 16); // by adding this timeout we avoid short glitch at the beginning of animation
+
+
+ // Lots of timeouts...
+ }
+ });
+ _mfpOn(BEFORE_CLOSE_EVENT+ns, function() {
+ if(mfp._allowZoom()) {
+
+ clearTimeout(openTimeout);
+
+ mfp.st.removalDelay = duration;
+
+ if(!image) {
+ image = mfp._getItemToZoom();
+ if(!image) {
+ return;
+ }
+ animatedImg = getElToAnimate(image);
+ }
+
+ animatedImg.css( mfp._getOffset(true) );
+ mfp.wrap.append(animatedImg);
+ mfp.content.css('visibility', 'hidden');
+
+ setTimeout(function() {
+ animatedImg.css( mfp._getOffset() );
+ }, 16);
+ }
+
+ });
+
+ _mfpOn(CLOSE_EVENT+ns, function() {
+ if(mfp._allowZoom()) {
+ showMainContent();
+ if(animatedImg) {
+ animatedImg.remove();
+ }
+ image = null;
+ }
+ });
+ },
+
+ _allowZoom: function() {
+ return mfp.currItem.type === 'image';
+ },
+
+ _getItemToZoom: function() {
+ if(mfp.currItem.hasSize) {
+ return mfp.currItem.img;
+ } else {
+ return false;
+ }
+ },
+
+ // Get element postion relative to viewport
+ _getOffset: function(isLarge) {
+ var el;
+ if(isLarge) {
+ el = mfp.currItem.img;
+ } else {
+ el = mfp.st.zoom.opener(mfp.currItem.el || mfp.currItem);
+ }
+
+ var offset = el.offset();
+ var paddingTop = parseInt(el.css('padding-top'),10);
+ var paddingBottom = parseInt(el.css('padding-bottom'),10);
+ offset.top -= ( $(window).scrollTop() - paddingTop );
+
+
+ /*
+
+ Animating left + top + width/height looks glitchy in Firefox, but perfect in Chrome. And vice-versa.
+
+ */
+ var obj = {
+ width: el.width(),
+ // fix Zepto height+padding issue
+ height: (_isJQ ? el.innerHeight() : el[0].offsetHeight) - paddingBottom - paddingTop
+ };
+
+ // I hate to do this, but there is no another option
+ if( getHasMozTransform() ) {
+ obj['-moz-transform'] = obj['transform'] = 'translate(' + offset.left + 'px,' + offset.top + 'px)';
+ } else {
+ obj.left = offset.left;
+ obj.top = offset.top;
+ }
+ return obj;
+ }
+
+ }
+ });
+
+
+
+ /*>>zoom*/
+
+ /*>>iframe*/
+
+ var IFRAME_NS = 'iframe',
+ _emptyPage = '//about:blank',
+
+ _fixIframeBugs = function(isShowing) {
+ if(mfp.currTemplate[IFRAME_NS]) {
+ var el = mfp.currTemplate[IFRAME_NS].find('iframe');
+ if(el.length) {
+ // reset src after the popup is closed to avoid "video keeps playing after popup is closed" bug
+ if(!isShowing) {
+ el[0].src = _emptyPage;
+ }
+
+ // IE8 black screen bug fix
+ if(mfp.isIE8) {
+ el.css('display', isShowing ? 'block' : 'none');
+ }
+ }
+ }
+ };
+
+ $.magnificPopup.registerModule(IFRAME_NS, {
+
+ options: {
+ markup: '
',
+
+ srcAction: 'iframe_src',
+
+ // we don't care and support only one default type of URL by default
+ patterns: {
+ youtube: {
+ index: 'youtube.com',
+ id: 'v=',
+ src: '//www.youtube.com/embed/%id%?autoplay=1'
+ },
+ vimeo: {
+ index: 'vimeo.com/',
+ id: '/',
+ src: '//player.vimeo.com/video/%id%?autoplay=1'
+ },
+ gmaps: {
+ index: '//maps.google.',
+ src: '%id%&output=embed'
+ }
+ }
+ },
+
+ proto: {
+ initIframe: function() {
+ mfp.types.push(IFRAME_NS);
+
+ _mfpOn('BeforeChange', function(e, prevType, newType) {
+ if(prevType !== newType) {
+ if(prevType === IFRAME_NS) {
+ _fixIframeBugs(); // iframe if removed
+ } else if(newType === IFRAME_NS) {
+ _fixIframeBugs(true); // iframe is showing
+ }
+ }// else {
+ // iframe source is switched, don't do anything
+ //}
+ });
+
+ _mfpOn(CLOSE_EVENT + '.' + IFRAME_NS, function() {
+ _fixIframeBugs();
+ });
+ },
+
+ getIframe: function(item, template) {
+ var embedSrc = item.src;
+ var iframeSt = mfp.st.iframe;
+
+ $.each(iframeSt.patterns, function() {
+ if(embedSrc.indexOf( this.index ) > -1) {
+ if(this.id) {
+ if(typeof this.id === 'string') {
+ embedSrc = embedSrc.substr(embedSrc.lastIndexOf(this.id)+this.id.length, embedSrc.length);
+ } else {
+ embedSrc = this.id.call( this, embedSrc );
+ }
+ }
+ embedSrc = this.src.replace('%id%', embedSrc );
+ return false; // break;
+ }
+ });
+
+ var dataObj = {};
+ if(iframeSt.srcAction) {
+ dataObj[iframeSt.srcAction] = embedSrc;
+ }
+ mfp._parseMarkup(template, dataObj, item);
+
+ mfp.updateStatus('ready');
+
+ return template;
+ }
+ }
+ });
+
+
+
+ /*>>iframe*/
+
+ /*>>gallery*/
+ /**
+ * Get looped index depending on number of slides
+ */
+ var _getLoopedId = function(index) {
+ var numSlides = mfp.items.length;
+ if(index > numSlides - 1) {
+ return index - numSlides;
+ } else if(index < 0) {
+ return numSlides + index;
+ }
+ return index;
+ },
+ _replaceCurrTotal = function(text, curr, total) {
+ return text.replace(/%curr%/gi, curr + 1).replace(/%total%/gi, total);
+ };
+
+ $.magnificPopup.registerModule('gallery', {
+
+ options: {
+ enabled: false,
+ arrowMarkup: '
',
+ preload: [0,2],
+ navigateByImgClick: true,
+ arrows: true,
+
+ tPrev: 'Previous (Left arrow key)',
+ tNext: 'Next (Right arrow key)',
+ tCounter: '%curr% of %total%'
+ },
+
+ proto: {
+ initGallery: function() {
+
+ var gSt = mfp.st.gallery,
+ ns = '.mfp-gallery';
+
+ mfp.direction = true; // true - next, false - prev
+
+ if(!gSt || !gSt.enabled ) return false;
+
+ _wrapClasses += ' mfp-gallery';
+
+ _mfpOn(OPEN_EVENT+ns, function() {
+
+ if(gSt.navigateByImgClick) {
+ mfp.wrap.on('click'+ns, '.mfp-img', function() {
+ if(mfp.items.length > 1) {
+ mfp.next();
+ return false;
+ }
+ });
+ }
+
+ _document.on('keydown'+ns, function(e) {
+ if (e.keyCode === 37) {
+ mfp.prev();
+ } else if (e.keyCode === 39) {
+ mfp.next();
+ }
+ });
+ });
+
+ _mfpOn('UpdateStatus'+ns, function(e, data) {
+ if(data.text) {
+ data.text = _replaceCurrTotal(data.text, mfp.currItem.index, mfp.items.length);
+ }
+ });
+
+ _mfpOn(MARKUP_PARSE_EVENT+ns, function(e, element, values, item) {
+ var l = mfp.items.length;
+ values.counter = l > 1 ? _replaceCurrTotal(gSt.tCounter, item.index, l) : '';
+ });
+
+ _mfpOn('BuildControls' + ns, function() {
+ if(mfp.items.length > 1 && gSt.arrows && !mfp.arrowLeft) {
+ var markup = gSt.arrowMarkup,
+ arrowLeft = mfp.arrowLeft = $( markup.replace(/%title%/gi, gSt.tPrev).replace(/%dir%/gi, 'left') ).addClass(PREVENT_CLOSE_CLASS),
+ arrowRight = mfp.arrowRight = $( markup.replace(/%title%/gi, gSt.tNext).replace(/%dir%/gi, 'right') ).addClass(PREVENT_CLOSE_CLASS);
+
+ arrowLeft.click(function() {
+ mfp.prev();
+ });
+ arrowRight.click(function() {
+ mfp.next();
+ });
+
+ mfp.container.append(arrowLeft.add(arrowRight));
+ }
+ });
+
+ _mfpOn(CHANGE_EVENT+ns, function() {
+ if(mfp._preloadTimeout) clearTimeout(mfp._preloadTimeout);
+
+ mfp._preloadTimeout = setTimeout(function() {
+ mfp.preloadNearbyImages();
+ mfp._preloadTimeout = null;
+ }, 16);
+ });
+
+
+ _mfpOn(CLOSE_EVENT+ns, function() {
+ _document.off(ns);
+ mfp.wrap.off('click'+ns);
+ mfp.arrowRight = mfp.arrowLeft = null;
+ });
+
+ },
+ next: function() {
+ mfp.direction = true;
+ mfp.index = _getLoopedId(mfp.index + 1);
+ mfp.updateItemHTML();
+ },
+ prev: function() {
+ mfp.direction = false;
+ mfp.index = _getLoopedId(mfp.index - 1);
+ mfp.updateItemHTML();
+ },
+ goTo: function(newIndex) {
+ mfp.direction = (newIndex >= mfp.index);
+ mfp.index = newIndex;
+ mfp.updateItemHTML();
+ },
+ preloadNearbyImages: function() {
+ var p = mfp.st.gallery.preload,
+ preloadBefore = Math.min(p[0], mfp.items.length),
+ preloadAfter = Math.min(p[1], mfp.items.length),
+ i;
+
+ for(i = 1; i <= (mfp.direction ? preloadAfter : preloadBefore); i++) {
+ mfp._preloadItem(mfp.index+i);
+ }
+ for(i = 1; i <= (mfp.direction ? preloadBefore : preloadAfter); i++) {
+ mfp._preloadItem(mfp.index-i);
+ }
+ },
+ _preloadItem: function(index) {
+ index = _getLoopedId(index);
+
+ if(mfp.items[index].preloaded) {
+ return;
+ }
+
+ var item = mfp.items[index];
+ if(!item.parsed) {
+ item = mfp.parseEl( index );
+ }
+
+ _mfpTrigger('LazyLoad', item);
+
+ if(item.type === 'image') {
+ item.img = $('
![]()
').on('load.mfploader', function() {
+ item.hasSize = true;
+ }).on('error.mfploader', function() {
+ item.hasSize = true;
+ item.loadError = true;
+ _mfpTrigger('LazyLoadError', item);
+ }).attr('src', item.src);
+ }
+
+
+ item.preloaded = true;
+ }
+ }
+ });
+
+ /*>>gallery*/
+
+ /*>>retina*/
+
+ var RETINA_NS = 'retina';
+
+ $.magnificPopup.registerModule(RETINA_NS, {
+ options: {
+ replaceSrc: function(item) {
+ return item.src.replace(/\.\w+$/, function(m) { return '@2x' + m; });
+ },
+ ratio: 1 // Function or number. Set to 1 to disable.
+ },
+ proto: {
+ initRetina: function() {
+ if(window.devicePixelRatio > 1) {
+
+ var st = mfp.st.retina,
+ ratio = st.ratio;
+
+ ratio = !isNaN(ratio) ? ratio : ratio();
+
+ if(ratio > 1) {
+ _mfpOn('ImageHasSize' + '.' + RETINA_NS, function(e, item) {
+ item.img.css({
+ 'max-width': item.img[0].naturalWidth / ratio,
+ 'width': '100%'
+ });
+ });
+ _mfpOn('ElementParse' + '.' + RETINA_NS, function(e, item) {
+ item.src = st.replaceSrc(item, ratio);
+ });
+ }
+ }
+
+ }
+ }
+ });
+
+ /*>>retina*/
+ _checkInstance(); }));
\ No newline at end of file
diff --git a/assets/js/plugins/smooth-scroll.js b/assets/js/plugins/smooth-scroll.js
new file mode 100644
index 000000000..c4179a731
--- /dev/null
+++ b/assets/js/plugins/smooth-scroll.js
@@ -0,0 +1,650 @@
+/*!
+ * smooth-scroll v16.1.2
+ * Animate scrolling to anchor links
+ * (c) 2020 Chris Ferdinandi
+ * MIT License
+ * http://github.com/cferdinandi/smooth-scroll
+ */
+
+(function (root, factory) {
+ if (typeof define === 'function' && define.amd) {
+ define([], (function () {
+ return factory(root);
+ }));
+ } else if (typeof exports === 'object') {
+ module.exports = factory(root);
+ } else {
+ root.SmoothScroll = factory(root);
+ }
+})(typeof global !== 'undefined' ? global : typeof window !== 'undefined' ? window : this, (function (window) {
+
+ 'use strict';
+
+ //
+ // Default settings
+ //
+
+ var defaults = {
+
+ // Selectors
+ ignore: '[data-scroll-ignore]',
+ header: null,
+ topOnEmptyHash: true,
+
+ // Speed & Duration
+ speed: 500,
+ speedAsDuration: false,
+ durationMax: null,
+ durationMin: null,
+ clip: true,
+ offset: 0,
+
+ // Easing
+ easing: 'easeInOutCubic',
+ customEasing: null,
+
+ // History
+ updateURL: true,
+ popstate: true,
+
+ // Custom Events
+ emitEvents: true
+
+ };
+
+
+ //
+ // Utility Methods
+ //
+
+ /**
+ * Check if browser supports required methods
+ * @return {Boolean} Returns true if all required methods are supported
+ */
+ var supports = function () {
+ return (
+ 'querySelector' in document &&
+ 'addEventListener' in window &&
+ 'requestAnimationFrame' in window &&
+ 'closest' in window.Element.prototype
+ );
+ };
+
+ /**
+ * Merge two or more objects together.
+ * @param {Object} objects The objects to merge together
+ * @returns {Object} Merged values of defaults and options
+ */
+ var extend = function () {
+ var merged = {};
+ Array.prototype.forEach.call(arguments, (function (obj) {
+ for (var key in obj) {
+ if (!obj.hasOwnProperty(key)) return;
+ merged[key] = obj[key];
+ }
+ }));
+ return merged;
+ };
+
+ /**
+ * Check to see if user prefers reduced motion
+ * @param {Object} settings Script settings
+ */
+ var reduceMotion = function () {
+ if ('matchMedia' in window && window.matchMedia('(prefers-reduced-motion)').matches) {
+ return true;
+ }
+ return false;
+ };
+
+ /**
+ * Get the height of an element.
+ * @param {Node} elem The element to get the height of
+ * @return {Number} The element's height in pixels
+ */
+ var getHeight = function (elem) {
+ return parseInt(window.getComputedStyle(elem).height, 10);
+ };
+
+ /**
+ * Escape special characters for use with querySelector
+ * @author Mathias Bynens
+ * @link https://github.com/mathiasbynens/CSS.escape
+ * @param {String} id The anchor ID to escape
+ */
+ var escapeCharacters = function (id) {
+
+ // Remove leading hash
+ if (id.charAt(0) === '#') {
+ id = id.substr(1);
+ }
+
+ var string = String(id);
+ var length = string.length;
+ var index = -1;
+ var codeUnit;
+ var result = '';
+ var firstCodeUnit = string.charCodeAt(0);
+ while (++index < length) {
+ codeUnit = string.charCodeAt(index);
+ // Note: there’s no need to special-case astral symbols, surrogate
+ // pairs, or lone surrogates.
+
+ // If the character is NULL (U+0000), then throw an
+ // `InvalidCharacterError` exception and terminate these steps.
+ if (codeUnit === 0x0000) {
+ throw new InvalidCharacterError(
+ 'Invalid character: the input contains U+0000.'
+ );
+ }
+
+ if (
+ // If the character is in the range [\1-\1F] (U+0001 to U+001F) or is
+ // U+007F, […]
+ (codeUnit >= 0x0001 && codeUnit <= 0x001F) || codeUnit == 0x007F ||
+ // If the character is the first character and is in the range [0-9]
+ // (U+0030 to U+0039), […]
+ (index === 0 && codeUnit >= 0x0030 && codeUnit <= 0x0039) ||
+ // If the character is the second character and is in the range [0-9]
+ // (U+0030 to U+0039) and the first character is a `-` (U+002D), […]
+ (
+ index === 1 &&
+ codeUnit >= 0x0030 && codeUnit <= 0x0039 &&
+ firstCodeUnit === 0x002D
+ )
+ ) {
+ // http://dev.w3.org/csswg/cssom/#escape-a-character-as-code-point
+ result += '\\' + codeUnit.toString(16) + ' ';
+ continue;
+ }
+
+ // If the character is not handled by one of the above rules and is
+ // greater than or equal to U+0080, is `-` (U+002D) or `_` (U+005F), or
+ // is in one of the ranges [0-9] (U+0030 to U+0039), [A-Z] (U+0041 to
+ // U+005A), or [a-z] (U+0061 to U+007A), […]
+ if (
+ codeUnit >= 0x0080 ||
+ codeUnit === 0x002D ||
+ codeUnit === 0x005F ||
+ codeUnit >= 0x0030 && codeUnit <= 0x0039 ||
+ codeUnit >= 0x0041 && codeUnit <= 0x005A ||
+ codeUnit >= 0x0061 && codeUnit <= 0x007A
+ ) {
+ // the character itself
+ result += string.charAt(index);
+ continue;
+ }
+
+ // Otherwise, the escaped character.
+ // http://dev.w3.org/csswg/cssom/#escape-a-character
+ result += '\\' + string.charAt(index);
+
+ }
+
+ // Return sanitized hash
+ return '#' + result;
+
+ };
+
+ /**
+ * Calculate the easing pattern
+ * @link https://gist.github.com/gre/1650294
+ * @param {String} type Easing pattern
+ * @param {Number} time Time animation should take to complete
+ * @returns {Number}
+ */
+ var easingPattern = function (settings, time) {
+ var pattern;
+
+ // Default Easing Patterns
+ if (settings.easing === 'easeInQuad') pattern = time * time; // accelerating from zero velocity
+ if (settings.easing === 'easeOutQuad') pattern = time * (2 - time); // decelerating to zero velocity
+ if (settings.easing === 'easeInOutQuad') pattern = time < 0.5 ? 2 * time * time : -1 + (4 - 2 * time) * time; // acceleration until halfway, then deceleration
+ if (settings.easing === 'easeInCubic') pattern = time * time * time; // accelerating from zero velocity
+ if (settings.easing === 'easeOutCubic') pattern = (--time) * time * time + 1; // decelerating to zero velocity
+ if (settings.easing === 'easeInOutCubic') pattern = time < 0.5 ? 4 * time * time * time : (time - 1) * (2 * time - 2) * (2 * time - 2) + 1; // acceleration until halfway, then deceleration
+ if (settings.easing === 'easeInQuart') pattern = time * time * time * time; // accelerating from zero velocity
+ if (settings.easing === 'easeOutQuart') pattern = 1 - (--time) * time * time * time; // decelerating to zero velocity
+ if (settings.easing === 'easeInOutQuart') pattern = time < 0.5 ? 8 * time * time * time * time : 1 - 8 * (--time) * time * time * time; // acceleration until halfway, then deceleration
+ if (settings.easing === 'easeInQuint') pattern = time * time * time * time * time; // accelerating from zero velocity
+ if (settings.easing === 'easeOutQuint') pattern = 1 + (--time) * time * time * time * time; // decelerating to zero velocity
+ if (settings.easing === 'easeInOutQuint') pattern = time < 0.5 ? 16 * time * time * time * time * time : 1 + 16 * (--time) * time * time * time * time; // acceleration until halfway, then deceleration
+
+ // Custom Easing Patterns
+ if (!!settings.customEasing) pattern = settings.customEasing(time);
+
+ return pattern || time; // no easing, no acceleration
+ };
+
+ /**
+ * Determine the document's height
+ * @returns {Number}
+ */
+ var getDocumentHeight = function () {
+ return Math.max(
+ document.body.scrollHeight, document.documentElement.scrollHeight,
+ document.body.offsetHeight, document.documentElement.offsetHeight,
+ document.body.clientHeight, document.documentElement.clientHeight
+ );
+ };
+
+ /**
+ * Calculate how far to scroll
+ * Clip support added by robjtede - https://github.com/cferdinandi/smooth-scroll/issues/405
+ * @param {Element} anchor The anchor element to scroll to
+ * @param {Number} headerHeight Height of a fixed header, if any
+ * @param {Number} offset Number of pixels by which to offset scroll
+ * @param {Boolean} clip If true, adjust scroll distance to prevent abrupt stops near the bottom of the page
+ * @returns {Number}
+ */
+ var getEndLocation = function (anchor, headerHeight, offset, clip) {
+ var location = 0;
+ if (anchor.offsetParent) {
+ do {
+ location += anchor.offsetTop;
+ anchor = anchor.offsetParent;
+ } while (anchor);
+ }
+ location = Math.max(location - headerHeight - offset, 0);
+ if (clip) {
+ location = Math.min(location, getDocumentHeight() - window.innerHeight);
+ }
+ return location;
+ };
+
+ /**
+ * Get the height of the fixed header
+ * @param {Node} header The header
+ * @return {Number} The height of the header
+ */
+ var getHeaderHeight = function (header) {
+ return !header ? 0 : (getHeight(header) + header.offsetTop);
+ };
+
+ /**
+ * Calculate the speed to use for the animation
+ * @param {Number} distance The distance to travel
+ * @param {Object} settings The plugin settings
+ * @return {Number} How fast to animate
+ */
+ var getSpeed = function (distance, settings) {
+ var speed = settings.speedAsDuration ? settings.speed : Math.abs(distance / 1000 * settings.speed);
+ if (settings.durationMax && speed > settings.durationMax) return settings.durationMax;
+ if (settings.durationMin && speed < settings.durationMin) return settings.durationMin;
+ return parseInt(speed, 10);
+ };
+
+ var setHistory = function (options) {
+
+ // Make sure this should run
+ if (!history.replaceState || !options.updateURL || history.state) return;
+
+ // Get the hash to use
+ var hash = window.location.hash;
+ hash = hash ? hash : '';
+
+ // Set a default history
+ history.replaceState(
+ {
+ smoothScroll: JSON.stringify(options),
+ anchor: hash ? hash : window.pageYOffset
+ },
+ document.title,
+ hash ? hash : window.location.href
+ );
+
+ };
+
+ /**
+ * Update the URL
+ * @param {Node} anchor The anchor that was scrolled to
+ * @param {Boolean} isNum If true, anchor is a number
+ * @param {Object} options Settings for Smooth Scroll
+ */
+ var updateURL = function (anchor, isNum, options) {
+
+ // Bail if the anchor is a number
+ if (isNum) return;
+
+ // Verify that pushState is supported and the updateURL option is enabled
+ if (!history.pushState || !options.updateURL) return;
+
+ // Update URL
+ history.pushState(
+ {
+ smoothScroll: JSON.stringify(options),
+ anchor: anchor.id
+ },
+ document.title,
+ anchor === document.documentElement ? '#top' : '#' + anchor.id
+ );
+
+ };
+
+ /**
+ * Bring the anchored element into focus
+ * @param {Node} anchor The anchor element
+ * @param {Number} endLocation The end location to scroll to
+ * @param {Boolean} isNum If true, scroll is to a position rather than an element
+ */
+ var adjustFocus = function (anchor, endLocation, isNum) {
+
+ // Is scrolling to top of page, blur
+ if (anchor === 0) {
+ document.body.focus();
+ }
+
+ // Don't run if scrolling to a number on the page
+ if (isNum) return;
+
+ // Otherwise, bring anchor element into focus
+ anchor.focus();
+ if (document.activeElement !== anchor) {
+ anchor.setAttribute('tabindex', '-1');
+ anchor.focus();
+ anchor.style.outline = 'none';
+ }
+ window.scrollTo(0 , endLocation);
+
+ };
+
+ /**
+ * Emit a custom event
+ * @param {String} type The event type
+ * @param {Object} options The settings object
+ * @param {Node} anchor The anchor element
+ * @param {Node} toggle The toggle element
+ */
+ var emitEvent = function (type, options, anchor, toggle) {
+ if (!options.emitEvents || typeof window.CustomEvent !== 'function') return;
+ var event = new CustomEvent(type, {
+ bubbles: true,
+ detail: {
+ anchor: anchor,
+ toggle: toggle
+ }
+ });
+ document.dispatchEvent(event);
+ };
+
+
+ //
+ // SmoothScroll Constructor
+ //
+
+ var SmoothScroll = function (selector, options) {
+
+ //
+ // Variables
+ //
+
+ var smoothScroll = {}; // Object for public APIs
+ var settings, anchor, toggle, fixedHeader, eventTimeout, animationInterval;
+
+
+ //
+ // Methods
+ //
+
+ /**
+ * Cancel a scroll-in-progress
+ */
+ smoothScroll.cancelScroll = function (noEvent) {
+ cancelAnimationFrame(animationInterval);
+ animationInterval = null;
+ if (noEvent) return;
+ emitEvent('scrollCancel', settings);
+ };
+
+ /**
+ * Start/stop the scrolling animation
+ * @param {Node|Number} anchor The element or position to scroll to
+ * @param {Element} toggle The element that toggled the scroll event
+ * @param {Object} options
+ */
+ smoothScroll.animateScroll = function (anchor, toggle, options) {
+
+ // Cancel any in progress scrolls
+ smoothScroll.cancelScroll();
+
+ // Local settings
+ var _settings = extend(settings || defaults, options || {}); // Merge user options with defaults
+
+ // Selectors and variables
+ var isNum = Object.prototype.toString.call(anchor) === '[object Number]' ? true : false;
+ var anchorElem = isNum || !anchor.tagName ? null : anchor;
+ if (!isNum && !anchorElem) return;
+ var startLocation = window.pageYOffset; // Current location on the page
+ if (_settings.header && !fixedHeader) {
+ // Get the fixed header if not already set
+ fixedHeader = document.querySelector(_settings.header);
+ }
+ var headerHeight = getHeaderHeight(fixedHeader);
+ var endLocation = isNum ? anchor : getEndLocation(anchorElem, headerHeight, parseInt((typeof _settings.offset === 'function' ? _settings.offset(anchor, toggle) : _settings.offset), 10), _settings.clip); // Location to scroll to
+ var distance = endLocation - startLocation; // distance to travel
+ var documentHeight = getDocumentHeight();
+ var timeLapsed = 0;
+ var speed = getSpeed(distance, _settings);
+ var start, percentage, position;
+
+ /**
+ * Stop the scroll animation when it reaches its target (or the bottom/top of page)
+ * @param {Number} position Current position on the page
+ * @param {Number} endLocation Scroll to location
+ * @param {Number} animationInterval How much to scroll on this loop
+ */
+ var stopAnimateScroll = function (position, endLocation) {
+
+ // Get the current location
+ var currentLocation = window.pageYOffset;
+
+ // Check if the end location has been reached yet (or we've hit the end of the document)
+ if (position == endLocation || currentLocation == endLocation || ((startLocation < endLocation && window.innerHeight + currentLocation) >= documentHeight)) {
+
+ // Clear the animation timer
+ smoothScroll.cancelScroll(true);
+
+ // Bring the anchored element into focus
+ adjustFocus(anchor, endLocation, isNum);
+
+ // Emit a custom event
+ emitEvent('scrollStop', _settings, anchor, toggle);
+
+ // Reset start
+ start = null;
+ animationInterval = null;
+
+ return true;
+
+ }
+ };
+
+ /**
+ * Loop scrolling animation
+ */
+ var loopAnimateScroll = function (timestamp) {
+ if (!start) { start = timestamp; }
+ timeLapsed += timestamp - start;
+ percentage = speed === 0 ? 0 : (timeLapsed / speed);
+ percentage = (percentage > 1) ? 1 : percentage;
+ position = startLocation + (distance * easingPattern(_settings, percentage));
+ window.scrollTo(0, Math.floor(position));
+ if (!stopAnimateScroll(position, endLocation)) {
+ animationInterval = window.requestAnimationFrame(loopAnimateScroll);
+ start = timestamp;
+ }
+ };
+
+ /**
+ * Reset position to fix weird iOS bug
+ * @link https://github.com/cferdinandi/smooth-scroll/issues/45
+ */
+ if (window.pageYOffset === 0) {
+ window.scrollTo(0, 0);
+ }
+
+ // Update the URL
+ updateURL(anchor, isNum, _settings);
+
+ // If the user prefers reduced motion, jump to location
+ if (reduceMotion()) {
+ window.scrollTo(0, Math.floor(endLocation));
+ return;
+ }
+
+ // Emit a custom event
+ emitEvent('scrollStart', _settings, anchor, toggle);
+
+ // Start scrolling animation
+ smoothScroll.cancelScroll(true);
+ window.requestAnimationFrame(loopAnimateScroll);
+
+ };
+
+ /**
+ * If smooth scroll element clicked, animate scroll
+ */
+ var clickHandler = function (event) {
+
+ // Don't run if event was canceled but still bubbled up
+ // By @mgreter - https://github.com/cferdinandi/smooth-scroll/pull/462/
+ if (event.defaultPrevented) return;
+
+ // Don't run if right-click or command/control + click or shift + click
+ if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey) return;
+
+ // Check if event.target has closest() method
+ // By @totegi - https://github.com/cferdinandi/smooth-scroll/pull/401/
+ if (!('closest' in event.target)) return;
+
+ // Check if a smooth scroll link was clicked
+ toggle = event.target.closest(selector);
+ if (!toggle || toggle.tagName.toLowerCase() !== 'a' || event.target.closest(settings.ignore)) return;
+
+ // Only run if link is an anchor and points to the current page
+ if (toggle.hostname !== window.location.hostname || toggle.pathname !== window.location.pathname || !/#/.test(toggle.href)) return;
+
+ // Get an escaped version of the hash
+ var hash;
+ try {
+ hash = escapeCharacters(decodeURIComponent(toggle.hash));
+ } catch(e) {
+ hash = escapeCharacters(toggle.hash);
+ }
+
+ // Get the anchored element
+ var anchor;
+ if (hash === '#') {
+ if (!settings.topOnEmptyHash) return;
+ anchor = document.documentElement;
+ } else {
+ anchor = document.querySelector(hash);
+ }
+ anchor = !anchor && hash === '#top' ? document.documentElement : anchor;
+
+ // If anchored element exists, scroll to it
+ if (!anchor) return;
+ event.preventDefault();
+ setHistory(settings);
+ smoothScroll.animateScroll(anchor, toggle);
+
+ };
+
+ /**
+ * Animate scroll on popstate events
+ */
+ var popstateHandler = function (event) {
+
+ // Stop if history.state doesn't exist (ex. if clicking on a broken anchor link).
+ // fixes `Cannot read property 'smoothScroll' of null` error getting thrown.
+ if (history.state === null) return;
+
+ // Only run if state is a popstate record for this instantiation
+ if (!history.state.smoothScroll || history.state.smoothScroll !== JSON.stringify(settings)) return;
+
+ // Only run if state includes an anchor
+
+ // if (!history.state.anchor && history.state.anchor !== 0) return;
+
+ // Get the anchor
+ var anchor = history.state.anchor;
+ if (typeof anchor === 'string' && anchor) {
+ anchor = document.querySelector(escapeCharacters(history.state.anchor));
+ if (!anchor) return;
+ }
+
+ // Animate scroll to anchor link
+ smoothScroll.animateScroll(anchor, null, {updateURL: false});
+
+ };
+
+ /**
+ * Destroy the current initialization.
+ */
+ smoothScroll.destroy = function () {
+
+ // If plugin isn't already initialized, stop
+ if (!settings) return;
+
+ // Remove event listeners
+ document.removeEventListener('click', clickHandler, false);
+ window.removeEventListener('popstate', popstateHandler, false);
+
+ // Cancel any scrolls-in-progress
+ smoothScroll.cancelScroll();
+
+ // Reset variables
+ settings = null;
+ anchor = null;
+ toggle = null;
+ fixedHeader = null;
+ eventTimeout = null;
+ animationInterval = null;
+
+ };
+
+ /**
+ * Initialize Smooth Scroll
+ * @param {Object} options User settings
+ */
+ var init = function () {
+
+ // feature test
+ if (!supports()) throw 'Smooth Scroll: This browser does not support the required JavaScript methods and browser APIs.';
+
+ // Destroy any existing initializations
+ smoothScroll.destroy();
+
+ // Selectors and variables
+ settings = extend(defaults, options || {}); // Merge user options with defaults
+ fixedHeader = settings.header ? document.querySelector(settings.header) : null; // Get the fixed header
+
+ // When a toggle is clicked, run the click handler
+ document.addEventListener('click', clickHandler, false);
+
+ // If updateURL and popState are enabled, listen for pop events
+ if (settings.updateURL && settings.popstate) {
+ window.addEventListener('popstate', popstateHandler, false);
+ }
+
+ };
+
+
+ //
+ // Initialize plugin
+ //
+
+ init();
+
+
+ //
+ // Public APIs
+ //
+
+ return smoothScroll;
+
+ };
+
+ return SmoothScroll;
+
+}));
diff --git a/assets/js/vendor/jquery/jquery-3.5.1.js b/assets/js/vendor/jquery/jquery-3.5.1.js
new file mode 100644
index 000000000..50937333b
--- /dev/null
+++ b/assets/js/vendor/jquery/jquery-3.5.1.js
@@ -0,0 +1,10872 @@
+/*!
+ * jQuery JavaScript Library v3.5.1
+ * https://jquery.com/
+ *
+ * Includes Sizzle.js
+ * https://sizzlejs.com/
+ *
+ * Copyright JS Foundation and other contributors
+ * Released under the MIT license
+ * https://jquery.org/license
+ *
+ * Date: 2020-05-04T22:49Z
+ */
+( function( global, factory ) {
+
+ "use strict";
+
+ if ( typeof module === "object" && typeof module.exports === "object" ) {
+
+ // For CommonJS and CommonJS-like environments where a proper `window`
+ // is present, execute the factory and get jQuery.
+ // For environments that do not have a `window` with a `document`
+ // (such as Node.js), expose a factory as module.exports.
+ // This accentuates the need for the creation of a real `window`.
+ // e.g. var jQuery = require("jquery")(window);
+ // See ticket #14549 for more info.
+ module.exports = global.document ?
+ factory( global, true ) :
+ function( w ) {
+ if ( !w.document ) {
+ throw new Error( "jQuery requires a window with a document" );
+ }
+ return factory( w );
+ };
+ } else {
+ factory( global );
+ }
+
+// Pass this if window is not defined yet
+} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
+
+// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
+// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
+// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
+// enough that all such attempts are guarded in a try block.
+"use strict";
+
+var arr = [];
+
+var getProto = Object.getPrototypeOf;
+
+var slice = arr.slice;
+
+var flat = arr.flat ? function( array ) {
+ return arr.flat.call( array );
+} : function( array ) {
+ return arr.concat.apply( [], array );
+};
+
+
+var push = arr.push;
+
+var indexOf = arr.indexOf;
+
+var class2type = {};
+
+var toString = class2type.toString;
+
+var hasOwn = class2type.hasOwnProperty;
+
+var fnToString = hasOwn.toString;
+
+var ObjectFunctionString = fnToString.call( Object );
+
+var support = {};
+
+var isFunction = function isFunction( obj ) {
+
+ // Support: Chrome <=57, Firefox <=52
+ // In some browsers, typeof returns "function" for HTML