https://www.abt-sportsline.de/typo3temp/assets/compressed/lazyload…9931a5710a2e75ae5e4559774ad16.js?1789569026

1var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
2
3var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
4
5(function (global, factory) {
6    (typeof exports === 'undefined' ? 'undefined' : _typeof(exports)) === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.LazyLoad = factory();
7})(this, function () {
8    'use strict';
9
10    var defaultSettings = {
11        elements_selector: "img",
12        container: document,
13        threshold: 300,
14        data_src: "src",
15        data_srcset: "srcset",
16        class_loading: "loading",
17        class_loaded: "loaded",
18        class_error: "error",
19        callback_load: null,
20        callback_error: null,
21        callback_set: null,
22        callback_enter: null
23    };
24
25    var dataPrefix = "data-";
26
27    var getData = function getData(element, attribute) {
28        return element.getAttribute(dataPrefix + attribute);
29    };
30
31    var setData = function setData(element, attribute, value) {
32        return element.setAttribute(dataPrefix + attribute, value);
33    };
34
35    var purgeElements = function purgeElements(elements) {
36        return elements.filter(function (element) {
37            return !getData(element, "was-processed");
38        });
39    };
40
41    /* Creates instance and notifies it through the window element */
42    var createInstance = function createInstance(classObj, options) {
43        var event;
44        var eventString = "LazyLoad::Initialized";
45        var instance = new classObj(options);
46        try {
47            // Works in modern browsers
48            event = new CustomEvent(eventString, { detail: { instance: instance } });
49        } catch (err) {
50            // Works in Internet Explorer (all versions)
51            event = document.createEvent("CustomEvent");
52            event.initCustomEvent(eventString, false, false, { instance: instance });
53        }
54        window.dispatchEvent(event);
55    };
56
57    /* Auto initialization of one or more instances of lazyload, depending on the
58        options passed in (plain object or an array) */
59    var autoInitialize = function autoInitialize(classObj, options) {
60        if (!options.length) {
61            // Plain object
62            createInstance(classObj, options);
63        } else {
64            // Array of objects
65            for (var i = 0, optionsItem; optionsItem = options[i]; i += 1) {
66                createInstance(classObj, optionsItem);
67            }
68        }
69    };
70
71    var setSourcesForPicture = function setSourcesForPicture(element, settings) {
72        var dataSrcSet = settings.data_srcset;
73
74        var parent = element.parentNode;
75        if (parent.tagName !== "PICTURE") {
76            return;
77        }
78        for (var i = 0, pictureChild; pictureChild = parent.children[i]; i += 1) {
79            if (pictureChild.tagName === "SOURCE") {
80                var sourceSrcset = getData(pictureChild, dataSrcSet);
81                if (sourceSrcset) {
82                    pictureChild.setAttribute("srcset", sourceSrcset);
83                }
84            }
85        }
86    };
87
88    var setSources = function setSources(element, settings) {
89        var dataSrc = settings.data_src,
90            dataSrcSet = settings.data_srcset;
91
92        var tagName = element.tagName;
93        var elementSrc = getData(element, dataSrc);
94        if (tagName === "IMG") {
95            setSourcesForPicture(element, settings);
96            var imgSrcset = getData(element, dataSrcSet);
97            if (imgSrcset) {
98                element.setAttribute("srcset", imgSrcset);
99            }
100            if (elementSrc) {
101                element.setAttribute("src", elementSrc);
102            }
103            return;
104        }
105        if (tagName === "IFRAME") {
106            if (elementSrc) {
107                element.setAttribute("src", elementSrc);
108            }
109            return;
110        }
111        if (elementSrc) {
112            element.style.backgroundImage = 'url("' + elementSrc + '")';
113        }
114    };
115
116    var supportsClassList = "classList" in document.createElement("p");
117
118    var addClass = function addClass(element, className) {
119        if (supportsClassList) {
120            element.classList.add(className);
121            return;
122        }
123        element.className += (element.className ? " " : "") + className;
124    };
125
126    var removeClass = function removeClass(element, className) {
127        if (supportsClassList) {
128            element.classList.remove(className);
129            return;
130        }
131        element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, "");
132    };
133
134    var callCallback = function callCallback(callback, argument) {
135        if (callback) {
136            callback(argument);
137        }
138    };
139
140    var loadString = "load";
141    var errorString = "error";
142
143    var removeListeners = function removeListeners(element, loadHandler, errorHandler) {
144        element.removeEventListener(loadString, loadHandler);
145        element.removeEventListener(errorString, errorHandler);
146    };
147
148    var addOneShotListeners = function addOneShotListeners(element, settings) {
149        var onLoad = function onLoad(event) {
150            onEvent(event, true, settings);
151            removeListeners(element, onLoad, onError);
152        };
153        var onError = function onError(event) {
154            onEvent(event, false, settings);
155            removeListeners(element, onLoad, onError);
156        };
157        element.addEventListener(loadString, onLoad);
158        element.addEventListener(errorString, onError);
159    };
160
161    var onEvent = function onEvent(event, success, settings) {
162        var element = event.target;
163        removeClass(element, settings.class_loading);
164        addClass(element, success ? settings.class_loaded : settings.class_error); // Setting loaded or error class
165        callCallback(success ? settings.callback_load : settings.callback_error, element); // Calling loaded or error callback
166    };
167
168    var revealElement = function revealElement(element, settings) {
169        callCallback(settings.callback_enter, element);
170        if (["IMG", "IFRAME"].indexOf(element.tagName) > -1) {
171            addOneShotListeners(element, settings);
172            addClass(element, settings.class_loading);
173        }
174        setSources(element, settings);
175        setData(element, "was-processed", true);
176        callCallback(settings.callback_set, element);
177    };
178
179    var LazyLoad = function LazyLoad(instanceSettings, elements) {
180        this._settings = _extends({}, defaultSettings, instanceSettings);
181        this._setObserver();
182        this.update(elements);
183    };
184
185    LazyLoad.prototype = {
186        _setObserver: function _setObserver() {
187            var _this = this;
188
189            if (!("IntersectionObserver" in window)) {
190                return;
191            }
192
193            var settings = this._settings;
194            var onIntersection = function onIntersection(entries) {

195                entries.forEach(function (entry) {
196                    // entry.isIntersecting is null on some versions of MS Edge
197                    // entry.intersectionRatio can be 0 on some intersecting elements
198                    if (entry.isIntersecting || entry.intersectionRatio > 0) {
199                        var element = entry.target;
200                        revealElement(element, settings);
201                        _this._observer.unobserve(element);
202                    }
203                });
204                _this._elements = purgeElements(_this._elements);
205            };
206            this._observer = new IntersectionObserver(onIntersection, {
207                root: settings.container === document ? null : settings.container,
208                rootMargin: settings.threshold + "px"
209            });
210        },
211
212        update: function update(elements) {
213            var _this2 = this;
214
215            var settings = this._settings;
216            var nodeSet = elements || settings.container.querySelectorAll(settings.elements_selector);
217
218            this._elements = purgeElements(Array.prototype.slice.call(nodeSet)); // nodeset to array for IE compatibility
219            if (this._observer) {
220                this._elements.forEach(function (element) {
221                    _this2._observer.observe(element);
222                });
223                return;
224            }
225            // Fallback: load all elements at once
226            this._elements.forEach(function (element) {
227                revealElement(element, settings);
228            });
229            this._elements = purgeElements(this._elements);
230        },
231
232        destroy: function destroy() {
233            var _this3 = this;
234
235            if (this._observer) {
236                purgeElements(this._elements).forEach(function (element) {
237                    _this3._observer.unobserve(element);
238                });
239                this._observer = null;
240            }
241            this._elements = null;
242            this._settings = null;
243        }
244    };
245
246    /* Automatic instances creation if required (useful for async script loading!) */
247    var autoInitOptions = window.lazyLoadOptions;
248    if (autoInitOptions) {
249        autoInitialize(LazyLoad, autoInitOptions);
250    }
251
252    return LazyLoad;
253});