https://nosound.band/viewsthebench/muse/vendor/forqy/core/components/forqys/image/js/lib/lazyload.js
1(function (global, factory) { 2 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : 3 typeof define === 'function' && define.amd ? define(factory) : 4 (global = typeof globalThis !== 'undefined' ? globalThis : 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: ".lazy", 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 class_entered: "entered", 49 class_exited: "exited", 50 unobserve_completed: true, 51 unobserve_entered: false, 52 cancel_on_exit: true, 53 callback_enter: null, 54 callback_exit: null, 55 callback_applied: null, 56 callback_loading: null, 57 callback_loaded: null, 58 callback_error: null, 59 callback_finish: null, 60 callback_cancel: null, 61 use_native: false 62 }; 63 var getExtendedSettings = function getExtendedSettings(customSettings) { 64 return _extends({}, defaultSettings, customSettings); 65 }; 66 67 /* Creates instance and notifies it through the window element */ 68 var createInstance = function createInstance(classObj, options) { 69 var event; 70 var eventString = "LazyLoad::Initialized"; 71 var instance = new classObj(options); 72 73 try { 74 // Works in modern browsers 75 event = new CustomEvent(eventString, { 76 detail: { 77 instance: instance 78 } 79 }); 80 } catch (err) { 81 // Works in Internet Explorer (all versions) 82 event = document.createEvent("CustomEvent"); 83 event.initCustomEvent(eventString, false, false, { 84 instance: instance 85 }); 86 } 87 88 window.dispatchEvent(event); 89 }; 90 /* Auto initialization of one or more instances of lazyload, depending on the 91 options passed in (plain object or an array) */ 92 93 94 var autoInitialize = function autoInitialize(classObj, options) { 95 if (!options) { 96 return; 97 } 98 99 if (!options.length) { 100 // Plain object 101 createInstance(classObj, options); 102 } else { 103 // Array of objects 104 for (var i = 0, optionsItem; optionsItem = options[i]; i += 1) { 105 createInstance(classObj, optionsItem); 106 } 107 } 108 }; 109 110 var SRC = "src"; 111 var SRCSET = "srcset"; 112 var SIZES = "sizes"; 113 var POSTER = "poster"; 114 var ORIGINALS = "llOriginalAttrs"; 115 116 var statusLoading = "loading"; 117 var statusLoaded = "loaded"; 118 var statusApplied = "applied"; 119 var statusEntered = "entered"; 120 var statusError = "error"; 121 var statusNative = "native"; 122 123 var dataPrefix = "data-"; 124 var statusDataName = "ll-status"; 125 var getData = function getData(element, attribute) { 126 return element.getAttribute(dataPrefix + attribute); 127 }; 128 var setData = function setData(element, attribute, value) { 129 var attrName = dataPrefix + attribute; 130 131 if (value === null) { 132 element.removeAttribute(attrName); 133 return; 134 } 135 136 element.setAttribute(attrName, value); 137 }; 138 var getStatus = function getStatus(element) { 139 return getData(element, statusDataName); 140 }; 141 var setStatus = function setStatus(element, status) { 142 return setData(element, statusDataName, status); 143 }; 144 var resetStatus = function resetStatus(element) { 145 return setStatus(element, null); 146 }; 147 var hasEmptyStatus = function hasEmptyStatus(element) { 148 return getStatus(element) === null; 149 }; 150 var hasStatusLoading = function hasStatusLoading(element) { 151 return getStatus(element) === statusLoading; 152 }; 153 var hasStatusError = function hasStatusError(element) { 154 return getStatus(element) === statusError; 155 }; 156 var hasStatusNative = function hasStatusNative(element) { 157 return getStatus(element) === statusNative; 158 }; 159 var statusesAfterLoading = [statusLoading, statusLoaded, statusApplied, statusError]; 160 var hadStartedLoading = function hadStartedLoading(element) {
161 return statusesAfterLoading.indexOf(getStatus(element)) >= 0; 162 }; 163 164 var safeCallback = function safeCallback(callback, arg1, arg2, arg3) { 165 if (!callback) { 166 return; 167 } 168 169 if (arg3 !== undefined) { 170 callback(arg1, arg2, arg3); 171 return; 172 } 173 174 if (arg2 !== undefined) { 175 callback(arg1, arg2); 176 return; 177 } 178 179 callback(arg1); 180 }; 181 182 var addClass = function addClass(element, className) { 183 if (supportsClassList) { 184 element.classList.add(className); 185 return; 186 } 187 188 element.className += (element.className ? " " : "") + className; 189 }; 190 var removeClass = function removeClass(element, className) { 191 if (supportsClassList) { 192 element.classList.remove(className); 193 return; 194 } 195 196 element.className = element.className.replace(new RegExp("(^|\\s+)" + className + "(\\s+|$)"), " ").replace(/^\s+/, "").replace(/\s+$/, ""); 197 }; 198 199 var addTempImage = function addTempImage(element) { 200 element.llTempImage = document.createElement("IMG"); 201 }; 202 var deleteTempImage = function deleteTempImage(element) { 203 delete element.llTempImage; 204 }; 205 var getTempImage = function getTempImage(element) { 206 return element.llTempImage; 207 }; 208 209 var unobserve = function unobserve(element, instance) { 210 if (!instance) return; 211 var observer = instance._observer; 212 if (!observer) return; 213 observer.unobserve(element); 214 }; 215 var resetObserver = function resetObserver(observer) { 216 observer.disconnect(); 217 }; 218 var unobserveEntered = function unobserveEntered(element, settings, instance) { 219 if (settings.unobserve_entered) unobserve(element, instance); 220 }; 221 222 var updateLoadingCount = function updateLoadingCount(instance, delta) { 223 if (!instance) return; 224 instance.loadingCount += delta; 225 }; 226 var decreaseToLoadCount = function decreaseToLoadCount(instance) { 227 if (!instance) return; 228 instance.toLoadCount -= 1; 229 }; 230 var setToLoadCount = function setToLoadCount(instance, value) { 231 if (!instance) return; 232 instance.toLoadCount = value; 233 }; 234 var isSomethingLoading = function isSomethingLoading(instance) { 235 return instance.loadingCount > 0; 236 }; 237 var haveElementsToLoad = function haveElementsToLoad(instance) { 238 return instance.toLoadCount > 0; 239 }; 240 241 var getSourceTags = function getSourceTags(parentTag) { 242 var sourceTags = []; 243 244 for (var i = 0, childTag; childTag = parentTag.children[i]; i += 1) { 245 if (childTag.tagName === "SOURCE") { 246 sourceTags.push(childTag); 247 } 248 } 249 250 return sourceTags; 251 }; 252 253 var forEachPictureSource = function forEachPictureSource(element, fn) { 254 var parent = element.parentNode; 255 256 if (!parent || parent.tagName !== "PICTURE") { 257 return; 258 } 259 260 var sourceTags = getSourceTags(parent); 261 sourceTags.forEach(fn); 262 }; 263 var forEachVideoSource = function forEachVideoSource(element, fn) { 264 var sourceTags = getSourceTags(element); 265 sourceTags.forEach(fn); 266 }; 267 268 var attrsSrc = [SRC]; 269 var attrsSrcPoster = [SRC, POSTER]; 270 var attrsSrcSrcsetSizes = [SRC, SRCSET, SIZES]; 271 var hasOriginalAttrs = function hasOriginalAttrs(element) { 272 return !!element[ORIGINALS]; 273 }; 274 var getOriginalAttrs = function getOriginalAttrs(element) { 275 return element[ORIGINALS]; 276 }; 277 var deleteOriginalAttrs = function deleteOriginalAttrs(element) { 278 return delete element[ORIGINALS]; 279 }; // ## SAVE ## 280 281 var setOriginalsObject = function setOriginalsObject(element, attributes) { 282 if (hasOriginalAttrs(element)) { 283 return; 284 } 285 286 var originals = {}; 287 attributes.forEach(function (attribute) { 288 originals[attribute] = element.getAttribute(attribute); 289 }); 290 element[ORIGINALS] = originals; 291 };
292 var saveOriginalBackgroundStyle = function saveOriginalBackgroundStyle(element) { 293 if (hasOriginalAttrs(element)) { 294 return; 295 } 296 297 element[ORIGINALS] = { 298 backgroundImage: element.style.backgroundImage 299 }; 300 }; // ## RESTORE ## 301 302 var setOrResetAttribute = function setOrResetAttribute(element, attrName, value) { 303 if (!value) { 304 element.removeAttribute(attrName); 305 return; 306 } 307 308 element.setAttribute(attrName, value); 309 }; 310 311 var restoreOriginalAttrs = function restoreOriginalAttrs(element, attributes) { 312 if (!hasOriginalAttrs(element)) { 313 return; 314 } 315 316 var originals = getOriginalAttrs(element); 317 attributes.forEach(function (attribute) { 318 setOrResetAttribute(element, attribute, originals[attribute]); 319 }); 320 }; 321 var restoreOriginalBgImage = function restoreOriginalBgImage(element) { 322 if (!hasOriginalAttrs(element)) { 323 return; 324 } 325 326 var originals = getOriginalAttrs(element); 327 element.style.backgroundImage = originals.backgroundImage; 328 }; 329 330 var manageApplied = function manageApplied(element, settings, instance) { 331 addClass(element, settings.class_applied); 332 setStatus(element, statusApplied); // Instance is not provided when loading is called from static class 333 334 if (!instance) return; 335 336 if (settings.unobserve_completed) { 337 // Unobserve now because we can't do it on load 338 unobserve(element, settings); 339 } 340 341 safeCallback(settings.callback_applied, element, instance); 342 }; 343 var manageLoading = function manageLoading(element, settings, instance) { 344 addClass(element, settings.class_loading); 345 setStatus(element, statusLoading); // Instance is not provided when loading is called from static class 346 347 if (!instance) return; 348 updateLoadingCount(instance, +1); 349 safeCallback(settings.callback_loading, element, instance); 350 }; 351 var setAttributeIfValue = function setAttributeIfValue(element, attrName, value) { 352 if (!value) { 353 return; 354 } 355 356 element.setAttribute(attrName, value); 357 }; 358 var setImageAttributes = function setImageAttributes(element, settings) { 359 setAttributeIfValue(element, SIZES, getData(element, settings.data_sizes)); 360 setAttributeIfValue(element, SRCSET, getData(element, settings.data_srcset)); 361 setAttributeIfValue(element, SRC, getData(element, settings.data_src)); 362 }; 363 var setSourcesImg = function setSourcesImg(imgEl, settings) { 364 forEachPictureSource(imgEl, function (sourceTag) { 365 setOriginalsObject(sourceTag, attrsSrcSrcsetSizes); 366 setImageAttributes(sourceTag, settings); 367 }); 368 setOriginalsObject(imgEl, attrsSrcSrcsetSizes); 369 setImageAttributes(imgEl, settings); 370 }; 371 var setSourcesIframe = function setSourcesIframe(iframe, settings) { 372 setOriginalsObject(iframe, attrsSrc); 373 setAttributeIfValue(iframe, SRC, getData(iframe, settings.data_src)); 374 }; 375 var setSourcesVideo = function setSourcesVideo(videoEl, settings) { 376 forEachVideoSource(videoEl, function (sourceEl) { 377 setOriginalsObject(sourceEl, attrsSrc); 378 setAttributeIfValue(sourceEl, SRC, getData(sourceEl, settings.data_src)); 379 }); 380 setOriginalsObject(videoEl, attrsSrcPoster); 381 setAttributeIfValue(videoEl, POSTER, getData(videoEl, settings.data_poster)); 382 setAttributeIfValue(videoEl, SRC, getData(videoEl, settings.data_src)); 383 videoEl.load(); 384 }; 385 var setBackground = function setBackground(element, settings, instance) { 386 var bg1xValue = getData(element, settings.data_bg); 387 var bgHiDpiValue = getData(element, settings.data_bg_hidpi); 388 var bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue; 389 if (!bgDataValue) return; 390 element.style.backgroundImage = "url(\"".concat(bgDataValue, "\")"); 391 getTempImage(element).setAttribute(SRC, bgDataValue); 392 manageLoading(element, settings, instance); 393 }; // NOTE: THE TEMP IMAGE TRICK CANNOT BE DONE WITH data-multi-bg 394 // BECAUSE INSIDE ITS VALUES MUST BE WRAPPED WITH URL() AND ONE OF THEM 395 // COULD BE A GRADIENT BACKGROUND IMAGE 396
397 var setMultiBackground = function setMultiBackground(element, settings, instance) { 398 var bg1xValue = getData(element, settings.data_bg_multi); 399 var bgHiDpiValue = getData(element, settings.data_bg_multi_hidpi); 400 var bgDataValue = isHiDpi && bgHiDpiValue ? bgHiDpiValue : bg1xValue; 401 402 if (!bgDataValue) { 403 return; 404 } 405 406 element.style.backgroundImage = bgDataValue; 407 manageApplied(element, settings, instance); 408 }; 409 var setSourcesFunctions = { 410 IMG: setSourcesImg, 411 IFRAME: setSourcesIframe, 412 VIDEO: setSourcesVideo 413 }; 414 var setSourcesNative = function setSourcesNative(element, settings) { 415 var setSourcesFunction = setSourcesFunctions[element.tagName]; 416 417 if (!setSourcesFunction) { 418 return; 419 } 420 421 setSourcesFunction(element, settings); 422 }; 423 var setSources = function setSources(element, settings, instance) { 424 var setSourcesFunction = setSourcesFunctions[element.tagName]; 425 426 if (!setSourcesFunction) { 427 return; 428 } 429 430 setSourcesFunction(element, settings); 431 manageLoading(element, settings, instance); 432 }; 433 434 var elementsWithLoadEvent = ["IMG", "IFRAME", "VIDEO"]; 435 var hasLoadEvent = function hasLoadEvent(element) { 436 return elementsWithLoadEvent.indexOf(element.tagName) > -1; 437 }; 438 var checkFinish = function checkFinish(settings, instance) { 439 if (instance && !isSomethingLoading(instance) && !haveElementsToLoad(instance)) { 440 safeCallback(settings.callback_finish, instance); 441 } 442 }; 443 var addEventListener = function addEventListener(element, eventName, handler) { 444 element.addEventListener(eventName, handler); 445 element.llEvLisnrs[eventName] = handler; 446 }; 447 var removeEventListener = function removeEventListener(element, eventName, handler) { 448 element.removeEventListener(eventName, handler); 449 }; 450 var hasEventListeners = function hasEventListeners(element) { 451 return !!element.llEvLisnrs; 452 }; 453 var addEventListeners = function addEventListeners(element, loadHandler, errorHandler) { 454 if (!hasEventListeners(element)) element.llEvLisnrs = {}; 455 var loadEventName = element.tagName === "VIDEO" ? "loadeddata" : "load"; 456 addEventListener(element, loadEventName, loadHandler); 457 addEventListener(element, "error", errorHandler); 458 }; 459 var removeEventListeners = function removeEventListeners(element) { 460 if (!hasEventListeners(element)) { 461 return; 462 } 463 464 var eventListeners = element.llEvLisnrs; 465 466 for (var eventName in eventListeners) { 467 var handler = eventListeners[eventName]; 468 removeEventListener(element, eventName, handler); 469 } 470 471 delete element.llEvLisnrs; 472 }; 473 var doneHandler = function doneHandler(element, settings, instance) { 474 deleteTempImage(element); 475 updateLoadingCount(instance, -1); 476 decreaseToLoadCount(instance); 477 removeClass(element, settings.class_loading); 478 479 if (settings.unobserve_completed) { 480 unobserve(element, instance); 481 } 482 }; 483 var loadHandler = function loadHandler(event, element, settings, instance) { 484 var goingNative = hasStatusNative(element); 485 doneHandler(element, settings, instance); 486 addClass(element, settings.class_loaded); 487 setStatus(element, statusLoaded); 488 safeCallback(settings.callback_loaded, element, instance); 489 if (!goingNative) checkFinish(settings, instance); 490 }; 491 var errorHandler = function errorHandler(event, element, settings, instance) { 492 var goingNative = hasStatusNative(element); 493 doneHandler(element, settings, instance); 494 addClass(element, settings.class_error); 495 setStatus(element, statusError); 496 safeCallback(settings.callback_error, element, instance); 497 if (!goingNative) checkFinish(settings, instance); 498 }; 499 var addOneShotEventListeners = function addOneShotEventListeners(element, settings, instance) { 500 var elementToListenTo = getTempImage(element) || element; 501 502 if (hasEventListeners(elementToListenTo)) { 503 // This happens when loading is retried twice 504 return; 505 } 506 507 var _loadHandler = function _loadHandler(event) { 508 loadHandler(event, element, settings, instance); 509 removeEventListeners(elementToListenTo); 510 }; 511 512 var _errorHandler = function _errorHandler(event) { 513 errorHandler(event, element, settings, instance); 514 removeEventListeners(elementToListenTo); 515 }; 516 517 addEventListeners(elementToListenTo, _loadHandler, _errorHandler); 518 }; 519
520 var loadBackground = function loadBackground(element, settings, instance) { 521 addTempImage(element); 522 addOneShotEventListeners(element, settings, instance); 523 saveOriginalBackgroundStyle(element); 524 setBackground(element, settings, instance); 525 setMultiBackground(element, settings, instance); 526 }; 527 528 var loadRegular = function loadRegular(element, settings, instance) { 529 addOneShotEventListeners(element, settings, instance); 530 setSources(element, settings, instance); 531 }; 532 533 var load = function load(element, settings, instance) { 534 if (hasLoadEvent(element)) { 535 loadRegular(element, settings, instance); 536 } else { 537 loadBackground(element, settings, instance); 538 } 539 }; 540 var loadNative = function loadNative(element, settings, instance) { 541 element.setAttribute("loading", "lazy"); 542 addOneShotEventListeners(element, settings, instance); 543 setSourcesNative(element, settings); 544 setStatus(element, statusNative); 545 }; 546 547 var removeImageAttributes = function removeImageAttributes(element) { 548 element.removeAttribute(SRC); 549 element.removeAttribute(SRCSET); 550 element.removeAttribute(SIZES); 551 }; 552 553 var resetSourcesImg = function resetSourcesImg(element) { 554 forEachPictureSource(element, function (sourceTag) { 555 removeImageAttributes(sourceTag); 556 }); 557 removeImageAttributes(element); 558 }; 559 560 var restoreImg = function restoreImg(imgEl) { 561 forEachPictureSource(imgEl, function (sourceEl) { 562 restoreOriginalAttrs(sourceEl, attrsSrcSrcsetSizes); 563 }); 564 restoreOriginalAttrs(imgEl, attrsSrcSrcsetSizes); 565 }; 566 var restoreVideo = function restoreVideo(videoEl) { 567 forEachVideoSource(videoEl, function (sourceEl) { 568 restoreOriginalAttrs(sourceEl, attrsSrc); 569 }); 570 restoreOriginalAttrs(videoEl, attrsSrcPoster); 571 videoEl.load(); 572 }; 573 var restoreIframe = function restoreIframe(iframeEl) { 574 restoreOriginalAttrs(iframeEl, attrsSrc); 575 }; 576 var restoreFunctions = { 577 IMG: restoreImg, 578 IFRAME: restoreIframe, 579 VIDEO: restoreVideo 580 }; 581 582 var restoreAttributes = function restoreAttributes(element) { 583 var restoreFunction = restoreFunctions[element.tagName]; 584 585 if (!restoreFunction) { 586 restoreOriginalBgImage(element); 587 return; 588 } 589 590 restoreFunction(element); 591 }; 592 593 var resetClasses = function resetClasses(element, settings) { 594 if (hasEmptyStatus(element) || hasStatusNative(element)) { 595 return; 596 } 597 598 removeClass(element, settings.class_entered); 599 removeClass(element, settings.class_exited); 600 removeClass(element, settings.class_applied); 601 removeClass(element, settings.class_loading); 602 removeClass(element, settings.class_loaded); 603 removeClass(element, settings.class_error); 604 }; 605 606 var restore = function restore(element, settings) { 607 restoreAttributes(element); 608 resetClasses(element, settings); 609 resetStatus(element); 610 deleteOriginalAttrs(element); 611 }; 612 613 var cancelLoading = function cancelLoading(element, entry, settings, instance) { 614 if (!settings.cancel_on_exit) return; 615 if (!hasStatusLoading(element)) return; 616 if (element.tagName !== "IMG") return; //Works only on images 617 618 removeEventListeners(element); 619 resetSourcesImg(element); 620 restoreImg(element); 621 removeClass(element, settings.class_loading); 622 updateLoadingCount(instance, -1); 623 resetStatus(element); 624 safeCallback(settings.callback_cancel, element, entry, instance); 625 }; 626 627 var onEnter = function onEnter(element, entry, settings, instance) { 628 var dontLoad = hadStartedLoading(element); 629 /* Save status 630 before setting it, to prevent loading it again. Fixes #526. */ 631 632 setStatus(element, statusEntered); 633 addClass(element, settings.class_entered); 634 removeClass(element, settings.class_exited); 635 unobserveEntered(element, settings, instance); 636 safeCallback(settings.callback_enter, element, entry, instance); 637 if (dontLoad) return; 638 load(element, settings, instance); 639 }; 640 var onExit = function onExit(element, entry, settings, instance) { 641 if (hasEmptyStatus(element)) return; //Ignore the first pass, at landing 642 643 addClass(element, settings.class_exited); 644 cancelLoading(element, entry, settings, instance); 645 safeCallback(settings.callback_exit, element, entry, instance); 646 }; 647 648 var tagsWithNativeLazy = ["IMG", "IFRAME", "VIDEO"]; 649 var shouldUseNative = function shouldUseNative(settings) { 650 return settings.use_native && "loading" in HTMLImageElement.prototype; 651 }; 652 var loadAllNative = function loadAllNative(elements, settings, instance) {
653 elements.forEach(function (element) { 654 if (tagsWithNativeLazy.indexOf(element.tagName) === -1) { 655 return; 656 } 657 658 loadNative(element, settings, instance); 659 }); 660 setToLoadCount(instance, 0); 661 }; 662 663 var isIntersecting = function isIntersecting(entry) { 664 return entry.isIntersecting || entry.intersectionRatio > 0; 665 }; 666 667 var getObserverSettings = function getObserverSettings(settings) { 668 return { 669 root: settings.container === document ? null : settings.container, 670 rootMargin: settings.thresholds || settings.threshold + "px" 671 }; 672 }; 673 674 var intersectionHandler = function intersectionHandler(entries, settings, instance) { 675 entries.forEach(function (entry) { 676 return isIntersecting(entry) ? onEnter(entry.target, entry, settings, instance) : onExit(entry.target, entry, settings, instance); 677 }); 678 }; 679 680 var observeElements = function observeElements(observer, elements) { 681 elements.forEach(function (element) { 682 observer.observe(element); 683 }); 684 }; 685 var updateObserver = function updateObserver(observer, elementsToObserve) { 686 resetObserver(observer); 687 observeElements(observer, elementsToObserve); 688 }; 689 var setObserver = function setObserver(settings, instance) { 690 if (!supportsIntersectionObserver || shouldUseNative(settings)) { 691 return; 692 } 693 694 instance._observer = new IntersectionObserver(function (entries) { 695 intersectionHandler(entries, settings, instance); 696 }, getObserverSettings(settings)); 697 }; 698 699 var toArray = function toArray(nodeSet) { 700 return Array.prototype.slice.call(nodeSet); 701 }; 702 var queryElements = function queryElements(settings) { 703 return settings.container.querySelectorAll(settings.elements_selector); 704 }; 705 var excludeManagedElements = function excludeManagedElements(elements) { 706 return toArray(elements).filter(hasEmptyStatus); 707 }; 708 var hasError = function hasError(element) { 709 return hasStatusError(element); 710 }; 711 var filterErrorElements = function filterErrorElements(elements) { 712 return toArray(elements).filter(hasError); 713 }; 714 var getElementsToLoad = function getElementsToLoad(elements, settings) { 715 return excludeManagedElements(elements || queryElements(settings)); 716 }; 717 718 var retryLazyLoad = function retryLazyLoad(settings, instance) { 719 var errorElements = filterErrorElements(queryElements(settings)); 720 errorElements.forEach(function (element) { 721 removeClass(element, settings.class_error); 722 resetStatus(element); 723 }); 724 instance.update(); 725 }; 726 var setOnlineCheck = function setOnlineCheck(settings, instance) { 727 if (!runningOnBrowser) { 728 return; 729 } 730 731 window.addEventListener("online", function () { 732 retryLazyLoad(settings, instance); 733 }); 734 }; 735 736 var LazyLoad = function LazyLoad(customSettings, elements) { 737 var settings = getExtendedSettings(customSettings); 738 this._settings = settings; 739 this.loadingCount = 0; 740 setObserver(settings, this); 741 setOnlineCheck(settings, this); 742 this.update(elements); 743 }; 744 745 LazyLoad.prototype = { 746 update: function update(givenNodeset) { 747 var settings = this._settings; 748 var elementsToLoad = getElementsToLoad(givenNodeset, settings); 749 setToLoadCount(this, elementsToLoad.length); 750 751 if (isBot || !supportsIntersectionObserver) { 752 this.loadAll(elementsToLoad); 753 return; 754 } 755 756 if (shouldUseNative(settings)) { 757 loadAllNative(elementsToLoad, settings, this); 758 return; 759 } 760 761 updateObserver(this._observer, elementsToLoad); 762 }, 763 destroy: function destroy() { 764 // Observer 765 if (this._observer) { 766 this._observer.disconnect(); 767 } // Clean custom attributes on elements 768 769
770 queryElements(this._settings).forEach(function (element) { 771 deleteOriginalAttrs(element); 772 }); // Delete all internal props 773 774 delete this._observer; 775 delete this._settings; 776 delete this.loadingCount; 777 delete this.toLoadCount; 778 }, 779 loadAll: function loadAll(elements) { 780 var _this = this; 781 782 var settings = this._settings; 783 var elementsToLoad = getElementsToLoad(elements, settings); 784 elementsToLoad.forEach(function (element) { 785 unobserve(element, _this); 786 load(element, settings, _this); 787 }); 788 }, 789 restoreAll: function restoreAll() { 790 var settings = this._settings; 791 queryElements(settings).forEach(function (element) { 792 restore(element, settings); 793 }); 794 } 795 }; 796 797 LazyLoad.load = function (element, customSettings) { 798 var settings = getExtendedSettings(customSettings); 799 load(element, settings); 800 }; 801 802 LazyLoad.resetStatus = function (element) { 803 resetStatus(element); 804 }; // Automatic instances creation if required (useful for async script loading) 805 806 807 if (runningOnBrowser) { 808 autoInitialize(LazyLoad, window.lazyLoadOptions); 809 } 810 811 return LazyLoad; 812 813})));
Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.