Diff: STRATO-apps/wordpress_03/app/wp-content/plugins/wp-rocket/assets/js/lazyload/16.1/lazyload.js
Keine Baseline-Datei – Diff nur gegen leer.
1
-
1
+
(function (global, factory) {
2
+
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
3
+
typeof define === 'function' && define.amd ? define(factory) :
4
+
(global = global || self, global.LazyLoad = factory());
5
+
}(this, (function () { 'use strict';
6
+
7
+
function _extends() {
8
+
_extends = Object.assign || function (target) {
9
+
for (var i = 1; i < arguments.length; i++) {
10
+
var source = arguments[i];
11
+
12
+
for (var key in source) {
13
+
if (Object.prototype.hasOwnProperty.call(source, key)) {
14
+
target[key] = source[key];
15
+
}
16
+
}
17
+
}
18
+
19
+
return target;
20
+
};
21
+
22
+
return _extends.apply(this, arguments);
23
+
}
24
+
25
+
var runningOnBrowser = typeof window !== "undefined";
26
+
var isBot = runningOnBrowser && !("onscroll" in window) || typeof navigator !== "undefined" && /(gle|ing|ro)bot|crawl|spider/i.test(navigator.userAgent);
27
+
var supportsIntersectionObserver = runningOnBrowser && "IntersectionObserver" in window;
28
+
var supportsClassList = runningOnBrowser && "classList" in document.createElement("p");
29
+
var isHiDpi = runningOnBrowser && window.devicePixelRatio > 1;
30
+
31
+
var defaultSettings = {
32
+
elements_selector: "IMG",
33
+
container: isBot || runningOnBrowser ? document : null,
34
+
threshold: 300,
35
+
thresholds: null,
36
+
data_src: "src",
37
+
data_srcset: "srcset",
38
+
data_sizes: "sizes",
39
+
data_bg: "bg",
40
+
data_bg_hidpi: "bg-hidpi",
41
+
data_bg_multi: "bg-multi",
42
+
data_bg_multi_hidpi: "bg-multi-hidpi",
43
+
data_poster: "poster",
44
+
class_applied: "applied",
45
+
class_loading: "loading",
46
+
class_loaded: "loaded",
47
+
class_error: "error",
48
+
unobserve_completed: true,
49
+
unobserve_entered: false,
50
+
cancel_on_exit: false,
51
+
callback_enter: null,
52
+
callback_exit: null,
53
+
callback_applied: null,
54
+
callback_loading: null,
55
+
callback_loaded: null,
56
+
callback_error: null,
57
+
callback_finish: null,
58
+
callback_cancel: null,
59
+
use_native: false
60
+
};
61
+
var getExtendedSettings = function getExtendedSettings(customSettings) {
62
+
return _extends({}, defaultSettings, customSettings);
63
+
};
64
+
65
+
/* Creates instance and notifies it through the window element */
66
+
var createInstance = function createInstance(classObj, options) {
67
+
var event;
68
+
var eventString = "LazyLoad::Initialized";
69
+
var instance = new classObj(options);
70
+
71
+
try {
72
+
// Works in modern browsers
73
+
event = new CustomEvent(eventString, {
74
+
detail: {
75
+
instance: instance
76
+
}
77
+
});
78
+
} catch (err) {
79
+
// Works in Internet Explorer (all versions)
80
+
event = document.createEvent("CustomEvent");
81
+
event.initCustomEvent(eventString, false, false, {
82
+
instance: instance
83
+
});
84
+
}
85
+
86
+
window.dispatchEvent(event);
87
+
};
88
+
/* Auto initialization of one or more instances of lazyload, depending on the
89
+
options passed in (plain object or an array) */
90
+
91
+
92
+
var autoInitialize = function autoInitialize(classObj, options) {
93
+
if (!options) {
94
+
return;
95
+
}
96
+
97
+
if (!options.length) {
98
+
// Plain object
99
+
createInstance(classObj, options);
100
+
} else {
101
+
// Array of objects
102
+
for (var i = 0, optionsItem; optionsItem = options[i]; i += 1) {
103
+
createInstance(classObj, optionsItem);
104
+
}
105
+
}
106
+
};
107
+
108
+
var statusLoading = "loading";
109
+
var statusLoaded = "loaded";
110
+
var statusApplied = "applied";
111
+
var statusError = "error";
112
+
var statusNative = "native";
113
+
114
+
var dataPrefix = "data-";
115
+
var statusDataName = "ll-status";
116
+
var getData = function getData(element, attribute) {
117
+
return element.getAttribute(dataPrefix + attribute);
118
+
};
119
+
var setData = function setData(element, attribute, value) {
120
+
var attrName = dataPrefix + attribute;
121
+
122
+
if (value === null) {
123
+
element.removeAttribute(attrName);
124
+
return;
125
+
}
126
+
127
+
element.setAttribute(attrName, value);
128
+
};
129
+
var getStatus = function getStatus(element) {
130
+
return getData(element, statusDataName);
131
+
};
132
+
var setStatus = function setStatus(element, status) {
133
+
return setData(element, statusDataName, status);
134
+
};
135
+
var resetStatus = function resetStatus(element) {
136
+
return setStatus(element, null);
137
+
};
138
+
var hasEmptyStatus = function hasEmptyStatus(element) {
139
+
return getStatus(element) === null;
140
+
};
141
+
var hasStatusLoading = function hasStatusLoading(element) {
142
+
return getStatus(element) === statusLoading;
143
+
};
144
+
var hasStatusError = function hasStatusError(element) {
145
+
return getStatus(element) === statusError;
146
+
};
147
+
var hasStatusNative = function hasStatusNative(element) {
148
+
return getStatus(element) === statusNative;
149
+
};
150
+
var hadStartedLoading = function hadStartedLoading(element) {
151
+
return !hasEmptyStatus(element);
152
+
};
153
+
154
+
var safeCallback = function safeCallback(callback, arg1, arg2, arg3) {
155
+
if (!callback) {
156
+
return;
157
+
}
158
+
159
+
if (arg3 !== undefined) {
160
+
callback(arg1, arg2, arg3);
161
+
return;
162
+
}
163
+
164
+
if (arg2 !== undefined) {
165
+
callback(arg1, arg2);
166
+
return;
167
+
}
168
+
169
+
callback(arg1);
170
+
};
171
+
172
+
var addClass = function addClass(element, className) {
173
+
if (supportsClassList) {
174
+
element.classList.add(className);
175
+
return;
176
+
}
177
+
178
+
element.className += (element.className ? " " : "") + className;
179
+
};
180
+
var removeClass = function removeClass(element, className) {
181
+
if (supportsClassList) {
182
+
element.classList.remove(className);
183
+
return;
184
+
}
185
+
186
+
element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, "");
187
+
};
188
+
189
+
var addTempImage = function addTempImage(element) {
190
+
element.llTempImage = document.createElement("IMG");
191
+
};
192
+
var deleteTempImage = function deleteTempImage(element) {
193
+
delete element.llTempImage;
194
+
};
195
+
var getTempImage = function getTempImage(element) {
196
+
return element.llTempImage;
197
+
};
198
+
199
+
var unobserve = function unobserve(element, instance) {
200
+
if (!instance) return;
201
+
var observer = instance._observer;
202
+
if (!observer) return;
203
+
observer.unobserve(element);
204
+
};
205
+
var resetObserver = function resetObserver(observer) {
206
+
observer.disconnect();
207
+
};
208
+
var unobserveIfRequired = function unobserveIfRequired(element, settings, instance) {
209
+
if (settings.unobserve_entered) unobserve(element, instance);
210
+
};
211
+
212
+
var updateLoadingCount = function updateLoadingCount(instance, delta) {
213
+
if (!instance) return;
214
+
instance.loadingCount += delta;
215
+
};
216
+
var decreaseToLoadCount = function decreaseToLoadCount(instance) {
217
+
if (!instance) return;
218
+
instance.toLoadCount -= 1;
219
+
};
220
+
var setToLoadCount = function setToLoadCount(instance, value) {
221
+
if (!instance) return;
222
+
instance.toLoadCount = value;
223
+
};
224
+
var isSomethingLoading = function isSomethingLoading(instance) {
225
+
return instance.loadingCount > 0;
226
+
};
227
+
var haveElementsToLoad = function haveElementsToLoad(instance) {
228
+
return instance.toLoadCount > 0;
229
+
};
230
+
231
+
var getSourceTags = function getSourceTags(parentTag) {
232
+
var sourceTags = [];
233
+
234
+
for (var i = 0, childTag; childTag = parentTag.children[i]; i += 1) {
235
+
if (childTag.tagName === "SOURCE") {
236
+
sourceTags.push(childTag);
237
+
}
238
+
}
239
+
240
+
return sourceTags;
241
+
};
242
+
var setAttributeIfValue = function setAttributeIfValue(element, attrName, value) {
243
+
if (!value) {
244
+
return;
245
+
}
246
+
247
+
element.setAttribute(attrName, value);
248
+
};
249
+
var resetAttribute = function resetAttribute(element, attrName) {
250
+
element.removeAttribute(attrName);
251
+
};
252
+
var hasOriginalAttributes = function hasOriginalAttributes(element) {
253
+
return !!element.llOriginalAttrs;
254
+
};
255
+
var saveOriginalImageAttributes = function saveOriginalImageAttributes(element) {
256
+
if (hasOriginalAttributes(element)) {
257
+
return;
258
+
}
259
+
260
+
var originalAttributes = {};
261
+
originalAttributes["src"] = element.getAttribute("src");
262
+
originalAttributes["srcset"] = element.getAttribute("srcset");
263
+
originalAttributes["sizes"] = element.getAttribute("sizes");
264
+
element.llOriginalAttrs = originalAttributes;
265
+
};
266
+
var restoreOriginalImageAttributes = function restoreOriginalImageAttributes(element) {
267
+
if (!hasOriginalAttributes(element)) {
268
+
return;
269
+
}
270
+
271
+
var originalAttributes = element.llOriginalAttrs;
272
+
setAttributeIfValue(element, "src", originalAttributes["src"]);
273
+
setAttributeIfValue(element, "srcset", originalAttributes["srcset"]);
274
+
setAttributeIfValue(element, "sizes", originalAttributes["sizes"]);
275
+
};
276
+
var setImageAttributes = function setImageAttributes(element, settings) {
277
+
setAttributeIfValue(element, "sizes", getData(element, settings.data_sizes));
278
+
setAttributeIfValue(element, "srcset", getData(element, settings.data_srcset));
279
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
280
+
};
281
+
var resetImageAttributes = function resetImageAttributes(element) {
282
+
resetAttribute(element, "src");
283
+
resetAttribute(element, "srcset");
284
+
resetAttribute(element, "sizes");
285
+
};
286
+
var forEachPictureSource = function forEachPictureSource(element, fn) {
287
+
var parent = element.parentNode;
288
+
289
+
if (!parent || parent.tagName !== "PICTURE") {
290
+
return;
291
+
}
292
+
293
+
var sourceTags = getSourceTags(parent);
294
+
sourceTags.forEach(fn);
295
+
};
296
+
var forEachVideoSource = function forEachVideoSource(element, fn) {
297
+
var sourceTags = getSourceTags(element);
298
+
sourceTags.forEach(fn);
299
+
};
300
+
var restoreOriginalAttributesImg = function restoreOriginalAttributesImg(element) {
301
+
forEachPictureSource(element, function (sourceTag) {
302
+
restoreOriginalImageAttributes(sourceTag);
303
+
});
304
+
restoreOriginalImageAttributes(element);
305
+
};
306
+
var setSourcesImg = function setSourcesImg(element, settings) {
307
+
forEachPictureSource(element, function (sourceTag) {
308
+
saveOriginalImageAttributes(sourceTag);
309
+
setImageAttributes(sourceTag, settings);
310
+
});
311
+
saveOriginalImageAttributes(element);
312
+
setImageAttributes(element, settings);
313
+
};
314
+
var resetSourcesImg = function resetSourcesImg(element) {
315
+
forEachPictureSource(element, function (sourceTag) {
316
+
resetImageAttributes(sourceTag);
317
+
});
318
+
resetImageAttributes(element);
319
+
};
320
+
var setSourcesIframe = function setSourcesIframe(element, settings) {
321
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
322
+
};
323
+
var setSourcesVideo = function setSourcesVideo(element, settings) {
324
+
forEachVideoSource(element, function (sourceTag) {
325
+
setAttributeIfValue(sourceTag, "src", getData(sourceTag, settings.data_src));
326
+
});
327
+
setAttributeIfValue(element, "poster", getData(element, settings.data_poster));
328
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
329
+
element.load();
330
+
};
331
+
var setSourcesFunctions = {
332
+
IMG: setSourcesImg,
333
+
IFRAME: setSourcesIframe,
334
+
VIDEO: setSourcesVideo
335
+
};
336
+
var setBackground = function setBackground(element, settings, instance) {
337
+
var bg1xValue = getData(element, settings.data_bg);
338
+
var bgHiDpiValue = getData(element, settings.data_bg_hidpi);
339
+
var bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue;
340
+
if (!bgDataValue) return;
341
+
element.style.backgroundImage = "url(\"".concat(bgDataValue, "\")");
342
+
getTempImage(element).setAttribute("src", bgDataValue);
343
+
manageLoading(element, settings, instance);
344
+
}; // NOTE: THE TEMP IMAGE TRICK CANNOT BE DONE WITH data-multi-bg
345
+
// BECAUSE INSIDE ITS VALUES MUST BE WRAPPED WITH URL() AND ONE OF THEM
346
+
// COULD BE A GRADIENT BACKGROUND IMAGE
347
+
348
+
var setMultiBackground = function setMultiBackground(element, settings, instance) {
349
+
var bg1xValue = getData(element, settings.data_bg_multi);
350
+
var bgHiDpiValue = getData(element, settings.data_bg_multi_hidpi);
351
+
var bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue;
352
+
353
+
if (!bgDataValue) {
354
+
return;
355
+
}
356
+
357
+
element.style.backgroundImage = bgDataValue;
358
+
manageApplied(element, settings, instance);
359
+
};
360
+
var setSources = function setSources(element, settings) {
361
+
var setSourcesFunction = setSourcesFunctions[element.tagName];
362
+
363
+
if (!setSourcesFunction) {
364
+
return;
365
+
}
366
+
367
+
setSourcesFunction(element, settings);
368
+
};
369
+
var manageApplied = function manageApplied(element, settings, instance) {
370
+
addClass(element, settings.class_applied);
371
+
setStatus(element, statusApplied);
372
+
removeDataMultiBackground(element, settings);
373
+
374
+
if (settings.unobserve_completed) {
375
+
// Unobserve now because we can't do it on load
376
+
unobserve(element, settings);
377
+
}
378
+
379
+
safeCallback(settings.callback_applied, element, instance);
380
+
};
381
+
var manageLoading = function manageLoading(element, settings, instance) {
382
+
updateLoadingCount(instance, +1);
383
+
addClass(element, settings.class_loading);
384
+
setStatus(element, statusLoading);
385
+
safeCallback(settings.callback_loading, element, instance);
386
+
}; // REMOVE DATA ATTRIBUTES --------------
387
+
388
+
var removeDataImg = function removeDataImg(element, settings) {
389
+
setData(element, settings.data_src, null);
390
+
setData(element, settings.data_srcset, null);
391
+
setData(element, settings.data_sizes, null);
392
+
forEachPictureSource(element, function (sourceTag) {
393
+
setData(sourceTag, settings.data_srcset, null);
394
+
setData(sourceTag, settings.data_sizes, null);
395
+
});
396
+
};
397
+
var removeDataIframe = function removeDataIframe(element, settings) {
398
+
setData(element, settings.data_src, null);
399
+
};
400
+
var removeDataVideo = function removeDataVideo(element, settings) {
401
+
setData(element, settings.data_src, null);
402
+
setData(element, settings.data_poster, null);
403
+
forEachVideoSource(element, function (sourceTag) {
404
+
setData(sourceTag, settings.data_src, null);
405
+
});
406
+
};
407
+
var removeDataFunctions = {
408
+
IMG: removeDataImg,
409
+
IFRAME: removeDataIframe,
410
+
VIDEO: removeDataVideo
411
+
};
412
+
var removeDataBackground = function removeDataBackground(element, settings) {
413
+
setData(element, settings.data_bg, null);
414
+
setData(element, settings.data_bg_hidpi, null);
415
+
};
416
+
var removeDataMultiBackground = function removeDataMultiBackground(element, settings) {
417
+
setData(element, settings.data_bg_multi, null);
418
+
setData(element, settings.data_bg_multi_hidpi, null);
419
+
};
420
+
var removeDataAttributes = function removeDataAttributes(element, settings) {
421
+
var removeDataFunction = removeDataFunctions[element.tagName];
422
+
423
+
if (removeDataFunction) {
424
+
removeDataFunction(element, settings);
425
+
return;
426
+
}
427
+
428
+
removeDataBackground(element, settings);
429
+
};
430
+
431
+
var elementsWithLoadEvent = ["IMG", "IFRAME", "VIDEO"];
432
+
var hasLoadEvent = function hasLoadEvent(element) {
433
+
return elementsWithLoadEvent.indexOf(element.tagName) > -1;
434
+
};
435
+
var checkFinish = function checkFinish(settings, instance) {
436
+
if (instance && !isSomethingLoading(instance) && !haveElementsToLoad(instance)) {
437
+
safeCallback(settings.callback_finish, instance);
438
+
}
439
+
};
440
+
var addEventListener = function addEventListener(element, eventName, handler) {
441
+
element.addEventListener(eventName, handler);
442
+
element.llEvLisnrs[eventName] = handler;
443
+
};
444
+
var removeEventListener = function removeEventListener(element, eventName, handler) {
445
+
element.removeEventListener(eventName, handler);
446
+
};
447
+
var hasEventListeners = function hasEventListeners(element) {
448
+
return !!element.llEvLisnrs;
449
+
};
450
+
var addEventListeners = function addEventListeners(element, loadHandler, errorHandler) {
451
+
if (!hasEventListeners(element)) element.llEvLisnrs = {};
452
+
var loadEventName = element.tagName === "VIDEO" ? "loadeddata" : "load";
453
+
addEventListener(element, loadEventName, loadHandler);
454
+
addEventListener(element, "error", errorHandler);
455
+
};
456
+
var removeEventListeners = function removeEventListeners(element) {
457
+
if (!hasEventListeners(element)) {
458
+
return;
459
+
}
460
+
461
+
var eventListeners = element.llEvLisnrs;
462
+
463
+
for (var eventName in eventListeners) {
464
+
var handler = eventListeners[eventName];
465
+
removeEventListener(element, eventName, handler);
466
+
}
467
+
468
+
delete element.llEvLisnrs;
469
+
};
470
+
var doneHandler = function doneHandler(element, settings, instance) {
471
+
deleteTempImage(element);
472
+
updateLoadingCount(instance, -1);
473
+
decreaseToLoadCount(instance);
474
+
removeClass(element, settings.class_loading);
475
+
476
+
if (settings.unobserve_completed) {
477
+
unobserve(element, instance);
478
+
}
479
+
};
480
+
var loadHandler = function loadHandler(event, element, settings, instance) {
481
+
var goingNative = hasStatusNative(element);
482
+
doneHandler(element, settings, instance);
483
+
addClass(element, settings.class_loaded);
484
+
setStatus(element, statusLoaded);
485
+
removeDataAttributes(element, settings);
486
+
safeCallback(settings.callback_loaded, element, instance);
487
+
if (!goingNative) checkFinish(settings, instance);
488
+
};
489
+
var errorHandler = function errorHandler(event, element, settings, instance) {
490
+
var goingNative = hasStatusNative(element);
491
+
doneHandler(element, settings, instance);
492
+
addClass(element, settings.class_error);
493
+
setStatus(element, statusError);
494
+
safeCallback(settings.callback_error, element, instance);
495
+
if (!goingNative) checkFinish(settings, instance);
496
+
};
497
+
var addOneShotEventListeners = function addOneShotEventListeners(element, settings, instance) {
498
+
var elementToListenTo = getTempImage(element) || element;
499
+
500
+
if (hasEventListeners(elementToListenTo)) {
501
+
// This happens when loading is retried twice
502
+
return;
503
+
}
504
+
505
+
var _loadHandler = function _loadHandler(event) {
506
+
loadHandler(event, element, settings, instance);
507
+
removeEventListeners(elementToListenTo);
508
+
};
509
+
510
+
var _errorHandler = function _errorHandler(event) {
511
+
errorHandler(event, element, settings, instance);
512
+
removeEventListeners(elementToListenTo);
513
+
};
514
+
515
+
addEventListeners(elementToListenTo, _loadHandler, _errorHandler);
516
+
};
517
+
518
+
var loadBackground = function loadBackground(element, settings, instance) {
519
+
addTempImage(element);
520
+
addOneShotEventListeners(element, settings, instance);
521
+
setBackground(element, settings, instance);
522
+
setMultiBackground(element, settings, instance);
523
+
};
524
+
525
+
var loadRegular = function loadRegular(element, settings, instance) {
526
+
addOneShotEventListeners(element, settings, instance);
527
+
setSources(element, settings);
528
+
manageLoading(element, settings, instance);
529
+
};
530
+
531
+
var load = function load(element, settings, instance) {
532
+
if (hasLoadEvent(element)) {
533
+
loadRegular(element, settings, instance);
534
+
} else {
535
+
loadBackground(element, settings, instance);
536
+
}
537
+
};
538
+
var loadNative = function loadNative(element, settings, instance) {
539
+
addOneShotEventListeners(element, settings, instance);
540
+
setSources(element, settings);
541
+
removeDataAttributes(element, settings);
542
+
setStatus(element, statusNative);
543
+
};
544
+
545
+
var cancelLoadingIfRequired = function cancelLoadingIfRequired(element, entry, settings, instance) {
546
+
if (!settings.cancel_on_exit) return;
547
+
if (!hasStatusLoading(element)) return;
548
+
if (element.tagName !== "IMG") return; //Works only on images
549
+
550
+
removeEventListeners(element);
551
+
resetSourcesImg(element);
552
+
restoreOriginalAttributesImg(element);
553
+
removeClass(element, settings.class_loading);
554
+
updateLoadingCount(instance, -1);
555
+
resetStatus(element);
556
+
safeCallback(settings.callback_cancel, element, entry, instance);
557
+
};
558
+
559
+
var onEnter = function onEnter(element, entry, settings, instance) {
560
+
safeCallback(settings.callback_enter, element, entry, instance);
561
+
unobserveIfRequired(element, settings, instance);
562
+
if (hadStartedLoading(element)) return; //Prevent loading it again
563
+
564
+
load(element, settings, instance);
565
+
};
566
+
var onExit = function onExit(element, entry, settings, instance) {
567
+
if (hasEmptyStatus(element)) return; //Ignore the first pass, at landing
568
+
569
+
cancelLoadingIfRequired(element, entry, settings, instance);
570
+
safeCallback(settings.callback_exit, element, entry, instance);
571
+
};
572
+
573
+
var tagsWithNativeLazy = ["IMG", "IFRAME"];
574
+
var shouldUseNative = function shouldUseNative(settings) {
575
+
return settings.use_native && "loading" in HTMLImageElement.prototype;
576
+
};
577
+
var loadAllNative = function loadAllNative(elements, settings, instance) {
578
+
elements.forEach(function (element) {
579
+
if (tagsWithNativeLazy.indexOf(element.tagName) === -1) {
580
+
return;
581
+
}
582
+
583
+
element.setAttribute("loading", "lazy"); //TODO: Move inside the loadNative method
584
+
585
+
loadNative(element, settings, instance);
586
+
});
587
+
setToLoadCount(instance, 0);
588
+
};
589
+
590
+
var isIntersecting = function isIntersecting(entry) {
591
+
return entry.isIntersecting || entry.intersectionRatio > 0;
592
+
};
593
+
594
+
var getObserverSettings = function getObserverSettings(settings) {
595
+
return {
596
+
root: settings.container === document ? null : settings.container,
597
+
rootMargin: settings.thresholds || settings.threshold + "px"
598
+
};
599
+
};
600
+
601
+
var intersectionHandler = function intersectionHandler(entries, settings, instance) {
602
+
entries.forEach(function (entry) {
603
+
return isIntersecting(entry) ? onEnter(entry.target, entry, settings, instance) : onExit(entry.target, entry, settings, instance);
604
+
});
605
+
};
606
+
607
+
var observeElements = function observeElements(observer, elements) {
608
+
elements.forEach(function (element) {
609
+
observer.observe(element);
610
+
});
611
+
};
612
+
var updateObserver = function updateObserver(observer, elementsToObserve) {
613
+
resetObserver(observer);
614
+
observeElements(observer, elementsToObserve);
615
+
};
616
+
var setObserver = function setObserver(settings, instance) {
617
+
if (!supportsIntersectionObserver || shouldUseNative(settings)) {
618
+
return;
619
+
}
620
+
621
+
instance._observer = new IntersectionObserver(function (entries) {
622
+
intersectionHandler(entries, settings, instance);
623
+
}, getObserverSettings(settings));
624
+
};
625
+
626
+
var toArray = function toArray(nodeSet) {
627
+
return Array.prototype.slice.call(nodeSet);
628
+
};
629
+
var queryElements = function queryElements(settings) {
630
+
return settings.container.querySelectorAll(settings.elements_selector);
631
+
};
632
+
var excludeManagedElements = function excludeManagedElements(elements) {
633
+
return toArray(elements).filter(hasEmptyStatus);
634
+
};
635
+
var hasError = function hasError(element) {
636
+
return hasStatusError(element);
637
+
};
638
+
var filterErrorElements = function filterErrorElements(elements) {
639
+
return toArray(elements).filter(hasError);
640
+
};
641
+
var getElementsToLoad = function getElementsToLoad(elements, settings) {
642
+
return excludeManagedElements(elements || queryElements(settings));
643
+
};
644
+
645
+
var retryLazyLoad = function retryLazyLoad(settings, instance) {
646
+
var errorElements = filterErrorElements(queryElements(settings));
647
+
errorElements.forEach(function (element) {
648
+
removeClass(element, settings.class_error);
649
+
resetStatus(element);
650
+
});
651
+
instance.update();
652
+
};
653
+
var setOnlineCheck = function setOnlineCheck(settings, instance) {
654
+
if (!runningOnBrowser) {
655
+
return;
656
+
}
657
+
658
+
window.addEventListener("online", function () {
659
+
retryLazyLoad(settings, instance);
660
+
});
661
+
};
662
+
663
+
var LazyLoad = function LazyLoad(customSettings, elements) {
664
+
var settings = getExtendedSettings(customSettings);
665
+
this._settings = settings;
666
+
this.loadingCount = 0;
667
+
setObserver(settings, this);
668
+
setOnlineCheck(settings, this);
669
+
this.update(elements);
670
+
};
671
+
672
+
LazyLoad.prototype = {
673
+
update: function update(givenNodeset) {
674
+
var settings = this._settings;
675
+
var elementsToLoad = getElementsToLoad(givenNodeset, settings);
676
+
setToLoadCount(this, elementsToLoad.length);
677
+
678
+
if (isBot || !supportsIntersectionObserver) {
679
+
this.loadAll(elementsToLoad);
680
+
return;
681
+
}
682
+
683
+
if (shouldUseNative(settings)) {
684
+
loadAllNative(elementsToLoad, settings, this);
685
+
return;
686
+
}
687
+
688
+
updateObserver(this._observer, elementsToLoad);
689
+
},
690
+
destroy: function destroy() {
691
+
// Observer
692
+
if (this._observer) {
693
+
this._observer.disconnect();
694
+
} // Clean custom attributes on elements
695
+
696
+
697
+
queryElements(this._settings).forEach(function (element) {
698
+
delete element.llOriginalAttrs;
699
+
}); // Delete all internal props
700
+
701
+
delete this._observer;
702
+
delete this._settings;
703
+
delete this.loadingCount;
704
+
delete this.toLoadCount;
705
+
},
706
+
loadAll: function loadAll(elements) {
707
+
var _this = this;
708
+
709
+
var settings = this._settings;
710
+
var elementsToLoad = getElementsToLoad(elements, settings);
711
+
elementsToLoad.forEach(function (element) {
712
+
load(element, settings, _this);
713
+
});
714
+
}
715
+
};
716
+
717
+
LazyLoad.load = function (element, customSettings) {
718
+
var settings = getExtendedSettings(customSettings);
719
+
load(element, settings);
720
+
};
721
+
722
+
LazyLoad.resetStatus = function (element) {
723
+
resetStatus(element);
724
+
}; // Automatic instances creation if required (useful for async script loading)
725
+
726
+
727
+
if (runningOnBrowser) {
728
+
autoInitialize(LazyLoad, window.lazyLoadOptions);
729
+
}
730
+
731
+
return LazyLoad;
732
+
733
+
})));
734
+