https://seiya-gss.com/js/fp.js

6
7    if (!Array.prototype.find) {
8      Object.defineProperty(Array.prototype, 'find', {
9        value: function value(predicate) {
10          // 1. Let O be ? ToObject(this value).
11          if (this == null) {
12            throw new TypeError('"this" is null or not defined');
13          }
14
15          var o = Object(this); // 2. Let len be ? ToLength(? Get(O, "length")).
16
17          var len = o.length >>> 0; // 3. If IsCallable(predicate) is false, throw a TypeError exception.
18
19          if (typeof predicate !== 'function') {
20            throw new TypeError('predicate must be a function');
21          } // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
22
23
24          var thisArg = arguments[1]; // 5. Let k be 0.
25
26          var k = 0; // 6. Repeat, while k < len
27
28          while (k < len) {
29            // a. Let Pk be ! ToString(k).
30            // b. Let kValue be ? Get(O, Pk).
31            // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
32            // d. If testResult is true, return kValue.
33            var kValue = o[k];
34
35            if (predicate.call(thisArg, kValue, k, o)) {
36              return kValue;
37            } // e. Increase k by 1.
38
39
40            k++;
41          } // 7. Return undefined.
42
43
44          return undefined;
45        }
46      });
47    }
48
49    // Production steps of ECMA-262, Edition 6, 22.1.2.1
50    if (!Array.from) {
51      Array.from = function () {
52        var toStr = Object.prototype.toString;
53
54        var isCallable = function isCallable(fn) {
55          return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
56        };
57
58        var toInteger = function toInteger(value) {
59          var number = Number(value);
60
61          if (isNaN(number)) {
62            return 0;
63          }
64
65          if (number === 0 || !isFinite(number)) {
66            return number;
67          }
68
69          return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number));
70        };
71
72        var maxSafeInteger = Math.pow(2, 53) - 1;
73
74        var toLength = function toLength(value) {
75          var len = toInteger(value);
76          return Math.min(Math.max(len, 0), maxSafeInteger);
77        }; // The length property of the from method is 1.
78
79
80        return function from(arrayLike
81        /*, mapFn, thisArg */
82        ) {
83          // 1. Let C be the this value.
84          var C = this; // 2. Let items be ToObject(arrayLike).
85
86          var items = Object(arrayLike); // 3. ReturnIfAbrupt(items).
87
88          if (arrayLike == null) {
89            throw new TypeError('Array.from requires an array-like object - not null or undefined');
90          } // 4. If mapfn is undefined, then let mapping be false.
91
92
93          var mapFn = arguments.length > 1 ? arguments[1] : void undefined;
94          var T;
95
96          if (typeof mapFn !== 'undefined') {
97            // 5. else
98            // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
99            if (!isCallable(mapFn)) {
100              throw new TypeError('Array.from: when provided, the second argument must be a function');
101            } // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
102
103
104            if (arguments.length > 2) {
105              T = arguments[2];
106            }
107          } // 10. Let lenValue be Get(items, "length").
108          // 11. Let len be ToLength(lenValue).
109
110
111          var len = toLength(items.length); // 13. If IsConstructor(C) is true, then
112          // 13. a. Let A be the result of calling the [[Construct]] internal method
113          // of C with an argument list containing the single item len.
114          // 14. a. Else, Let A be ArrayCreate(len).
115
116          var A = isCallable(C) ? Object(new C(len)) : new Array(len); // 16. Let k be 0.
117
118          var k = 0; // 17. Repeat, while k < len… (also steps a - h)
119
120          var kValue;
121
122          while (k < len) {
123            kValue = items[k];
124
125            if (mapFn) {
126              A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
127            } else {
128              A[k] = kValue;
129            }
130
131            k += 1;
132          } // 18. Let putStatus be Put(A, "length", len, true).
133
134
135          A.length = len; // 20. Return A.
136
137          return A;
138        };
139      }();
140    }
141
142    var win = window;
143    var doc = document;
144    var isTouchDevice = navigator.userAgent.match(/(iPhone|iPod|iPad|Android|playbook|silk|BlackBerry|BB10|Windows Phone|Tizen|Bada|webOS|IEMobile|Opera Mini)/) || navigator.userAgent.includes("Mac") && "ontouchend" in document; // iPad on iOS 13 detection
145
146    var isMacDevice = /(Mac|iPhone|iPod|iPad)/i.test(win.navigator.userAgent); // @ts-ignore
147
148    var isTouch = 'ontouchstart' in win || navigator.msMaxTouchPoints > 0 || navigator.maxTouchPoints;
149    var isIE11 = !!window.MSInputMethodContext && !!document.documentMode; // taken from https://github.com/udacity/ud891/blob/gh-pages/lesson2-focus/07-modals-and-keyboard-traps/solution/modal.js
150
151    var focusableElementsString = 'a[href], area[href], input:not([disabled]), select:not([disabled]), textarea:not([disabled]), button:not([disabled]), iframe, object, embed, [tabindex="0"], summary:not([disabled]), [contenteditable]'; // cache common elements
152
153    var FP = {
154      test: {},
155      shared: {}
156    };
157    var extensions = ['parallax', 'scrollOverflowReset', 'dragAndMove', 'offsetSections', 'fadingEffect', 'responsiveSlides', 'continuousHorizontal', 'interlockedSlides', 'scrollHorizontally', 'resetSliders', 'cards', 'dropEffect', 'waterEffect'];
158    var isInsideIframe = function () {
159      var inIframe = window.self !== window.top;
160      return function () {
161        return inIframe;
162      };
163    }();
164
165    /**
166    * forEach polyfill for IE
167    * https://developer.mozilla.org/en-US/docs/Web/API/NodeList/forEach#Browser_Compatibility
168    */
169
170    if (win.NodeList && !NodeList.prototype.forEach) {
171      NodeList.prototype.forEach = function (callback, thisArg) {
172        thisArg = thisArg || window;
173
174        for (var i = 0; i < this.length; i++) {
175          callback.call(thisArg, this[i], i, this);
176        }
177      };
178    }
179
180    if (typeof Object.assign != 'function') {
181      // Must be writable: true, enumerable: false, configurable: true
182      Object.defineProperty(Object, 'assign', {
183        value: function assign(target, varArgs) {
184
185          if (target == null) {
186            // TypeError if undefined or null
187            throw new TypeError('Cannot convert undefined or null to object');
188          }
189
190          var to = Object(target);
191
192          for (var index = 1; index < arguments.length; index++) {
193            var nextSource = arguments[index];
194
195            if (nextSource != null) {
196              // Skip over if undefined or null
197              for (var nextKey in nextSource) {
198                // Avoid bugs when hasOwnProperty is shadowed
199                if (Object.prototype.hasOwnProperty.call(nextSource, nextKey)) {
200                  to[nextKey] = nextSource[nextKey];
201                }
202              }
203            }
204          }
205
206          return to;
207        },
208        writable: true,
209        configurable: true
210      });
211    }
212
213    // https://stackoverflow.com/questions/51719553/padstart-not-working-in-ie11
214    // https://github.com/behnammodi/polyfill/blob/master/string.polyfill.js
215    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
216    if (!String.prototype.padStart) {
217      String.prototype.padStart = function padStart(targetLength, padString) {
218        targetLength = targetLength >> 0; //truncate if number or convert non-number to 0;
219
220        padString = String(typeof padString !== 'undefined' ? padString : ' ');
221
222        if (this.length > targetLength) {
223          return String(this);
224        } else {
225          targetLength = targetLength - this.length;
226
227          if (targetLength > padString.length) {
228            padString += Array.apply(null, Array(targetLength)).map(function () {
229              return padString;
230            }).join("");
231          }
232
233          return padString.slice(0, targetLength) + String(this);
234        }
235      };
236    }
237
238    //utils
239    /**
240    * Shows a message in the console of the given type.
241    */
242
243    function showError(type, text) {
244      win.console && win.console[type] && win.console[type]('fullPage: ' + text);
245    }
246    function isVisible(el) {
247      var style = win.getComputedStyle(el);
248      return style.display !== 'none';
249    }
250    function getVisible(elements) {
251      return Array.from(elements).filter(function (e) {
252        return isVisible(e);
253      });
254    }
255    /**
256    * Equivalent of jQuery function $().
257    */
258
259    function $(selector, context) {
260      context = arguments.length > 1 ? context : document;
261      return context ? context.querySelectorAll(selector) : null;
262    }
263    /**
264    * Extends a given Object properties and its childs.
265    */
266
267    function deepExtend(out) {
268      out = out || {};
269
270      for (var i = 1, len = arguments.length; i < len; ++i) {
271        var obj = arguments[i];
272
273        if (!obj) {
274          continue;
275        }
276
277        for (var key in obj) {
278          if (!obj.hasOwnProperty(key) || key == '__proto__' || key == 'constructor') {
279            continue;
280          } // based on https://javascriptweblog.wordpress.com/2011/08/08/fixing-the-javascript-typeof-operator/
281
282
283          if (Object.prototype.toString.call(obj[key]) === '[object Object]') {
284            out[key] = deepExtend(out[key], obj[key]);
285            continue;
286          }
287
288          out[key] = obj[key];
289        }
290      }
291
292      return out;
293    }
294    /**
295    * Checks if the passed element contains the passed class.
296    */
297
298    function hasClass(el, className) {
299      if (el == null) {
300        return false;
301      }
302
303      return el.classList.contains(className);
304    }
305    /**
306    * Gets the window height. Crossbrowser.
307    */
308
309    function getWindowHeight() {
310      return 'innerHeight' in win ? win.innerHeight : doc.documentElement.offsetHeight;
311    }
312    /**
313    * Gets the window width.
314    */
315
316    function getWindowWidth() {
317      return win.innerWidth;
318    }
319    /**
320    * Set's the CSS properties for the passed item/s.
321    * @param {NodeList|HTMLElement|Object} items
322    * @param {Object} props css properties and values.
323    */
324
325    function css(items, props) {
326      items = getList(items);
327      var key;
328
329      for (key in props) {
330        if (props.hasOwnProperty(key)) {
331          if (key !== null) {
332            for (var i = 0; i < items.length; i++) {
333              var item = items[i];
334              item.style[key] = props[key];
335            }
336          }
337        }
338      }
339
340      return items;
341    }
342    /**
343    * Gets the previous element to the passed element.
344    */
345
346    function prev(item) {
347      return item.previousElementSibling;
348    }
349    /**
350    * Gets the next element to the passed element.
351    */
352
353    function next(item) {
354      return item.nextElementSibling;
355    }
356    /**
357    * Gets the last element from the passed list of elements.
358    */
359
360    function last(item) {
361      return item[item.length - 1];
362    }
363    /**
364    * Gets index from the passed element.
365    * @param {String} selector is optional.
366    */
367
368    function index(item, selector) {
369      item = isArrayOrList(item) ? item[0] : item;
370      var children = selector != null ? $(selector, item.parentNode) : item.parentNode.childNodes;
371      var num = 0;
372
373      for (var i = 0; i < children.length; i++) {
374        if (children[i] == item) return num;
375        if (children[i].nodeType == 1) num++;
376      }
377
378      return -1;
379    }
380    /**
381    * Gets an iterable element for the passed element/s
382    */
383
384    function getList(item) {
385      return !isArrayOrList(item) ? [item] : item;
386    }
387    /**
388    * Adds the display=none property for the passed element/s
389    */
390
391    function hide(el) {
392      el = getList(el);
393
394      for (var i = 0; i < el.length; i++) {
395        el[i].style.display = 'none';
396      }
397
398      return el;
399    }
400    /**
401    * Adds the display=block property for the passed element/s
402    */
403
404    function show(el) {
405      el = getList(el);
406
407      for (var i = 0; i < el.length; i++) {
408        el[i].style.display = 'block';
409      }
410
411      return el;
412    }
413    /**
414    * Checks if the passed element is an iterable element or not
415    */
416
417    function isArrayOrList(el) {
418      return Object.prototype.toString.call(el) === '[object Array]' || Object.prototype.toString.call(el) === '[object NodeList]';
419    }
420    /**
421    * Adds the passed class to the passed element/s
422    */
423
424    function addClass(el, className) {
425      el = getList(el);
426
427      for (var i = 0; i < el.length; i++) {
428        var item = el[i];
429        item.classList.add(className);
430      }
431
432      return el;
433    }
434    /**
435    * Removes the passed class to the passed element/s
436    * @param {String} `className` can be multiple classnames separated by whitespace
437    */
438
439    function removeClass(el, className) {
440      el = getList(el);
441      var classNames = className.split(' ');
442
443      for (var a = 0; a < classNames.length; a++) {
444        className = classNames[a];
445
446        for (var i = 0; i < el.length; i++) {
447          var item = el[i];
448          item.classList.remove(className);
449        }
450      }
451
452      return el;
453    }
454    /**
455    * Appends the given element ot the given parent.
456    */
457
458    function appendTo(el, parent) {
459      parent.appendChild(el);
460    }
461    /**
462    Usage:
463
464    var wrapper = document.createElement('div');
465    wrapper.className = 'fp-slides';
466    wrap($('.slide'), wrapper);
467
468    https://jsfiddle.net/qwzc7oy3/15/ (vanilla)
469    https://jsfiddle.net/oya6ndka/1/ (jquery equivalent)
470    */
471
472    function wrap(toWrap, wrapper, isWrapAll) {
473      var newParent;
474      wrapper = wrapper || doc.createElement('div');
475
476      for (var i = 0; i < toWrap.length; i++) {
477        var item = toWrap[i];
478
479        if (isWrapAll && !i || !isWrapAll) {
480          newParent = wrapper.cloneNode(true);
481          item.parentNode.insertBefore(newParent, item);
482        }
483
484        newParent.appendChild(item);
485      }
486
487      return toWrap;
488    }
489    /**
490    Usage:
491    var wrapper = document.createElement('div');
492    wrapper.className = 'fp-slides';
493    wrap($('.slide'), wrapper);
494
495    https://jsfiddle.net/qwzc7oy3/27/ (vanilla)
496    https://jsfiddle.net/oya6ndka/4/ (jquery equivalent)
497    */
498
499    function wrapAll(toWrap, wrapper) {
500      wrap(toWrap, wrapper, true);
501    }
502    /**
503    * Usage:
504    * wrapInner(document.querySelector('#pepe'), '<div class="test">afdas</div>');
505    * wrapInner(document.querySelector('#pepe'), element);
506    *
507    * https://jsfiddle.net/zexxz0tw/6/
508    *
509    * https://stackoverflow.com/a/21817590/1081396
510    */
511
512    function wrapInner(parent, wrapper) {
513      parent.appendChild(wrapper);
514
515      while (parent.firstChild !== wrapper) {
516        wrapper.appendChild(parent.firstChild);
517      }
518    }
519    /**
520    * Usage:
521    * unwrap(document.querySelector('#pepe'));
522    * unwrap(element);
523    *
524    * https://jsfiddle.net/szjt0hxq/1/
525    *
526    */
527
528    function unwrap(wrapper) {
529      var wrapperContent = doc.createDocumentFragment();
530
531      while (wrapper.firstChild) {
532        wrapperContent.appendChild(wrapper.firstChild);
533      }
534
535      wrapper.parentNode.replaceChild(wrapperContent, wrapper);
536    }
537    /**
538    * http://stackoverflow.com/questions/22100853/dom-pure-javascript-solution-to-jquery-closest-implementation
539    * Returns the element or `false` if there's none
540    */
541
542    function closest(el, selector) {
543      if (el && el.nodeType === 1) {
544        if (matches(el, selector)) {
545          return el;
546        }
547
548        return closest(el.parentNode, selector);
549      }
550
551      return null;
552    }
553    /**
554    * Places one element (rel) after another one or group of them (reference).
555    * @param {HTMLElement} reference
556    * @param {HTMLElement|NodeList|String|Array} el
557    * https://jsfiddle.net/9s97hhzv/1/
558    */
559
560    function after(reference, el) {
561      insertBefore(reference, reference.nextSibling, el);
562    }
563    /**
564    * Places one element (rel) before another one or group of them (reference).
565    * @param {HTMLElement} reference
566    * @param {HTMLElement|NodeList|String|Array} el
567    * https://jsfiddle.net/9s97hhzv/1/
568    */
569
570    function before(reference, el) {
571      insertBefore(reference, reference, el);
572    }
573    /**
574    * Based in https://stackoverflow.com/a/19316024/1081396
575    * and https://stackoverflow.com/a/4793630/1081396
576    */
577
578    function insertBefore(reference, beforeElement, el) {
579      if (!isArrayOrList(el)) {
580        if (typeof el == 'string') {
581          el = createElementFromHTML(el);
582        }
583
584        el = [el];
585      }
586
587      for (var i = 0; i < el.length; i++) {
588        reference.parentNode.insertBefore(el[i], beforeElement);
589      }
590    } //http://stackoverflow.com/questions/3464876/javascript-get-window-x-y-position-for-scroll
591
592    function getScrollTop() {
593      var docElement = doc.documentElement;
594      return (win.pageYOffset || docElement.scrollTop) - (docElement.clientTop || 0);
595    }
596    /**
597    * Gets the siblings of the passed element
598    */
599
600    function siblings(el) {
601      return Array.prototype.filter.call(el.parentNode.children, function (child) {
602        return child !== el;
603      });
604    }
605    function preventDefault(event) {
606      event.preventDefault();
607    }
608    function getAttr(el, attr) {
609      return el.getAttribute(attr);
610    }
611    function docAddEvent(event, callback, options) {
612      doc.addEventListener(event, callback, options === 'undefined' ? null : options);
613    }
614    function windowAddEvent(event, callback, options) {
615      win.addEventListener(event, callback, options === 'undefined' ? null : options);
616    }
617    function docRemoveEvent(event, callback, options) {
618      doc.removeEventListener(event, callback, options === 'undefined' ? null : options);
619    }
620    function windowRemoveEvent(event, callback, options) {
621      win.removeEventListener(event, callback, options === 'undefined' ? null : options);
622    }
623    /**
624    * Determines whether the passed item is of function type.
625    */
626
627    function isFunction(item) {
628      if (typeof item === 'function') {
629        return true;
630      }
631
632      var type = Object.prototype.toString.call(item);
633      return type === '[object Function]' || type === '[object GeneratorFunction]';
634    }
635    /**
636    * Trigger custom events
637    */
638
639    function trigger(el, eventName, data) {
640      var event;
641      data = typeof data === 'undefined' ? {} : data; // Native
642
643      if (typeof win.CustomEvent === "function") {
644        event = new CustomEvent(eventName, {
645          detail: data
646        });
647      } else {
648        event = doc.createEvent('CustomEvent');
649        event.initCustomEvent(eventName, true, true, data);
650      }
651
652      el.dispatchEvent(event);
653    }
654    /**
655    * Polyfill of .matches()
656    */
657
658    function matches(el, selector) {
659      return (el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector).call(el, selector);
660    }
661    /**
662    * Toggles the visibility of the passed element el.
663    */
664
665    function toggle(el, value) {
666      if (typeof value === "boolean") {
667        for (var i = 0; i < el.length; i++) {
668          el[i].style.display = value ? 'block' : 'none';
669        }
670      } //we don't use it in other way, so no else :)
671
672
673      return el;
674    }
675    /**
676    * Creates a HTMLElement from the passed HTML string.
677    * https://stackoverflow.com/a/494348/1081396
678    */
679
680    function createElementFromHTML(htmlString) {
681      var div = doc.createElement('div');
682      div.innerHTML = htmlString.trim(); // Change this to div.childNodes to support multiple top-level nodes
683
684      return div.firstChild;
685    }
686    /**
687    * Removes the passed item/s from the DOM.
688    */
689
690    function remove(items) {
691      items = getList(items);
692
693      for (var i = 0; i < items.length; i++) {
694        var item = items[i];
695
696        if (item && item.parentElement) {
697          item.parentNode.removeChild(item);
698        }
699      }
700    } //https://jsfiddle.net/w1rktecz/
701
702    function untilAll(item, selector, fn) {
703      var sibling = item[fn];
704      var siblings = [];
705
706      while (sibling) {
707        if (matches(sibling, selector) || selector == null) {
708          siblings.push(sibling);
709        }
710
711        sibling = sibling[fn];
712      }
713
714      return siblings;
715    }
716    /**
717    * Gets all next elements matching the passed selector.
718    */
719
720    function nextAll(item, selector) {
721      return untilAll(item, selector, 'nextElementSibling');
722    }
723    /**
724    * Gets all previous elements matching the passed selector.
725    */
726
727    function prevAll(item, selector) {
728      return untilAll(item, selector, 'previousElementSibling');
729    }
730    /**
731    * Converts an object to an array.
732    */
733
734    function toArray(objectData) {
735      return Object.keys(objectData).map(function (key) {
736        return objectData[key];
737      });
738    }
739    function getLast(items) {
740      return items[items.length - 1];
741    }
742    /**
743    * Gets the average of the last `number` elements of the given array.
744    */
745
746    function getAverage(elements, number) {
747      var sum = 0; //taking `number` elements from the end to make the average, if there are not enought, 1
748
749      var lastElements = elements.slice(Math.max(elements.length - number, 1));
750
751      for (var i = 0; i < lastElements.length; i++) {
752        sum = sum + lastElements[i];
753      }
754
755      return Math.ceil(sum / number);
756    }
757    /**
758    * Sets the value for the given attribute from the `data-` attribute with the same suffix
759    * ie: data-srcset ==> srcset  |  data-src ==> src
760    */
761
762    function setSrc(element, attribute) {
763      element.setAttribute(attribute, getAttr(element, 'data-' + attribute));
764      element.removeAttribute('data-' + attribute);
765    }
766    function getParentsUntil(item, topParentSelector) {
767      var parents = [item];
768
769      do {
770        item = item.parentNode;
771        parents.push(item);
772      } while (!matches(item, topParentSelector));
773
774      return parents;
775    }
776    function isInsideInput() {
777      var activeElement = doc.activeElement;
778      return matches(activeElement, 'textarea') || matches(activeElement, 'input') || matches(activeElement, 'select') || getAttr(activeElement, 'contentEditable') == "true" || getAttr(activeElement, 'contentEditable') == '';
779    } //utils are public, so we can use it wherever we want
780    // @ts-ignore
781
782    window["fp_utils"] = {
783      "$": $,
784      "deepExtend": deepExtend,
785      "hasClass": hasClass,
786      "getWindowHeight": getWindowHeight,
787      "css": css,
788      "prev": prev,
789      "next": next,
790      "last": last,
791      "index": index,
792      "getList": getList,
793      "hide": hide,
794      "show": show,
795      "isArrayOrList": isArrayOrList,
796      "addClass": addClass,
797      "removeClass": removeClass,
798      "appendTo": appendTo,
799      "wrap": wrap,
800      "wrapAll": wrapAll,
801      "unwrap": unwrap,
802      "closest": closest,
803      "after": after,
804      "before": before,
805      "insertBefore": insertBefore,
806      "getScrollTop": getScrollTop,
807      "siblings": siblings,
808      "preventDefault": preventDefault,
809      "isFunction": isFunction,
810      "trigger": trigger,
811      "matches": matches,
812      "toggle": toggle,
813      "createElementFromHTML": createElementFromHTML,
814      "remove": remove,
815      // "filter": filter,
816      "untilAll": untilAll,
817      "nextAll": nextAll,
818      "prevAll": prevAll,
819      "showError": showError
820    };
821
822    var utils = /*#__PURE__*/Object.freeze({
823        __proto__: null,
824        showError: showError,
825        isVisible: isVisible,
826        getVisible: getVisible,
827        $: $,
828        deepExtend: deepExtend,
829        hasClass: hasClass,
830        getWindowHeight: getWindowHeight,
831        getWindowWidth: getWindowWidth,
832        css: css,
833        prev: prev,
834        next: next,
835        last: last,
836        index: index,
837        getList: getList,
838        hide: hide,
839        show: show,
840        isArrayOrList: isArrayOrList,
841        addClass: addClass,
842        removeClass: removeClass,
843        appendTo: appendTo,
844        wrap: wrap,
845        wrapAll: wrapAll,
846        wrapInner: wrapInner,
847        unwrap: unwrap,
848        closest: closest,
849        after: after,
850        before: before,
851        insertBefore: insertBefore,
852        getScrollTop: getScrollTop,
853        siblings: siblings,
854        preventDefault: preventDefault,
855        getAttr: getAttr,
856        docAddEvent: docAddEvent,
857        windowAddEvent: windowAddEvent,
858        docRemoveEvent: docRemoveEvent,
859        windowRemoveEvent: windowRemoveEvent,
860        isFunction: isFunction,
861        trigger: trigger,
862        matches: matches,
863        toggle: toggle,
864        createElementFromHTML: createElementFromHTML,
865        remove: remove,
866        untilAll: untilAll,
867        nextAll: nextAll,
868        prevAll: prevAll,
869        toArray: toArray,
870        getLast: getLast,
871        getAverage: getAverage,
872        setSrc: setSrc,
873        getParentsUntil: getParentsUntil,
874        isInsideInput: isInsideInput
875    });
876
877    function _typeof(obj) {
878      "@babel/helpers - typeof";
879
880      if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
881        _typeof = function (obj) {
882          return typeof obj;
883        };
884      } else {
885        _typeof = function (obj) {
886          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
887        };
888      }
889
890      return _typeof(obj);
891    }
892
893    var EventEmitter = {
894      events: {},
895      on: function on(event, listener) {
896        var _this = this;
897
898        if (_typeof(this.events[event]) !== 'object') {
899          this.events[event] = [];
900        }
901
902        this.events[event].push(listener);
903        return function () {
904          return _this.removeListener(event, listener);
905        };
906      },
907      removeListener: function removeListener(event, listener) {
908        if (_typeof(this.events[event]) === 'object') {
909          var idx = this.events[event].indexOf(listener);
910
911          if (idx > -1) {
912            this.events[event].splice(idx, 1);
913          }
914        }
915      },
916      emit: function emit(event) {
917        var _this2 = this;
918
919        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
920          args[_key - 1] = arguments[_key];
921        }
922
923        if (_typeof(this.events[event]) === 'object') {
924          this.events[event].forEach(function (listener) {
925            return listener.apply(_this2, args);
926          });
927        }
928      },
929      once: function once(event, listener) {
930        var _this3 = this;
931
932        var remove = this.on(event, function () {
933          remove();
934
935          for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
936            args[_key2] = arguments[_key2];
937          }
938
939          listener.apply(_this3, args);
940        });
941      }
942    };
943
944    var 

