Diff: STRATO-apps/wordpress_03/app/wp-content/plugins/wp-rocket/assets/js/lazyload/11.0.6/lazyload.js
Keine Baseline-Datei – Diff nur gegen leer.
1
-
1
+
function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
2
+
3
+
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
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 runningOnBrowser = typeof window !== "undefined";
11
+
var isBot = runningOnBrowser && !("onscroll" in window) || typeof navigator !== "undefined" && /(gle|ing|ro)bot|crawl|spider/i.test(navigator.userAgent);
12
+
var supportsIntersectionObserver = runningOnBrowser && "IntersectionObserver" in window;
13
+
var supportsClassList = runningOnBrowser && "classList" in document.createElement("p");
14
+
var defaultSettings = {
15
+
elements_selector: "img",
16
+
container: isBot || runningOnBrowser ? document : null,
17
+
threshold: 300,
18
+
thresholds: null,
19
+
data_src: "src",
20
+
data_srcset: "srcset",
21
+
data_sizes: "sizes",
22
+
data_bg: "bg",
23
+
class_loading: "loading",
24
+
class_loaded: "loaded",
25
+
class_error: "error",
26
+
load_delay: 0,
27
+
auto_unobserve: true,
28
+
callback_enter: null,
29
+
callback_exit: null,
30
+
callback_reveal: null,
31
+
callback_loaded: null,
32
+
callback_error: null,
33
+
callback_finish: null
34
+
};
35
+
36
+
var getInstanceSettings = function getInstanceSettings(customSettings) {
37
+
return _extends({}, defaultSettings, customSettings);
38
+
};
39
+
40
+
var dataPrefix = "data-";
41
+
var processedDataName = "was-processed";
42
+
var timeoutDataName = "ll-timeout";
43
+
var trueString = "true";
44
+
45
+
var getData = function getData(element, attribute) {
46
+
return element.getAttribute(dataPrefix + attribute);
47
+
};
48
+
49
+
var setData = function setData(element, attribute, value) {
50
+
var attrName = dataPrefix + attribute;
51
+
52
+
if (value === null) {
53
+
element.removeAttribute(attrName);
54
+
return;
55
+
}
56
+
57
+
element.setAttribute(attrName, value);
58
+
};
59
+
60
+
var setWasProcessedData = function setWasProcessedData(element) {
61
+
return setData(element, processedDataName, trueString);
62
+
};
63
+
64
+
var getWasProcessedData = function getWasProcessedData(element) {
65
+
return getData(element, processedDataName) === trueString;
66
+
};
67
+
68
+
var setTimeoutData = function setTimeoutData(element, value) {
69
+
return setData(element, timeoutDataName, value);
70
+
};
71
+
72
+
var getTimeoutData = function getTimeoutData(element) {
73
+
return getData(element, timeoutDataName);
74
+
};
75
+
76
+
var purgeProcessedElements = function purgeProcessedElements(elements) {
77
+
return elements.filter(function (element) {
78
+
return !getWasProcessedData(element);
79
+
});
80
+
};
81
+
82
+
var purgeOneElement = function purgeOneElement(elements, elementToPurge) {
83
+
return elements.filter(function (element) {
84
+
return element !== elementToPurge;
85
+
});
86
+
};
87
+
/* Creates instance and notifies it through the window element */
88
+
89
+
90
+
var createInstance = function createInstance(classObj, options) {
91
+
var event;
92
+
var eventString = "LazyLoad::Initialized";
93
+
var instance = new classObj(options);
94
+
95
+
try {
96
+
// Works in modern browsers
97
+
event = new CustomEvent(eventString, {
98
+
detail: {
99
+
instance: instance
100
+
}
101
+
});
102
+
} catch (err) {
103
+
// Works in Internet Explorer (all versions)
104
+
event = document.createEvent("CustomEvent");
105
+
event.initCustomEvent(eventString, false, false, {
106
+
instance: instance
107
+
});
108
+
}
109
+
110
+
window.dispatchEvent(event);
111
+
};
112
+
/* Auto initialization of one or more instances of lazyload, depending on the
113
+
options passed in (plain object or an array) */
114
+
115
+
116
+
function autoInitialize(classObj, options) {
117
+
if (!options) {
118
+
return;
119
+
}
120
+
121
+
if (!options.length) {
122
+
// Plain object
123
+
createInstance(classObj, options);
124
+
} else {
125
+
// Array of objects
126
+
for (var i = 0, optionsItem; optionsItem = options[i]; i += 1) {
127
+
createInstance(classObj, optionsItem);
128
+
}
129
+
}
130
+
}
131
+
132
+
var callbackIfSet = function callbackIfSet(callback, argument) {
133
+
if (callback) {
134
+
callback(argument);
135
+
}
136
+
};
137
+
138
+
var updateLoadingCount = function updateLoadingCount(instance, plusMinus) {
139
+
instance._loadingCount += plusMinus;
140
+
141
+
if (instance._elements.length === 0 && instance._loadingCount === 0) {
142
+
callbackIfSet(instance._settings.callback_finish);
143
+
}
144
+
};
145
+
146
+
var getSourceTags = function getSourceTags(parentTag) {
147
+
var sourceTags = [];
148
+
149
+
for (var i = 0, childTag; childTag = parentTag.children[i]; i += 1) {
150
+
if (childTag.tagName === "SOURCE") {
151
+
sourceTags.push(childTag);
152
+
}
153
+
}
154
+
155
+
return sourceTags;
156
+
};
157
+
158
+
var setAttributeIfValue = function setAttributeIfValue(element, attrName, value) {
159
+
if (!value) {
160
+
return;
161
+
}
162
+
163
+
element.setAttribute(attrName, value);
164
+
};
165
+
166
+
var setImageAttributes = function setImageAttributes(element, settings) {
167
+
setAttributeIfValue(element, "sizes", getData(element, settings.data_sizes));
168
+
setAttributeIfValue(element, "srcset", getData(element, settings.data_srcset));
169
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
170
+
};
171
+
172
+
var setSourcesImg = function setSourcesImg(element, settings) {
173
+
var parent = element.parentNode;
174
+
175
+
if (parent && parent.tagName === "PICTURE") {
176
+
var sourceTags = getSourceTags(parent);
177
+
sourceTags.forEach(function (sourceTag) {
178
+
setImageAttributes(sourceTag, settings);
179
+
});
180
+
}
181
+
182
+
setImageAttributes(element, settings);
183
+
};
184
+
185
+
var setSourcesIframe = function setSourcesIframe(element, settings) {
186
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
187
+
};
188
+
189
+
var setSourcesVideo = function setSourcesVideo(element, settings) {
190
+
var sourceTags = getSourceTags(element);
191
+
sourceTags.forEach(function (sourceTag) {
192
+
setAttributeIfValue(sourceTag, "src", getData(sourceTag, settings.data_src));
193
+
});
194
+
setAttributeIfValue(element, "src", getData(element, settings.data_src));
195
+
element.load();
196
+
};
197
+
198
+
var setSourcesBgImage = function setSourcesBgImage(element, settings) {
199
+
var srcDataValue = getData(element, settings.data_src);
200
+
var bgDataValue = getData(element, settings.data_bg);
201
+
202
+
if (srcDataValue) {
203
+
element.style.backgroundImage = "url(\"".concat(srcDataValue, "\")");
204
+
}
205
+
206
+
if (bgDataValue) {
207
+
element.style.backgroundImage = bgDataValue;
208
+
}
209
+
};
210
+
211
+
var setSourcesFunctions = {
212
+
IMG: setSourcesImg,
213
+
IFRAME: setSourcesIframe,
214
+
VIDEO: setSourcesVideo
215
+
};
216
+
217
+
var setSources = function setSources(element, instance) {
218
+
var settings = instance._settings;
219
+
var tagName = element.tagName;
220
+
var setSourcesFunction = setSourcesFunctions[tagName];
221
+
222
+
if (setSourcesFunction) {
223
+
setSourcesFunction(element, settings);
224
+
updateLoadingCount(instance, 1);
225
+
instance._elements = purgeOneElement(instance._elements, element);
226
+
return;
227
+
}
228
+
229
+
setSourcesBgImage(element, settings);
230
+
};
231
+
232
+
var addClass = function addClass(element, className) {
233
+
if (supportsClassList) {
234
+
element.classList.add(className);
235
+
return;
236
+
}
237
+
238
+
element.className += (element.className ? " " : "") + className;
239
+
};
240
+
241
+
var removeClass = function removeClass(element, className) {
242
+
if (supportsClassList) {
243
+
element.classList.remove(className);
244
+
return;
245
+
}
246
+
247
+
element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, "");
248
+
};
249
+
250
+
var genericLoadEventName = "load";
251
+
var mediaLoadEventName = "loadeddata";
252
+
var errorEventName = "error";
253
+
254
+
var addEventListener = function addEventListener(element, eventName, handler) {
255
+
element.addEventListener(eventName, handler);
256
+
};
257
+
258
+
var removeEventListener = function removeEventListener(element, eventName, handler) {
259
+
element.removeEventListener(eventName, handler);
260
+
};
261
+
262
+
var addEventListeners = function addEventListeners(element, loadHandler, errorHandler) {
263
+
addEventListener(element, genericLoadEventName, loadHandler);
264
+
addEventListener(element, mediaLoadEventName, loadHandler);
265
+
addEventListener(element, errorEventName, errorHandler);
266
+
};
267
+
268
+
var removeEventListeners = function removeEventListeners(element, loadHandler, errorHandler) {
269
+
removeEventListener(element, genericLoadEventName, loadHandler);
270
+
removeEventListener(element, mediaLoadEventName, loadHandler);
271
+
removeEventListener(element, errorEventName, errorHandler);
272
+
};
273
+
274
+
var eventHandler = function eventHandler(event, success, instance) {
275
+
var settings = instance._settings;
276
+
var className = success ? settings.class_loaded : settings.class_error;
277
+
var callback = success ? settings.callback_loaded : settings.callback_error;
278
+
var element = event.target;
279
+
removeClass(element, settings.class_loading);
280
+
addClass(element, className);
281
+
callbackIfSet(callback, element);
282
+
updateLoadingCount(instance, -1);
283
+
};
284
+
285
+
var addOneShotEventListeners = function addOneShotEventListeners(element, instance) {
286
+
var loadHandler = function loadHandler(event) {
287
+
eventHandler(event, true, instance);
288
+
removeEventListeners(element, loadHandler, errorHandler);
289
+
};
290
+
291
+
var errorHandler = function errorHandler(event) {
292
+
eventHandler(event, false, instance);
293
+
removeEventListeners(element, loadHandler, errorHandler);
294
+
};
295
+
296
+
addEventListeners(element, loadHandler, errorHandler);
297
+
};
298
+
299
+
var managedTags = ["IMG", "IFRAME", "VIDEO"];
300
+
301
+
var onEnter = function onEnter(element, instance) {
302
+
var settings = instance._settings;
303
+
callbackIfSet(settings.callback_enter, element);
304
+
305
+
if (!settings.load_delay) {
306
+
revealAndUnobserve(element, instance);
307
+
return;
308
+
}
309
+
310
+
delayLoad(element, instance);
311
+
};
312
+
313
+
var revealAndUnobserve = function revealAndUnobserve(element, instance) {
314
+
var observer = instance._observer;
315
+
revealElement(element, instance);
316
+
317
+
if (observer && instance._settings.auto_unobserve) {
318
+
observer.unobserve(element);
319
+
}
320
+
};
321
+
322
+
var onExit = function onExit(element, instance) {
323
+
var settings = instance._settings;
324
+
callbackIfSet(settings.callback_exit, element);
325
+
326
+
if (!settings.load_delay) {
327
+
return;
328
+
}
329
+
330
+
cancelDelayLoad(element);
331
+
};
332
+
333
+
var cancelDelayLoad = function cancelDelayLoad(element) {
334
+
var timeoutId = getTimeoutData(element);
335
+
336
+
if (!timeoutId) {
337
+
return; // do nothing if timeout doesn't exist
338
+
}
339
+
340
+
clearTimeout(timeoutId);
341
+
setTimeoutData(element, null);
342
+
};
343
+
344
+
var delayLoad = function delayLoad(element, instance) {
345
+
var loadDelay = instance._settings.load_delay;
346
+
var timeoutId = getTimeoutData(element);
347
+
348
+
if (timeoutId) {
349
+
return; // do nothing if timeout already set
350
+
}
351
+
352
+
timeoutId = setTimeout(function () {
353
+
revealAndUnobserve(element, instance);
354
+
cancelDelayLoad(element);
355
+
}, loadDelay);
356
+
setTimeoutData(element, timeoutId);
357
+
};
358
+
359
+
var revealElement = function revealElement(element, instance, force) {
360
+
var settings = instance._settings;
361
+
362
+
if (!force && getWasProcessedData(element)) {
363
+
return; // element has already been processed and force wasn't true
364
+
}
365
+
366
+
if (managedTags.indexOf(element.tagName) > -1) {
367
+
addOneShotEventListeners(element, instance);
368
+
addClass(element, settings.class_loading);
369
+
}
370
+
371
+
setSources(element, instance);
372
+
setWasProcessedData(element);
373
+
callbackIfSet(settings.callback_reveal, element);
374
+
callbackIfSet(settings.callback_set, element);
375
+
};
376
+
377
+
var isIntersecting = function isIntersecting(entry) {
378
+
return entry.isIntersecting || entry.intersectionRatio > 0;
379
+
};
380
+
381
+
var getObserverSettings = function getObserverSettings(settings) {
382
+
return {
383
+
root: settings.container === document ? null : settings.container,
384
+
rootMargin: settings.thresholds || settings.threshold + "px"
385
+
};
386
+
};
387
+
388
+
var setObserver = function setObserver(instance) {
389
+
if (!supportsIntersectionObserver) {
390
+
return false;
391
+
}
392
+
393
+
instance._observer = new IntersectionObserver(function (entries) {
394
+
entries.forEach(function (entry) {
395
+
return isIntersecting(entry) ? onEnter(entry.target, instance) : onExit(entry.target, instance);
396
+
});
397
+
}, getObserverSettings(instance._settings));
398
+
return true;
399
+
};
400
+
401
+
var LazyLoad = function LazyLoad(customSettings, elements) {
402
+
this._settings = getInstanceSettings(customSettings);
403
+
this._loadingCount = 0;
404
+
setObserver(this);
405
+
this.update(elements);
406
+
};
407
+
408
+
LazyLoad.prototype = {
409
+
update: function update(elements) {
410
+
var _this = this;
411
+
412
+
var settings = this._settings;
413
+
414
+
var _elements = elements || settings.container.querySelectorAll(settings.elements_selector);
415
+
416
+
this._elements = purgeProcessedElements(Array.prototype.slice.call(_elements) // NOTE: nodeset to array for IE compatibility
417
+
);
418
+
419
+
if (isBot || !this._observer) {
420
+
this.loadAll();
421
+
return;
422
+
}
423
+
424
+
this._elements.forEach(function (element) {
425
+
_this._observer.observe(element);
426
+
});
427
+
},
428
+
destroy: function destroy() {
429
+
var _this2 = this;
430
+
431
+
if (this._observer) {
432
+
this._elements.forEach(function (element) {
433
+
_this2._observer.unobserve(element);
434
+
});
435
+
436
+
this._observer = null;
437
+
}
438
+
439
+
this._elements = null;
440
+
this._settings = null;
441
+
},
442
+
load: function load(element, force) {
443
+
revealElement(element, this, force);
444
+
},
445
+
loadAll: function loadAll() {
446
+
var _this3 = this;
447
+
448
+
var elements = this._elements;
449
+
elements.forEach(function (element) {
450
+
revealAndUnobserve(element, _this3);
451
+
});
452
+
}
453
+
};
454
+
/* Automatic instances creation if required (useful for async script loading) */
455
+
456
+
if (runningOnBrowser) {
457
+
autoInitialize(LazyLoad, window.lazyLoadOptions);
458
+
}
459
+
460
+
return LazyLoad;
461
+
});