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})));
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.