944state = {
945      numSections: 0,
946      numSlides: 0,
947      slides: [],
948      sections: [],
949      activeSection: null,
950      scrollTrigger: null,
951      isBeyondFullpage: false,
952      aboutToScrollToFullPage: false,
953      slideMoving: false,
954      isResizing: false,
955      isScrolling: false,
956      lastScrolledDestiny: undefined,
957      lastScrolledSlide: undefined,
958      activeAnimation: false,
959      canScroll: true,
960      touchDirection: 'none',
961      wheelDirection: 'none',
962      isGrabbing: false,
963      isUsingWheel: false,
964      isWindowFocused: true,
965      previousDestTop: 0,
966      windowsHeight: getWindowHeight(),
967      isDoingContinousVertical: false,
968      timeouts: {},
969      scrollY: 0,
970      scrollX: 0,
971      isFullpageInitDone: false
972    }; // @ts-ignore
973
974    win.state = state;
975    function setState(props) {
976      Object.assign(state, props);
977    }
978    function getState() {
979      return state;
980    }
981    function getActivePanel() {
982      return state.activeSection && state.activeSection.activeSlide ? state.activeSection.activeSlide : state.activeSection;
983    }
984
985    var events = {
986      onAfterRenderNoAnchor: 'onAfterRenderNoAnchor',
987      onClickOrTouch: 'onClickOrTouch',
988      moveSlideLeft: 'moveSlideLeft',
989      moveSlideRight: 'moveSlideRight',
990      onInitialise: 'onInitialise',
991      beforeInit: 'beforeInit',
992      bindEvents: 'bindEvents',
993      onDestroy: 'onDestroy',
994      contentChanged: 'contentChanged',
995      onScrollOverflowScrolled: 'onScrollOverflowScrolled',
996      onScrollPageAndSlide: 'onScrollPageAndSlide',
997      onKeyDown: 'onKeyDown',
998      onMenuClick: 'onMenuClick',
999      scrollPage: 'scrollPage',
1000      landscapeScroll: 'landscapeScroll',
1001      scrollBeyondFullpage: 'scrollBeyondFullpage',
1002      onPerformMovement: 'onPerformMovement',
1003      onSlideLeave: 'onSlideLeave',
1004      onLeave: 'onLeave',
1005      afterSectionLoads: 'afterSectionLoads',
1006      afterSlideLoads: 'afterSlideLoads'
1007    };
1008
1009    EventEmitter.on(events.bindEvents, bindEvents$c);
1010
1011    function bindEvents$c() {
1012      //Scrolls to the section when clicking the navigation bullet
1013      //simulating the jQuery .on('click') event using delegation
1014      ['click', 'touchstart'].forEach(function (eventName) {
1015        docAddEvent(eventName, delegatedEvents);
1016      });
1017      windowAddEvent('focus', focusHandler);
1018      internalEvents();
1019    }
1020
1021    function internalEvents() {
1022      EventEmitter.on(events.onDestroy, onDestroy$9);
1023    }
1024
1025    function delegatedEvents(e) {
1026      EventEmitter.emit(events.onClickOrTouch, {
1027        e: e,
1028        target: e.target
1029      });
1030    }
1031
1032    function onDestroy$9() {
1033      ['click', 'touchstart'].forEach(function (eventName) {
1034        docRemoveEvent(eventName, delegatedEvents);
1035      });
1036    } // changing isWindowFocused to true on focus event
1037
1038
1039    function focusHandler() {
1040      setState({
1041        isWindowFocused: true
1042      });
1043    }
1044
1045    // keeping central set of classnames and selectors
1046    var WRAPPER = 'fullpage-wrapper';
1047    var WRAPPER_SEL = '.' + WRAPPER; // slimscroll
1048
1049    var SCROLLABLE = 'fp-scrollable';
1050
1051    var RESPONSIVE = 'fp-responsive';
1052    var NO_TRANSITION = 'fp-notransition';
1053    var DESTROYED = 'fp-destroyed';
1054    var ENABLED = 'fp-enabled';
1055    var VIEWING_PREFIX = 'fp-viewing';
1056    var ACTIVE = 'active';
1057    var ACTIVE_SEL = '.' + ACTIVE;
1058    var COMPLETELY = 'fp-completely';
1059    var COMPLETELY_SEL = '.' + COMPLETELY;
1060    var LOADED = 'fp-loaded';
1061
1062    var SECTION_DEFAULT_SEL = '.section';
1063    var SECTION = 'fp-section';
1064    var SECTION_SEL = '.' + SECTION;
1065    var SECTION_ACTIVE_SEL = SECTION_SEL + ACTIVE_SEL;
1066    var TABLE_CELL = 'fp-tableCell';
1067    var TABLE_CELL_SEL = '.' + TABLE_CELL;
1068    var AUTO_HEIGHT = 'fp-auto-height';
1069    var AUTO_HEIGHT_SEL = '.' + AUTO_HEIGHT;
1070    var AUTO_HEIGHT_RESPONSIVE = 'fp-auto-height-responsive';
1071    var AUTO_HEIGHT_RESPONSIVE_SEL = '.' + AUTO_HEIGHT_RESPONSIVE;
1072    var NORMAL_SCROLL = 'fp-normal-scroll';
1073
1074    var SECTION_NAV = 'fp-nav';
1075    var SECTION_NAV_SEL = '#' + SECTION_NAV;
1076    var SECTION_NAV_TOOLTIP = 'fp-tooltip';
1077    var SECTION_NAV_TOOLTIP_SEL = '.' + SECTION_NAV_TOOLTIP;
1078    var SHOW_ACTIVE_TOOLTIP = 'fp-show-active'; // slide
1079
1080    var SLIDE_DEFAULT_SEL = '.slide';
1081    var SLIDE = 'fp-slide';
1082    var SLIDE_SEL = '.' + SLIDE;
1083    var SLIDE_ACTIVE_SEL = SLIDE_SEL + ACTIVE_SEL;
1084    var SLIDES_WRAPPER = 'fp-slides';
1085    var SLIDES_WRAPPER_SEL = '.' + SLIDES_WRAPPER;
1086    var SLIDES_CONTAINER = 'fp-slidesContainer';
1087    var SLIDES_CONTAINER_SEL = '.' + SLIDES_CONTAINER;
1088    var TABLE = 'fp-table';
1089    var OVERFLOW = 'fp-overflow';
1090    var OVERFLOW_SEL = '.' + OVERFLOW;
1091    var IS_OVERFLOW = 'fp-is-overflow'; // slide nav
1092
1093    var SLIDES_NAV = 'fp-slidesNav';
1094    var SLIDES_NAV_SEL = '.' + SLIDES_NAV;
1095    var SLIDES_NAV_LINK_SEL = SLIDES_NAV_SEL + ' a';
1096    var SLIDES_STYLED_ARROW = 'fp-arrow';
1097    var SLIDES_ARROW = 'fp-controlArrow';
1098    var SLIDES_ARROW_SEL = '.' + SLIDES_ARROW;
1099    var SLIDES_PREV = 'fp-prev';
1100    var SLIDES_PREV_SEL = '.' + SLIDES_PREV;
1101    var SLIDES_ARROW_PREV_SEL = SLIDES_ARROW_SEL + SLIDES_PREV_SEL;
1102    var SLIDES_NEXT = 'fp-next';
1103    var SLIDES_NEXT_SEL = '.' + SLIDES_NEXT;
1104    // var SLIDES_ARROW_NEXT_SEL = SLIDES_ARROW_SEL + SLIDES_NEXT_SEL; // Watermark
1105
1106    // var WATERMARK = 'fp-watermark';
1107    // var WATERMARK_SEL = '.' + WATERMARK;
1108
1109    var defaultOptions = {
1110      //navigation
1111      menu: false,
1112      anchors: [],
1113      lockAnchors: false,
1114      navigation: false,
1115      navigationPosition: 'right',
1116      navigationTooltips: [],
1117      showActiveTooltip: false,
1118      slidesNavigation: false,
1119      slidesNavPosition: 'bottom',
1120      scrollBar: false,
1121      hybrid: false,
1122      licenseKey: '',
1123      credits: {
1124        "enabled": true,
1125        "label": 'Made with fullPage.js',
1126        "position": 'right'
1127      },
1128      //scrolling
1129      css3: true,
1130      scrollingSpeed: 700,
1131      autoScrolling: true,
1132      fitToSection: true,
1133      fitToSectionDelay: 600,
1134      easing: 'easeInOutCubic',
1135      easingcss3: 'ease',
1136      loopBottom: false,
1137      loopTop: false,
1138      loopHorizontal: true,
1139      continuousVertical: false,
1140      continuousHorizontal: false,
1141      scrollHorizontally: false,
1142      interlockedSlides: false,
1143      dragAndMove: false,
1144      offsetSections: false,
1145      resetSliders: false,
1146      fadingEffect: false,
1147      normalScrollElements: null,
1148      scrollOverflow: true,
1149      scrollOverflowReset: false,
1150      skipIntermediateItems: false,
1151      touchSensitivity: 5,
1152      touchWrapper: null,
1153      bigSectionsDestination: null,
1154      adjustOnNavChange: true,
1155      //Accessibility
1156      keyboardScrolling: true,
1157      animateAnchor: true,
1158      recordHistory: true,
1159      allowCorrectDirection: false,
1160      //design
1161      scrollOverflowMacStyle: true,
1162      controlArrows: true,
1163      controlArrowsHTML: ['<div class="' + SLIDES_STYLED_ARROW + '"></div>', '<div class="' + SLIDES_STYLED_ARROW + '"></div>'],
1164      controlArrowColor: '#fff',
1165      verticalCentered: true,
1166      sectionsColor: [],
1167      paddingTop: 0,
1168      paddingBottom: 0,
1169      fixedElements: null,
1170      responsive: 0,
1171      //backwards compabitility with responsiveWiddth
1172      responsiveWidth: 0,
1173      responsiveHeight: 0,
1174      responsiveSlides: false,
1175      parallax: false,
1176      parallaxOptions: {
1177        type: 'reveal',
1178        percentage: 62,
1179        property: 'translate'
1180      },
1181      cards: false,
1182      cardsOptions: {
1183        perspective: 100,
1184        fadeContent: true,
1185        fadeBackground: true
1186      },
1187      //Custom selectors
1188      sectionSelector: SECTION_DEFAULT_SEL,
1189      slideSelector: SLIDE_DEFAULT_SEL,
1190      //events
1191      afterLoad: null,
1192      beforeLeave: null,
1193      onLeave: null,
1194      afterRender: null,
1195      afterResize: null,
1196      afterReBuild: null,
1197      afterSlideLoad: null,
1198      onSlideLeave: null,
1199      afterResponsive: null,
1200      onScrollOverflow: null,
1201      lazyLoading: true,
1202      lazyLoadThreshold: 0,
1203      observer: true,
1204      scrollBeyondFullpage: tru

1204e
1205    };
1206
1207    var container = null;
1208    var g_initialAnchorsInDom = false;
1209    var originals = deepExtend({}, defaultOptions); //deep copy
1210
1211    var g_options = null;
1212    function getInitialAnchorsInDom() {
1213      return g_initialAnchorsInDom;
1214    }
1215    function setContainer(value) {
1216      container = value;
1217    }
1218    function getContainer(value) {
1219      return container;
1220    }
1221    function getOptions() {
1222      return g_options || defaultOptions;
1223    }
1224    function setOptions(options) {
1225      g_options = deepExtend({}, defaultOptions, options);
1226      originals = Object.assign({}, g_options);
1227    }
1228    function getOriginals() {
1229      return originals;
1230    }
1231    function setOption(name, value) {
1232      defaultOptions[name] = value;
1233    }
1234    /*
1235    * Sets the state for a variable with multiple states (original, and temporal)
1236    * Some variables such as `autoScrolling` or `recordHistory` might change automatically its state when using `responsive` or `autoScrolling:false`.
1237    * This function is used to keep track of both states, the original and the temporal one.
1238    * If type is not 'internal', then we assume the user is globally changing the variable.
1239    */
1240
1241    function setVariableState(variable, value, type) {
1242      g_options[variable] = value;
1243
1244      if (type !== 'internal') {
1245        originals[variable] = value;
1246      }
1247    }
1248    /**
1249    * Setting options from DOM elements if they are not provided.
1250    */
1251
1252    function setOptionsFromDOM() {
1253      //no anchors option? Checking for them in the DOM attributes
1254      if (!getOptions().anchors.length) {
1255        var anchorsAttribute = '[data-anchor]';
1256        var anchors = $(getOptions().sectionSelector.split(',').join(anchorsAttribute + ',') + anchorsAttribute, container);
1257
1258        if (anchors.length && anchors.length === $(getOptions().sectionSelector, container).length) {
1259          g_initialAnchorsInDom = true;
1260          anchors.forEach(function (item) {
1261            getOptions().anchors.push(getAttr(item, 'data-anchor').toString());
1262          });
1263        }
1264      } //no tooltips option? Checking for them in the DOM attributes
1265
1266
1267      if (!getOptions().navigationTooltips.length) {
1268        var tooltipsAttribute = '[data-tooltip]';
1269        var tooltips = $(getOptions().sectionSelector.split(',').join(tooltipsAttribute + ',') + tooltipsAttribute, container);
1270
1271        if (tooltips.length) {
1272          tooltips.forEach(function (item) {
1273            getOptions().navigationTooltips.push(getAttr(item, 'data-tooltip').toString());
1274          });
1275        }
1276      }
1277    }
1278
1279    var plainItem = function plainItem(panel) {
1280      this.anchor = panel.anchor;
1281      this.item = panel.item;
1282      this.index = panel.index();
1283      this.isLast = this.index === panel.item.parentElement.querySelectorAll(panel.selector).length - 1;
1284      this.isFirst = !this.index;
1285      this.isActive = panel.isActive;
1286    };
1287    /**
1288    * Item. Slide or Section objects share the same properties.
1289    */
1290
1291    var Item = function Item(el, selector) {
1292      this.parent = this.parent || null;
1293      this.selector = selector;
1294      this.anchor = getAttr(el, 'data-anchor') || getOptions().anchors[index(el, getOptions().sectionSelector)];
1295      this.item = el;
1296      this.isVisible = isVisible(el);
1297      this.isActive = hasClass(el, ACTIVE);
1298      this.hasScroll = hasClass(el, OVERFLOW) || $(OVERFLOW_SEL, el)[0] != null;
1299      this.isSection = selector === getOptions().sectionSelector;
1300      this.container = closest(el, SLIDES_CONTAINER_SEL) || closest(el, WRAPPER_SEL);
1301
1302      this.index = function () {
1303        return this.siblings().indexOf(this);
1304      };
1305    };
1306
1307    Item.prototype.siblings = function () {
1308      if (this.isSection) {
1309        if (this.isVisible) {
1310          return state.sections;
1311        } else {
1312          return state.sectionsIncludingHidden;
1313        }
1314      }
1315
1316      return this.parent ? this.parent.slides : 0;
1317    };
1318
1319    Item.prototype.prev = function () {
1320      var siblings = this.siblings();
1321      var currentIndex = this.isSection ? siblings.indexOf(this) : this.parent.slides.indexOf(this);
1322      var prevIndex = currentIndex - 1;
1323
1324      if (prevIndex >= 0) {
1325        return siblings[prevIndex];
1326      }
1327
1328      return null;
1329    };
1330
1331    Item.prototype.next = function () {
1332      var siblings = this.siblings();
1333      var currentIndex = this.isSection ? siblings.indexOf(this) : this.parent.slides.indexOf(this);
1334      var nextIndex = currentIndex + 1;
1335
1336      if (nextIndex < siblings.length) {
1337        return siblings[nextIndex];
1338      }
1339
1340      return null;
1341    };
1342
1343    Item.prototype["prevPanel"] = function () {
1344      return this.prev() || (this.parent ? this.parent.prev() : null);
1345    };
1346
1347    Item.prototype["nextPanel"] = function () {
1348      return this.next() || (this.parent ? this.parent.next() : null);
1349    };
1350
1351    Item.prototype.getSiblings = function () {
1352      if (this.isSection) {
1353        return state.sections;
1354      }
1355
1356      return state.panels;
1357    };
1358
1359    function getNodes(panels) {
1360      return panels.map(function (panel) {
1361        return panel.item;
1362      });
1363    }
1364    function getPanelByElement(panels, el) {
1365      return panels.find(function (panel) {
1366        return panel.item === el;
1367      });
1368    }
1369    var Section = function Section(el) {
1370      plainItem.call(this, el);
1371    };
1372    var Slide = function Slide(el) {
1373      plainItem.call(this, el);
1374    };
1375
1376    /**
1377    * Gets the active slide (or section) for the given section
1378    */
1379
1380    function getSlideOrSection(destiny) {
1381      var slide = $(SLIDE_ACTIVE_SEL, destiny);
1382
1383      if (slide.length) {
1384        destiny = slide[0];
1385      }
1386
1387      return destiny;
1388    }
1389    function getSlideOrSectionPanel(panel) {
1390      if (!panel) {
1391        return null;
1392      }
1393
1394      return panel.activeSlide ? panel.activeSlide : panel;
1395    }
1396    function isFullPageAbove() {
1397      return getContainer().getBoundingClientRect().bottom >= 0;
1398    }
1399    /**
1400    * Gets the scrolling settings depending on the plugin autoScrolling option
1401    */
1402
1403    function getScrollSettings(top) {
1404      var options = getOptions();
1405      var position;
1406      var element; //top property animation
1407
1408      if (options.autoScrolling && !options.scrollBar) {
1409        position = -top;
1410        element = $(WRAPPER_SEL)[0];
1411      } //window real scrolling
1412      else {
1413        position = top;
1414        element = window;
1415      }
1416
1417      return {
1418        options: position,
1419        element: element
1420      };
1421    }
1422    /**
1423    * Scrolls the page / slider the given number of pixels.
1424    * It will do it one or another way dependiong on the library's config.
1425    */
1426
1427    function setScrolling(element, val) {
1428      if (!getOptions().autoScrolling || getOptions().scrollBar || element.self != window && hasClass(element, SLIDES_WRAPPER)) {
1429        //scrolling horizontally through the slides?
1430        if (element.self != window && hasClass(element, SLIDES_WRAPPER)) {
1431          element.scrollLeft = val;
1432        } //vertical scroll
1433        else {
1434          element.scrollTo(0, val);
1435        }
1436      } else {
1437        element.style.top = val + 'px';
1438      }
1439    }
1440    /**
1441    * Adds transition animations for the given element
1442    */
1443
1444    function addAnimation(element) {
1445      var transition = 'transform ' + getOptions().scrollingSpeed + 'ms ' + getOptions().easingcss3;
1446      removeClass(element, NO_TRANSITION);
1447      return css(element, {
1448        '-webkit-transition': transition,
1449        'transition': transition
1450      });
1451    }
1452    /**
1453    * Retuns `up` or `down` depending on the scrolling movement to reach its destination
1454    * from the current section.
1455    */
1456
1457    function getYmovement(activeSection, destiny) {
1458      var fromIndex = activeSection.index();
1459      var toIndex = index(destiny, SECTION_SEL);
1460
1461      if (fromIndex == toIndex) {
1462        return 'none';
1463      }
1464
1465      if (fromIndex > toIndex) {
1466        return 'up';
1467      }
1468
1469      return 'down';
1470    }
1471    /**
1472    * Remove transition animations for the given element
1473    */
1474
1475    function removeAnimation(element) {
1476      return addClass(element, NO_TRANSITION);
1477    }
1478    /**
1479    * Returns the cross-browser transform string.
1480    */
1481
1482    function getTransforms(translate3d) {
1483      return {
1484        '-webkit-transform': translate3d,
1485        '-moz-transform': translate3d,
1486        '-ms-transform': translate3d,
1487        'transform': translate3d
1488      };
1489    }
1490
1491    var silentScrollId;
1492    /**
1493    * Adds a css3 transform property to the container class with or without animation depending on the animated param.
1494    */
1495
1496    function transformContainer(translate3d, animated) {
1497      if (animated) {
1498        addAnimation(getContainer());
1499      } else {
1500        removeAnimation(getContainer());
1501      }
1502
1503      clearTimeout(silentScrollId);
1504      css(getContainer(), getTransforms(translate3d));
1505      FP.test.translate3d = translate3d; //syncronously removing the class after the animation has been applied.
1506
1507      silentScrollId = setTimeout(function () {
1508        removeClass(getContainer(), NO_TRANSITION);
1509      }, 10);
1510    }
1511
1512    /**
1513    * Scrolls silently (with no animation) the page to the given Y position.
1514    */
1515
1516    function silentScroll(top) {
1517      // The first section can have a negative value in iOS 10. Not quite sure why: -0.0142822265625
1518      // that's why we round it to 0.
1519      var roundedTop = Math.round(top);
1520
1521      if (getOptions().css3 && getOptions().autoScrolling && !getOptions().scrollBar) {
1522        var translate3d = 'translate3d(0px, -' + roundedTop + 'px, 0px)';
1523        transformContainer(translate3d, false);
1524      } else if (getOptions().autoScrolling && !getOptions().scrollBar) {
1525        css(getContainer(), {
1526          'top': -roundedTop + 'px'
1527        });
1528        FP.test.top = -roundedTop + 'px';
1529      } else {
1530        var scrollSettings = getScrollSettings(roundedTop);
1531        setScrolling(scrollSettings.element, scrollSettings.options);
1532      }
1533    }
1534
1535    FP.setScrollingSpeed = setScrollingSpeed;
1536    /**
1537    * Defines the scrolling speed
1538    */
1539
1540    function setScrollingSpeed(value, type) {
1541      setVariableState('scrollingSpeed', value, type);
1542    }
1543
1544    var $body = null;
1545    var $html = null;
1546    var $htmlBody = null; // caching common elements
1547
1548    function setCache() {
1549      $body = $('body')[0];
1550      $html = $('html')[0];
1551      $htmlBody = $('html, body');
1552    }
1553
1554    //@ts-check
1555
1556    var _g_animateScroll;
1557    /**
1558    * Simulates the animated scrollTop of jQuery. Used when css3:false or scrollBar:true or autoScrolling:false
1559    * http://stackoverflow.com/a/16136789/1081396
1560    */
1561
1562
1563    function scrollTo(element, to, duration, callback) {
1564      var start = getScrolledPosition(element);
1565      var change = to - start;
1566      var isCallbackFired = false;
1567      var startTime;
1568      var wasAnimationActive = state.activeAnimation;
1569      setState({
1570        activeAnimation: true
1571      }); // Cancelling any possible previous animations (io: clicking on nav dots very fast)
1572
1573      if (_g_animateScroll) {
1574        window.cancelAnimationFrame(_g_animateScroll);
1575      }
1576
1577      _g_animateScroll = function g_animateScroll(timestamp) {
1578        if (!startTime) {
1579          startTime = timestamp;
1580        }
1581
1582        var currentTime = Math.floor(timestamp - startTime);
1583
1584        if (state.activeAnimation) {
1585          //in order to stope it from other function whenever we want
1586          var val = to;
1587
1588          if (duration) {
1589            // @ts-ignore
1590            val = win.fp_easings[getOptions().easing](currentTime, start, change, duration);
1591          }
1592
1593          if (currentTime <= duration) {
1594            setScrolling(element, val);
1595          }
1596
1597          if (currentTime < duration) {
1598            window.requestAnimationFrame(_g_animateScroll);
1599          } else if (typeof callback !== 'undefined' && !isCallbackFired) {
1600            setScrolling(element, to);
1601            callback();
1602            setState({
1603              activeAnimation: false
1604            });
1605            isCallbackFired = true;
1606          }
1607        } else if (!isCallbackFired && !wasAnimationActive) {
1608          callback();
1609          setState({
1610            activeAnimation: false
1611          });
1612          isCallbackFired = true;
1613        }
1614      };
1615
1616      window.requestAnimationFrame(_g_animateScroll);
1617    }
1618    /**
1619    * Getting the position of the element to scroll when using jQuery animations
1620    */
1621
1622    function getScrolledPosition(element) {
1623      var position; //is not the window element and is a slide?
1624
1625      if (element.self != win && hasClass(element, SLIDES_WRAPPER)) {
1626        position = element.scrollLeft;
1627      } else if (!getOptions().autoScrolling || getOptions().scrollBar) {
1628        position = getScrollTop();
1629      } else {
1630        position = element.offsetTop;
1631      } //gets the top property of the wrapper
1632
1633
1634      return position;
1635    }
1636
1637    /**
1638    * Makes sure to only create a Panel object if the element exist
1639    */
1640
1641    function nullOrSection(el) {
1642      if (el && !el.item) {
1643        return new Section(new SectionPanel(el));
1644      }
1645
1646      return el ? new Section(el) : null;
1647    }
1648
1649    function nullOrSlide(el) {
1650      return el ? new Slide(el) : null;
1651    }
1652
1653    /**
1654    * Dispatch events & callbacks
1655    */
1656
1657    function fireCallback(eventName, v) {
1658      var eventData = getEventData(eventName, v);
1659      trigger(getContainer(), eventName, eventData);
1660
1661      if (getOptions()[eventName].apply(eventData[Object.keys(eventData)[0]], toArray(eventData)) === false) {
1662        return false;
1663      }
1664
1665      return true;
1666    }
1667    /**
1668    * Gets the event's data for the given event on the right format.
1669    */
1670
1671    function getEventData(eventName, v) {
1672      //using functions to run only the necessary bits within the object
1673      var paramsPerEvent = {
1674        afterRender: function afterRender() {
1675          return {
1676            section: nullOrSection(getState().activeSection),
1677            slide: nullOrSlide(getState().activeSection.activeSlide)
1678          };
1679        },
1680        onLeave: function onLeave() {
1681          return {
1682            origin: nullOrSection(v.items.origin),
1683            destination: nullOrSection(v.items.destination),
1684            direction: v.direction,
1685            trigger: getState().scrollTrigger
1686          };
1687        },
1688        afterLoad: function afterLoad() {
1689          return paramsPerEvent.onLeave();
1690        },
1691        afterSlideLoad: function afterSlideLoad() {
1692          return {
1693            section: nullOrSection(v.items.section),
1694            origin: nullOrSection(v.items.origin),
1695            destination: nullOrSection(v.items.destination),
1696            direction: v.direction,
1697            trigger: getState().scrollTrigger
1698          };
1699        },
1700        onSlideLeave: function onSlideLeave() {
1701          return paramsPerEvent.afterSlideLoad();
1702        },
1703        beforeLeave: function beforeLeave() {
1704          return paramsPerEvent.onLeave();
1705        },
1706        onScrollOverflow: function onScrollOverflow() {
1707          return {
1708            section: nullOrSection(getState().activeSection),
1709            slide: nullOrSlide(getState().activeSection.activeSlide),
1710            position: v.position,
1711            direction: v.direction
1712          };
1713        }
1714      };
1715      return paramsPerEvent[eventName]();
1716    }
1717
1718    function hasAutoPlay(item) {
1719      return item.hasAttribute('data-autoplay') || item.hasAttribute('autoplay');
1720    }
1721    /**
1722    * Plays video and audio elements.
1723    */
1724
1725
1726    function playMedia(destiny) {
1727      var panel = getSlideOrSection(destiny); //playing HTML5 media elements
1728
1729      $('video, audio', panel).forEach(function (element) {
1730        if (hasAutoPlay(element) && typeof element.play === 'function') {
1731          element.play();
1732        }
1733      }); //youtube videos
1734
1735      $('iframe[src*="youtube.com/embed/"]', panel).forEach(function (element) {
1736        if (hasAutoPlay(element)) {
1737          playYoutube(element);
1738        } //in case the URL was not loaded yet. On page load we need time for the new URL (with the API string) to load.
1739
1740
1741        element.onload = function () {
1742          if (hasAutoPlay(element)) {
1743            playYoutube(element);
1744          }
1745        };
1746      });
1747    }
1748    /**
1749    * Plays a youtube video
1750    */
1751
1752    function playYoutube(element) {
1753      element.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}', '*');
1754    }
1755    /**
1756    * Stops video and audio elements.
1757    */
1758
1759
1760    function stopMedia(destiny) {
1761      var panel = getSlideOrSection(destiny); //stopping HTML5 media elements
1762
1763      $('video, audio', panel).forEach(function (element) {
1764        if (!element.hasAttribute('data-keepplaying') && typeof element.pause === 'function') {
1765          element.pause();
1766        }
1767      }); //youtube videos
1768
1769      $('iframe[src*="youtube.com/embed/"]', panel).forEach(function (element) {
1770        if (/youtube\.com\/embed\//.test(getAttr(element, 'src')) && !element.hasAttribute('data-keepplaying')) {
1771          element.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}', '*');
1772        }
1773      });
1774    }
1775    /*
1776    * Enables the Youtube videos API so we can control their flow if necessary.
1777    */
1778
1779    function enableYoutubeAPI() {
1780      $('iframe[src*="youtube.com/embed/"]', getContainer()).forEach(function (item) {
1781        addURLParam(item, 'enablejsapi=1');
1782      });
1783    }
1784    /**
1785    * Adds a new parameter and its value to the `src` of a given element
1786    */
1787
1788    function addURLParam(element, newParam) {
1789      var originalSrc = getAttr(element, 'src');
1790      element.setAttribute('src', originalSrc + getUrlParamSign(originalSrc) + newParam);
1791    }
1792    /*
1793    * Returns the prefix sign to use for a new parameter in an existen URL.
1794    *
1795    * @return {String}  ? | &
1796    */
1797
1798
1799    function getUrlParamSign(url) {
1800      return !/\?/.test(url) ? '?' : '&';
1801    }
1802
1803    /**
1804    * Lazy loads image, video and audio elements.
1805    */
1806
1807    function lazyLoad(destiny) {
1808      if (!getOptions().lazyLoading) {
1809        return;
1810      }
1811
1812      var panel = getSlideOrSection(destiny);
1813      $('img[data-src], img[data-srcset], source[data-src], source[data-srcset], video[data-src], audio[data-src], iframe[data-src]', panel).forEach(function (element) {
1814        ['src', 'srcset'].forEach(function (type) {
1815          var attribute = getAttr(element, 'data-' + type);
1816
1817          if (attribute != null && attribute) {
1818            setSrc(element, type);
1819            element.addEventListener('load', function () {
1820            });
1821          }
1822        });
1823
1824        if (matches(element, 'source')) {
1825          var elementToPlay = closest(element, 'video, audio');
1826
1827          if (elementToPlay) {
1828            elementToPlay.load();
1829
1830            elementToPlay.onloadeddata = function () {
1831            };
1832          }
1833        }
1834      }); // Add fp-loaded class to the panel after lazy loading
1835
1836      addClass(panel, LOADED);
1837    }
1838    function lazyLoadPanels(panel) {
1839      var lazyLoadThresold = getOptions().lazyLoadThreshold;
1840      lazyLoad(panel.item);
1841
1842      if (lazyLoadThresold) {
1843        lazyLoadDirection(panel, 'prev', lazyLoadThresold);
1844        lazyLoadDirection(panel, 'next', lazyLoadThresold);
1845      }
1846    } // Lazy load "count" number of panels in a specific direction
1847
1848    function lazyLoadDirection(startPanel, direction, count) {
1849      var currentPanel = startPanel;
1850
1851      for (var i = 0; i < count && (currentPanel = currentPanel[direction]()); i++) {
1852        

1955    * Gets the name for screen readers for a section/slide navigation bullet.
1956    */
1957
1958    function getBulletLinkName(i, defaultName, item) {
1959      var anchor = defaultName === 'Section' ? getOptions().anchors[i] : getAttr(item, 'data-anchor');
1960      return encodeURI(getOptions().navigationTooltips[i] || anchor || defaultName + ' ' + (i + 1));
1961    }
1962
1963    function slideBulletHandler(e) {
1964      // not all events are cancellable 
1965      // https://www.uriports.com/blog/easy-fix-for-intervention-ignored-attempt-to-cancel-a-touchmove-event-with-cancelable-false/
1966      if (e.cancelable) {
1967        preventDefault(e);
1968      }
1969
1970      setState({
1971        scrollTrigger: 'horizontalNav'
1972      });
1973      /*jshint validthis:true */
1974
1975      var sectionElem = closest(this, SECTION_SEL);
1976      var slides = $(SLIDES_WRAPPER_SEL, closest(this, SECTION_SEL))[0];
1977      var section = getPanelByElement(getState().sections, sectionElem);
1978      var destiny = section.slides[index(closest(this, 'li'))];
1979      EventEmitter.emit(events.landscapeScroll, {
1980        slides: slides,
1981        destination: destiny.item
1982      });
1983    }
1984    /**
1985    * Sets the state for the horizontal bullet navigations.
1986    */
1987
1988    function activeSlidesNavigation(slidesNav, slideIndex) {
1989      if (getOptions().slidesNavigation && slidesNav != null) {
1990        removeClass($(ACTIVE_SEL, slidesNav), ACTIVE);
1991        addClass($('a', $('li', slidesNav)[slideIndex]), ACTIVE);
1992      }
1993    }
1994    /**
1995    * Creates a landscape navigation bar with dots for horizontal sliders.
1996    */
1997
1998    function addSlidesNavigation(section) {
1999      var sectionElem = section.item;
2000      var numSlides = section.slides.length;
2001      appendTo(createElementFromHTML('<div class="' + SLIDES_NAV + '"><ul></ul></div>'), sectionElem);
2002      var nav = $(SLIDES_NAV_SEL, sectionElem)[0]; //top or bottom
2003
2004      addClass(nav, 'fp-' + getOptions().slidesNavPosition);
2005
2006      for (var i = 0; i < numSlides; i++) {
2007        var slide = $(SLIDE_SEL, sectionElem)[i];
2008        appendTo(createElementFromHTML('<li><a href="#"><span class="fp-sr-only">' + getBulletLinkName(i, 'Slide', slide) + '</span><span></span></a></li>'), $('ul', nav)[0]);
2009      } //centering it
2010
2011
2012      css(nav, {
2013        'margin-left': '-' + nav.innerWidth / 2 + 'px'
2014      });
2015      var activeSlideIndex = section.activeSlide ? section.activeSlide.index() : 0;
2016      addClass($('a', $('li', nav)[activeSlideIndex]), ACTIVE);
2017    }
2018
2019    var isScrollAllowed = {};
2020    isScrollAllowed.m = {
2021      'up': true,
2022      'down': true,
2023      'left': true,
2024      'right': true
2025    };
2026    isScrollAllowed.k = deepExtend({}, isScrollAllowed.m);
2027    /**
2028    * Allowing or disallowing the mouse/swipe scroll in a given direction. (not for keyboard)
2029    * @param type m (mouse) or k (keyboard)
2030    */
2031
2032    function setIsScrollAllowed(value, direction, type) {
2033      //up, down, left, right
2034      if (direction !== 'all') {
2035        isScrollAllowed[type][direction] = value;
2036      } //all directions?
2037      else {
2038        Object.keys(isScrollAllowed[type]).forEach(function (key) {
2039          isScrollAllowed[type][key] = value;
2040        });
2041      }
2042    }
2043    function getIsScrollAllowed() {
2044      return isScrollAllowed;
2045    }
2046
2047    EventEmitter.on(events.onClickOrTouch, onClickOrTouch$2);
2048
2049    function onClickOrTouch$2(params) {
2050      var target = params.target;
2051
2052      if (matches(target, SLIDES_ARROW_SEL) || closest(target, SLIDES_ARROW_SEL)) {
2053        slideArrowHandler.call(target, params);
2054      }
2055    } //Scrolling horizontally when clicking on the slider controls.
2056
2057
2058    function slideArrowHandler() {
2059      /*jshint validthis:true */
2060      var section = closest(this, SECTION_SEL);
2061      var isPrevArrow = hasClass(this, SLIDES_PREV) || closest(this, SLIDES_PREV);
2062      /*jshint validthis:true */
2063
2064      if (isPrevArrow) {
2065        if (getIsScrollAllowed().m.left) {
2066          setState({
2067            scrollTrigger: 'slideArrow'
2068          });
2069          EventEmitter.emit(events.moveSlideLeft, {
2070            section: section
2071          });
2072        }
2073      } else {
2074        if (getIsScrollAllowed().m.right) {
2075          setState({
2076            scrollTrigger: 'slideArrow'
2077          });
2078          EventEmitter.emit(events.moveSlideRight, {
2079            section: section
2080          });
2081        }
2082      }
2083    }
2084    /**
2085    * Creates the control arrows for the given section
2086    */
2087
2088
2089    function createSlideArrows(section) {
2090      var sectionElem = section.item;
2091      var arrows = [createElementFromHTML(getOptions().controlArrowsHTML[0]), createElementFromHTML(getOptions().controlArrowsHTML[1])];
2092      after($(SLIDES_WRAPPER_SEL, sectionElem)[0], arrows);
2093      addClass(arrows, SLIDES_ARROW);
2094      addClass(arrows[0], SLIDES_PREV);
2095      addClass(arrows[1], SLIDES_NEXT);
2096
2097      if (getOptions().controlArrowColor !== '#fff') {
2098        css($(SLIDES_ARROW_NEXT_SEL, sectionElem), {
2099          'border-color': 'transparent transparent transparent ' + getOptions().controlArrowColor
2100        });
2101        css($(SLIDES_ARROW_PREV_SEL, sectionElem), {
2102          'border-color': 'transparent ' + getOptions().controlArrowColor + ' transparent transparent'
2103        });
2104      }
2105
2106      if (!getOptions().loopHorizontal) {
2107        hide($(SLIDES_ARROW_PREV_SEL, sectionElem));
2108      }
2109    }
2110    function toggleControlArrows(v) {
2111      if (!getOptions().loopHorizontal && getOptions().controlArrows) {
2112        //hidding it for the fist slide, showing for the rest
2113        toggle($(SLIDES_ARROW_PREV_SEL, v.section), v.slideIndex !== 0); //hidding it for the last slide, showing for the rest
2114
2115        toggle($(SLIDES_ARROW_NEXT_SEL, v.section), next(v.destiny) != null);
2116      }
2117    }
2118
2119    FP.setRecordHistory = setRecordHistory;
2120    /**
2121    * Defines wheter to record the history for each hash change in the URL.
2122    */
2123
2124    function setRecordHistory(value, type) {
2125      setVariableState('recordHistory', value, type);
2126    }
2127
2128    FP.setAutoScrolling = setAutoScrolling;
2129    FP.test.setAutoScrolling = setAutoScrolling;
2130    /**
2131    * Sets the autoScroll option.
2132    * It changes the scroll bar visibility and the history of the site as a result.
2133    */
2134
2135    function setAutoScrolling(value, type) {
2136      //removing the transformation
2137      if (!value) {
2138        silentScroll(0);
2139      }
2140
2141      setVariableState('autoScrolling', value, type);
2142      var element = getState().activeSection.item;
2143
2144      if (getOptions().autoScrolling && !getOptions().scrollBar) {
2145        css($htmlBody, {
2146          'overflow': 'hidden',
2147          'height': '100%'
2148        });
2149        removeClass($body, SCROLLABLE);
2150        setRecordHistory(getOriginals().recordHistory, 'internal'); //for IE touch devices
2151
2152        css(getContainer(), {

2317          addClass($('a[href="#' + name + '"]', nav), ACTIVE);
2318        } else {
2319          addClass($('a', $('li', nav)[sectionIndex]), ACTIVE);
2320        }
2321      }
2322    }
2323    /**
2324    * Creates a vertical navigation bar.
2325    */
2326
2327    function addVerticalNavigation() {
2328      remove($(SECTION_NAV_SEL));
2329      var navigation = doc.createElement('div');
2330      navigation.setAttribute('id', SECTION_NAV);
2331      var divUl = doc.createElement('ul');
2332      navigation.appendChild(divUl);
2333      appendTo(navigation, $body);
2334      var nav = $(SECTION_NAV_SEL)[0];
2335      addClass(nav, 'fp-' + getOptions().navigationPosition);
2336
2337      if (getOptions().showActiveTooltip) {
2338        addClass(nav, SHOW_ACTIVE_TOOLTIP);
2339      }
2340
2341      var li = '';
2342
2343      for (var i = 0; i < getState().sections.length; i++) {
2344        var section = getState().sections[i];
2345        var link = '';
2346
2347        if (getOptions().anchors.length) {
2348          link = section.anchor;
2349        }
2350
2351        li += '<li><a href="#' + encodeURI(link) + '"><span class="fp-sr-only">' + getBulletLinkName(section.index(), 'Section') + '</span><span></span></a>'; // Only add tooltip if needed (defined by user)
2352
2353        var tooltip = getOptions().navigationTooltips[section.index()];
2354
2355        if (typeof tooltip !== 'undefined' && tooltip !== '') {
2356          li += '<div class="' + SECTION_NAV_TOOLTIP + ' fp-' + getOptions().navigationPosition + '">' + tooltip + '</div>';
2357        }
2358
2359        li += '</li>';
2360      }
2361
2362      $('ul', nav)[0].innerHTML = li; //activating the current active section
2363
2364      var bullet = $('li', $(SECTION_NAV_SEL)[0])[getState().activeSection.index()];
2365      addClass($('a', bullet), ACTIVE);
2366    } //Scrolls to the section when clicking the navigation bullet
2367
2368    function sectionBulletHandler(e) {
2369      if (e.preventDefault) {
2370        preventDefault(e);
2371      }
2372
2373      setState({
2374        scrollTrigger: 'verticalNav'
2375      });
2376      /*jshint validthis:true */
2377      // @ts-ignore
2378
2379      var indexBullet = index(closest(this, SECTION_NAV_SEL + ' li'));
2380      EventEmitter.emit(events.scrollPage, {
2381        destination: getState().sections[indexBullet]
2382      });
2383    }
2384
2385    /**
2386    * Sets to active the current menu and vertical nav items.
2387    */
2388
2389    function activateMenuAndNav(anchor, index) {
2390      activateMenuElement(anchor);
2391      activateNavDots(anchor, index);
2392    }
2393    /**
2394    * Activating the website main menu elements according to the given slide name.
2395    */
2396
2397    function activateMenuElement(name) {
2398      if (getOptions().menu && getOptions().menu.length) {
2399        $(getOptions().menu).forEach(function (menu) {
2400          if (menu != null) {
2401            removeClass($(ACTIVE_SEL, menu), ACTIVE);
2402            addClass($('[data-menuanchor="' + name + '"]', menu), ACTIVE);
2403          }
2404        });
2405      }
2406    }
2407
2408    new Date().getTime();
2409    /**
2410     * Triggers the callback once per scroll wheel action.
2411     * Based on scrolling speed delay.
2412     */
2413
2414    var oncePerScroll = function () {
2415      var canTriggerEvent = true;
2416      var prevWheelTime = new Date().getTime();
2417      var result;
2418      var isScrollingOnInit = !win.fullpage_api;
2419      return function (scrollTrigger, callback) {
2420        var currentTime = new Date().getTime();
2421        var timeThreshold = scrollTrigger === 'wheel' ? getOptions().scrollingSpeed : 100;
2422        canTriggerEvent = isScrollingOnInit || currentTime - prevWheelTime >= timeThreshold;
2423        isScrollingOnInit = !win.fullpage_api;
2424
2425        if (canTriggerEvent) {
2426          result = callback();
2427          prevWheelTime = currentTime;
2428        }
2429
2430        return typeof result !== 'undefined' ? result : true;
2431      };
2432    }();
2433
2434    /**
2435    * Fires the wheel event once per mouse wheel trigger.
2436    */
2437
2438    function fireCallbackOncePerScroll(callbackName, params) {
2439      if (!isFunction(getOptions().beforeLeave)) {
2440        return;
2441      }
2442
2443      var result = oncePerScroll(getState().scrollTrigger, function () {
2444        return fireCallback(callbackName, params);
2445      });
2446      return result;
2447    }
2448
2449    FP.moveTo = moveTo;
2450
2451    FP.getScrollY = function () {
2452      return state.scrollY;
2453    };
2454
2455    var g_afterSectionLoadsId;
2456    var g_transitionLapseId;
2457    EventEmitter.on(events.onDestroy, onDestroy$8);
2458    /**
2459    * Scrolls the site to the given element and scrolls to the slide if a callback is given.
2460    */
2461
2462    function scrollPage(section, callback, isMovementUp) {
2463      var element = section.item;
2464
2465      if (element == null) {
2466        return;
2467      } //there's no element to scroll, leaving the function
2468
2469
2470      var dtop = getDestinationPosition(element);
2471      var slideAnchorLink;
2472      var slideIndex; //local variables
2473
2474      var v = {
2475        "element": element,
2476        "callback": callback,
2477        "isMovementUp": isMovementUp,
2478        "dtop": dtop,
2479        "yMovement": getYmovement(getState().activeSection, element),
2480        "anchorLink": section.anchor,
2481        "sectionIndex": section.index(),
2482        "activeSlide": section.activeSlide ? section.activeSlide.item : null,
2483        "leavingSection": getState().activeSection.index() + 1,
2484        //caching the value of isResizing at the momment the function is called
2485        //because it will be checked later inside a setTimeout and the value might change
2486        "localIsResizing": state.isResizing,
2487        "items": {
2488          "origin": getState().activeSection,
2489          "destination": section
2490        },
2491        "direction": null
2492      }; //quiting when destination scroll is the same as the current one
2493
2494      if (getState().activeSection.item == element && !state.isResizing || getOptions().scrollBar && getScrollTop() === v.dtop && !hasClass(element, AUTO_HEIGHT)) {
2495        return;
2496      }
2497
2498      if (v.activeSlide != null) {
2499        slideAnchorLink = getAttr(v.activeSlide, 'data-anchor');
2500        slideIndex = index(v.activeSlide, null);
2501      } //callback (onLeave) if the site is not just resizing and readjusting the slides
2502
2503
2504      if (!v.localIsResizing) {
2505        var direction = v.yMovement; //required for continousVertical
2506
2507        if (typeof isMovementUp !== 'undefined') {
2508          direction = isMovementUp ? 'up' : 'down';
2509        } //for the callback
2510
2511
2512        v.direction = direction;
2513
2514        if (isFunction(getOptions().beforeLeave)) {
2515          if (fireCallbackOncePerScroll('beforeLeave', v) === false) {
2516            return;
2517          }
2518        }
2519
2520        if (isFunction(getOptions().onLeave)) {
2521          if (!fireCallback('onLeave', v)) {
2522            return;
2523          }
2524        }
2525      } // If continuousVertical && we need to wrap around
2526
2527
2528      if (getOptions().autoScrolling && getOptions().continuousVertical && typeof v.isMovementUp !== "undefined" && (!v.isMovementUp && v.yMovement == 'up' || // Intending to scroll down but about to go up or
2529      v.isMovementUp && v.yMovement == 'down')) {
2530        // intending to scroll up but about to go down
2531        v = createInfiniteSections(v);
2532      } //pausing media of the leaving section (if we are not just resizing, as destinatino will be the same one)
2533
2534
2535      if (!v.localIsResizing) {
2536        stopMedia(getState().activeSection.item);
2537      }
2538
2539      addClass(element, ACTIVE);
2540      removeClass(siblings(element), ACTIVE);
2541      updateState();
2542      lazyLoadPanels(section); //preventing from activating the MouseWheelHandler event
2543      //more than once if the page is scrolling
2544
2545      setState({
2546        canScroll: FP.test.isTesting
2547      });
2548      setPageStatus(slideIndex, slideAnchorLink, v.anchorLink);
2549      EventEmitter.emit(events.onLeave, v);
2550      performMovement(v); //flag to avoid callingn `scrollPage()` twice in case of using anchor links
2551
2552      setState({
2553        lastScrolledDestiny: v.anchorLink
2554      }); //avoid firing it twice (as it does also on scroll)
2555
2556      activateMenuAndNav(v.anchorLink, v.sectionIndex);
2557    }
2558
2559    function onDestroy$8() {
2560      clearTimeout(g_afterSectionLoadsId);
2561      clearTimeout(g_transitionLapseId);
2562    }
2563    /**
2564    * Returns the destination Y position based on the scrolling direction and
2565    * the height of the section.
2566    */
2567
2568
2569    function getDestinationPosition(element) {
2570      var elementHeight = element.offsetHeight;
2571      var elementTop = element.offsetTop; //top of the desination will be at the top of the viewport
2572
2573      var position = elementTop;
2574      var isScrollingDown = elementTop > state.previousDestTop;
2575      var sectionBottom = position - getWindowHeight() + elementHeight;
2576      var bigSectionsDestination = getOptions().bigSectionsDestination; //is the destination element bigger than the viewport?
2577
2578      if (elementHeight > getWindowHeight()) {
2579        //scrolling up?
2580        if (!isScrollingDown && !bigSectionsDestination || bigSectionsDestination === 'bottom') {
2581          position = sectionBottom;
2582        }
2583      } //sections equal or smaller than the viewport height && scrolling down? ||  is resizing and its in the last section
2584      else if (isScrollingDown || state.isResizing && next(element) == null) {
2585        //The bottom of the destination will be at the bottom of the viewport
2586        position = sectionBottom;
2587      }
2588      /*
2589      Keeping record of the last scrolled position to determine the scrolling direction.
2590      No conventional methods can be used as the scroll bar might not be present
2591      AND the section might not be active if it is auto-height and didnt reach the middle
2592      of the viewport.
2593      */
2594
2595
2596      setState({
2597        previousDestTop: position
2598      });
2599      return position;
2600    }
2601    /**
2602    * Performs the vertical movement (by CSS3 or by jQuery)
2603    */

2604
2605
2606    function performMovement(v) {
2607      setState({
2608        touchDirection: 'none',
2609        scrollY: Math.round(v.dtop)
2610      });
2611      EventEmitter.emit(events.onPerformMovement, v);
2612      var isFastSpeed = getOptions().scrollingSpeed < 700;
2613      var transitionLapse = isFastSpeed ? 700 : getOptions().scrollingSpeed; // using CSS3 translate functionality
2614
2615      if (getOptions().css3 && getOptions().autoScrolling && !getOptions().scrollBar) {
2616        // The first section can have a negative value in iOS 10. Not quite sure why: -0.0142822265625
2617        // that's why we round it to 0.
2618        var translate3d = 'translate3d(0px, -' + Math.round(v.dtop) + 'px, 0px)';
2619        transformContainer(translate3d, true); //even when the scrollingSpeed is 0 there's a little delay, which might cause the
2620        //scrollingSpeed to change in case of using silentMoveTo();ç
2621
2622        if (getOptions().scrollingSpeed) {
2623          clearTimeout(g_afterSectionLoadsId);
2624          g_afterSectionLoadsId = setTimeout(function () {
2625            afterSectionLoads$1(v); //disabling canScroll when using fastSpeed
2626
2627            setState({
2628              canScroll: !isFastSpeed || FP.test.isTesting
2629            });
2630          }, getOptions().scrollingSpeed);
2631        } else {
2632          afterSectionLoads$1(v);
2633        }
2634      } // using JS to animate
2635      else {
2636        var scrollSettings = getScrollSettings(v.dtop);
2637        FP.test.top = -v.dtop + 'px';
2638        clearTimeout(g_afterSectionLoadsId);
2639        scrollTo(scrollSettings.element, scrollSettings.options, getOptions().scrollingSpeed, function () {
2640          if (getOptions().scrollBar) {
2641            /* Hack!
2642            The timeout prevents setting the most dominant section in the viewport as "active" when the user
2643            scrolled to a smaller section by using the mousewheel (auto scrolling) rather than draging the scroll bar.
2644             When using scrollBar:true It seems like the scroll events still getting propagated even after the scrolling animation has finished.
2645            */
2646            g_afterSectionLoadsId = setTimeout(function () {
2647              afterSectionLoads$1(v);
2648            }, 30);
2649          } else {
2650            afterSectionLoads$1(v); //disabling canScroll when using fastSpeed
2651
2652            setState({
2653              canScroll: !isFastSpeed || FP.test.isTesting
2654            });
2655          }
2656        });
2657      } // enabling canScroll after the minimum transition laps
2658
2659
2660      if (isFastSpeed) {
2661        clearTimeout(g_transitionLapseId);
2662        g_transitionLapseId = setTimeout(function () {
2663          setState({
2664            canScroll: true
2665          });
2666        }, transitionLapse);
2667      }
2668    }
2669    /**
2670    * Actions to do once the section is loaded.
2671    */
2672
2673
2674    function afterSectionLoads$1(v) {
2675      setState({
2676        isBeyondFullpage: false
2677      });
2678      continuousVerticalFixSectionOrder(v); //callback (afterLoad) if the site is not just resizing and readjusting the slides
2679
2680      if (isFunction(getOptions().afterLoad) && !v.localIsResizing) {
2681        fireCallback('afterLoad', v);
2682      }
2683
2684      updateState();
2685
2686      if (!v.localIsResizing) {
2687        playMedia(v.element);
2688      }
2689
2690      addClass(v.element, COMPLETELY);
2691      removeClass(siblings(v.element), COMPLETELY);
2692      lazyLoadOthers();
2693      setState({
2694        canScroll: true
2695      });
2696      EventEmitter.emit(events.afterSectionLoads, v);
2697
2698      if (isFunction(v.callback)) {
2699        v.callback();
2700      }
2701    }
2702
2703    FP.setFitToSection = setFitToSection;
2704    FP.fitToSection = fitToSection;
2705    /**
2706    * Sets fitToSection
2707    */
2708
2709    function setFitToSection(value, type) {
2710      setVariableState('fitToSection', value, type);
2711    }
2712    /**
2713    * Fits the site to the nearest active section
2714    */
2715
2716    function fitToSection() {
2717      //checking fitToSection again in case it was set to false before the timeout delay
2718      if (state.canScroll && getOptions().fitToSection) {
2719        //allows to scroll to an active section and
2720        //if the section is already active, we prevent firing callbacks
2721        setState({
2722          isResizing: true
2723        });
2724        scrollPage(state.activeSection);
2725        setState({
2726          isResizing: false
2727        });
2728      }
2729    }
2730
2731    FP.setResponsive = setResponsive;
2732    /**
2733    * Checks if the site needs to get responsive and disables autoScrolling if so.
2734    * A class `fp-responsive` is added to the plugin's container in case the user wants to use it for his own responsive CSS.
2735    */
2736
2737    function responsive() {
2738      var widthLimit = getOptions().responsive || getOptions().responsiveWidth; //backwards compatiblity
2739
2740      var heightLimit = getOptions().responsiveHeight; //only calculating what we need. Remember its called on the resize event.
2741
2742      var isBreakingPointWidth = widthLimit && win.innerWidth < widthLimit;
2743      var isBreakingPointHeight = heightLimit && win.innerHeight < heightLimit;
2744
2745      if (widthLimit && heightLimit) {
2746        setResponsive(isBreakingPointWidth || isBreakingPointHeight);
2747      } else if (widthLimit) {
2748        setResponsive(isBreakingPointWidth);
2749      } else if (heightLimit) {
2750        setResponsive(isBreakingPointHeight);
2751      }
2752    }
2753    /**
2754    * Turns fullPage.js to normal scrolling mode when the viewport `width` or `height`
2755    * are smaller than the set limit values.
2756    */
2757
2758    function setResponsive(active) {
2759      var isResponsive = isResponsiveMode();
2760
2761      if (active) {
2762        if (!isResponsive) {
2763          setAutoScrolling(false, 'internal');
2764          setFitToSection(false, 'internal');
2765          hide($(SECTION_NAV_SEL));
2766          addClass($body, RESPONSIVE);
2767
2768          if (isFunction(getOptions().afterResponsive)) {
2769            getOptions().afterResponsive.call(getContainer(), active);
2770          }
2771        }
2772      } else if (isResponsive) {
2773        setAutoScrolling(getOriginals().autoScrolling, 'internal');
2774        setFitToSection(getOriginals().autoScrolling, 'internal');
2775        show($(SECTION_NAV_SEL));
2776        removeClass($body, RESPONSIVE);
2777
2778        if (isFunction(getOptions().afterResponsive)) {
2779          getOptions().afterResponsive.call(getContainer(), active);
2780        }
2781      }
2782    }
2783    /**
2784    * Determines whether fullpage.js is in responsive mode or not.
2785    */
2786
2787
2788    function isResponsiveMode() {
2789      return hasClass($body, RESPONSIVE);
2790    }
2791
2792    function addTableClass(element) {
2793      if (!getOptions().verticalCentered) {
2794        return;
2795      } // Overflowing sections when scrollOverflow is disabled will be autoHeight
2796      // and won't require vertical aligment
2797
2798
2799      if (!getOptions().scrollOverflow && scrollOverflowHandler.shouldBeScrollable(element.item)) {
2800        return;
2801      }
2802
2803      if (!scrollOverflowHandler.isScrollable(element)) {
2804        //In case we are styling for the 2nd time as in with reponsiveSlides
2805        if (!hasClass(element.item, TABLE)) {
2806          addClass(element.item, TABLE);
2807        }
2808      }
2809    }
2810
2811    var startingSection = null;
2812    FP.getActiveSection = getActiveSection;
2813    function getStartingSection() {
2814      return startingSection;
2815    }
2816    /**
2817    * Styling vertical sections
2818    */
2819
2820    function styleSection(section) {
2821      var sectionElem = section.item;
2822      var hasSlides = section.allSlidesItems.length;
2823      var index = section.index(); //if no active section is defined, the 1st one will be the default one
2824
2825      if (!getState().activeSection && section.isVisible) {
2826        addClass(sectionElem, ACTIVE);
2827        updateState();
2828      }
2829
2830      if (!startingSection && section.isVisible) {
2831        startingSection = getState().activeSection.item;
2832      }
2833
2834      if (getOptions().paddingTop) {
2835        css(sectionElem, {
2836          'padding-top': getOptions().paddingTop
2837        });
2838      }
2839
2840      if (getOptions().paddingBottom) {
2841        css(sectionElem, {
2842          'padding-bottom': getOptions().paddingBottom
2843        });
2844      }
2845
2846      if (typeof getOptions().sectionsColor[index] !== 'undefined') {
2847        css(sectionElem, {
2848          'background-color': getOptions().sectionsColor[index]
2849        });
2850      }
2851
2852      if (typeof getOptions().anchors[index] !== 'undefined') {
2853        sectionElem.setAttribute('data-anchor', section.anchor);
2854      }
2855
2856      if (!hasSlides) {
2857        addTableClass(section);
2858      }
2859    }
2860    /**
2861    * Gets the active section.
2862    */
2863
2864    function getActiveSection() {
2865      return getState().activeSection;
2866    }
2867
2868    function getSectionFromPanel(panel) {
2869      return panel.isSection ? panel : panel.parent;
2870    }
2871
2872    var g_focusScrollableId;
2873    EventEmitter.on(events.bindEvents, bindEvents$b);
2874
2875    function bindEvents$b() {
2876      // We can't focus scrollOverflow before scrolling
2877      // to the anchor (if we need to)
2878      EventEmitter.on(events.onAfterRenderNoAnchor, afterRender);
2879      EventEmitter.on(events.onLeave, scrollOverflowHandler.onLeave);
2880      EventEmitter.on(events.onSlideLeave, scrollOverflowHandler.onLeave);
2881      EventEmitter.on(events.afterSlideLoads, scrollOverflowHandler.afterLoad);
2882      EventEmitter.on(events.afterSectionLoads, scrollOverflowHandler.afterLoad);
2883      EventEmitter.on(events.onDestroy, onDestroy$7);
2884      docAddEvent('keyup', scrollOverflowHandler.keyUpHandler);
2885    }
2886
2887    function afterRender() {
2888      if (getOptions().scrollOverflow && !getOptions().scrollBar) {
2889        scrollOverflowHandler.makeScrollable();
2890        scrollOverflowHandler.focusScrollable();
2891      }
2892    }
2893
2894    function onDestroy$7() {
2895      EventEmitter.removeListener(events.onAfterRenderNoAnchor, afterRender);
2896      docRemoveEvent('keyup', scrollOverflowHandler.keyUpHandler);
2897    }
2898
2899    var scrollOverflowHandler = {
2900      focusedElem: null,
2901      shouldFocusScrollable: true,
2902      isInnerScrollAllowed: true,
2903      timeBeforeReachingLimit: null,
2904      timeLastScroll: null,
2905      preventScrollWithMouseWheel: function preventScrollWithMouseWheel(e) {
2906        var activeSection = getState().activeSection;
2907
2908        if (!state.canScroll || isInsideIframe() && getOptions().scrollOverflow && scrollOverflowHandler.isScrollable(activeSection) && scrollOverflowHandler.isScrolled(getState().wheelDirection, activeSection.item)) {
2909          preventDefault(e);
2910          return false;
2911        }
2912      },
2913      preventScrollWithKeyboard: function preventScrollWithKeyboard(e) {
2914        if (!isInsideInput() && getOptions().keyboardScrolling) {
2915          var directionKeys = [38, 33, 32, 40, 34, 36, 35];
2916
2917          if (directionKeys.indexOf(e.keyCode) > -1 && !scrollOverflowHandler.isInnerScrollAllowed) {
2918            preventDefault(e);
2919            return false;
2920          }
2921        }
2922      },
2923      keyUpHandler: function keyUpHandler() {
2924        scrollOverflowHandler.shouldFocusScrollable = state.canScroll;
2925      },
2926      // Leaving sections or slides
2927      onLeave: function onLeave() {
2928        clearTimeout(g_focusScrollableId);
2929        scrollOverflowHandler.isInnerScrollAllowed = false;
2930      },
2931      // Loading sections or slides
2932      afterLoad: function afterLoad() {
2933        scrollOverflowHandler.isInnerScrollAllowed = false; // Delaying it to avoid issues on Safari when focusing elements #4484 & #4493
2934
2935        clearTimeout(g_focusScrollableId);
2936        g_focusScrollableId = setTimeout(function () {
2937          scrollOverflowHandler.shouldFocusScrollable = state.canScroll;
2938        }, 200);
2939      },
2940      // Unfocusing the scrollable element from the orgin section/slide
2941      unfocusScrollable: function unfocusScrollable() {
2942        if (doc.activeElement === this.focusedElem) {
2943          // @ts-ignore
2944          this.focusedElem.blur();
2945          scrollOverflowHandler.isInnerScrollAllowed = false;
2946        }
2947      },
2948      focusScrollable: function focusScrollable() {
2949        if (!getOptions().scrollOverflow || !scrollOverflowHandler.shouldFocusScrollable) {
2950          return;
2951        }
2952
2953        scrollOverflowHandler.unfocusScrollable();
2954        var scrollableItem = scrollOverflowHandler.getScrollableItem(getState().activeSection.item); // On desktop we focus the scrollable to be able to use the mouse wheel
2955        // We avoid it on mobile due to a bug in iOS Safari
2956
2957        if (scrollableItem && !isTouchDevice && !isTouch) {
2958          this.focusedElem = scrollableItem; // Forcing the focus on the next paint 
2959          // to avoid issue #4484 & #4493 on Safari
2960
2961          requestAnimationFrame(function () {
2962            scrollableItem.focus({
2963              preventScroll: true
2964            });
2965            scrollOverflowHandler.isInnerScrollAllowed = true;
2966          });
2967        }
2968
2969        scrollOverflowHandler.shouldFocusScrollable = false;
2970      },
2971      makeScrollable: function makeScrollable() {
2972        if (getOptions().scrollOverflowMacStyle && !isMacDevice) {
2973          addClass($body, 'fp-scroll-mac');
2974        }
2975
2976        getState().panels.forEach(function (el) {
2977          if (el.slides && el.slides.length) {
2978            return;
2979          }
2980
2981          if (hasClass(el.item, AUTO_HEIGHT_RESPONSIVE) && isResponsiveMode()) {
2982            return;
2983          } else {
2984            var item = getSlideOrSection(el.item);
2985            var shouldBeScrollable = scrollOverflowHandler.shouldBeScrollable(el.item);
2986            var section = getSectionFromPanel(el);
2987
2988            if (isIE11) {
2989              var toggleAction = shouldBeScrollable ? 'addClass' : 'removeClass';
2990              utils[toggleAction](section.item, IS_OVERFLOW);
2991              utils[toggleAction](el.item, IS_OVERFLOW);
2992            } else {
2993              addClass(section.item, IS_OVERFLOW);
2994              addClass(el.item, IS_OVERFLOW);
2995            }
2996
2997            if (!el.hasScroll) {
2998              scrollOverflowHandler.createWrapper(item);
2999              scrollOverflowHandler.bindEvents(item);
3000            } // updating the state now in case 
3001            // this is executed on page load (after images load)
3002
3003
3004            el.hasScroll = true;
3005          }
3006        });
3007      },
3008      bindEvents: function bindEvents(item) {
3009