integral 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7a76c7625e0d568743ac3d46253e00ca55949cb6
-  data.tar.gz: 5ea751e58f06074824da0d95106c9f1757923629
+  metadata.gz: 79d9ffb78cf456a49d8dc4b6c41ff99bb94d473a
+  data.tar.gz: 7691ba54679f3c1b0dd8e7fadb20f1ff3f22601d
 SHA512:
-  metadata.gz: 501c8ca1f8cf1cb6212e53923c1dc8e51d7d30cc60a48c7b339134d2af2043c59d84b8e37942e7dadb7c03f876e5d2f515d801a3ec5db6413c2b2c07aa112314
-  data.tar.gz: 9f2569eb03fac519a228958c2188dec8e4ebf1ef21943d4e4cfb33e79d541ee347664fca71fd7122e8d7e833eac402e063845febd7c8e6aca319d9f251308bb3
+  metadata.gz: 6852ebaa96f6d6b6e2aaa3aaa61ef02063ba54ce3ebb1740859e94ce229c0c5b2c78a1ab51a610c8faf01d9945c69761f753f36aaecdefa7de9aef611913fc48
+  data.tar.gz: d4a8027d77dc2a8e19fa297c0d0b1146c8aa598023a30efb808d5bfec7cbf0432746814e37587dbedc0e6e852cb2bc921c705b8501bc2627bf7baa47dd3e66e8

data/README.md

@@ -27,44 +27,16 @@ Out of the box integral provides;
 
 ## Getting Started
 
-1. Create a new Rails application
-```
-  rails new example_app --database=postgresql -T
-```
-2. Add Integral to your Gemfile and run `bundle install`
- ```
-  gem 'integral'
- ```
-3. Run Integral install rake task (adds configuration initializers, installs routes & sets up database)
- ```
-rails generate integral:install
- ```
-4. Set the default host within the development environment, used for URL generation
-```
-# config/environments/development.rb
-
-Rails.application.routes.default_url_options[:host] = 'http://localhost:3000'
-```
-
-Voila! Start your rails server and you're ready to go! You can access the user only area at `/admin`
-
-Integral requires Rails 5.1 or higher and Ruby 2.4.1 or higher.
+Get a professional website up and running in minutes - Check out our [documentation website](https://integralrails.com/docs) for installation instructions and guides.
 
 ## Information
 
 * [Integral Website][integral-cms]
+* [Integral Docs](https://integralrails.com/docs)
 * [CHANGELOG](https://github.com/yamasolutions/integral/blob/master/CHANGELOG.md)
 * [Code Documentation][docs-website]
 * [Wish list](https://github.com/yamasolutions/integral/wiki/Wish-List)
 
-### Guides
-* [Deploying to production](https://github.com/yamasolutions/integral/blob/master/docs/deploying_to_production.md)
-* [Integral <3 Heroku](https://github.com/yamasolutions/integral/blob/master/docs/heroku.md)
-* [Extending Integral](https://github.com/yamasolutions/integral/blob/master/docs/extending_integral.md)
-* [Integral Lists](https://github.com/yamasolutions/integral/blob/master/docs/integral_lists.md)
-* [Integral Pages](https://github.com/yamasolutions/integral/blob/master/docs/integral_pages.md)
-* [Integral Widgets](https://github.com/yamasolutions/integral/blob/master/docs/integral_widgets.md)
-* [WYSIWYG Editor](https://github.com/yamasolutions/integral/blob/master/docs/wysiwyg_editor.md)
 
 ### Bug reporting
 If you discover a problem with Integral, we would love to know about it. Please use the [GitHub issue tracker][github-issue-tracker] to contact us about it.

data/Rakefile

@@ -14,7 +14,7 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
 load 'rails/tasks/engine.rake'
 
 load 'rails/tasks/statistics.rake'

data/app/assets/javascripts/integral/backend.js

@@ -50,8 +50,90 @@ function ready() {
   new ChartManager();
   NotificationManager.flash();
   ImageUploader.init();
+  new RemoteForm($('.remote-form'));
   Grid.init();
 
+  // Recent activity 'view more' behaviour
+  $("[data-recent-activity]").on("click", function(ev) {
+    $button = $(ev.currentTarget);
+    modalId = $button.data('container-id');
+
+    $modal = $('#' + modalId);
+    if ($modal.length > 0) {
+      $modal.foundation('open');
+    } else {
+      $modal = $('#activity-placeholder').clone().appendTo('body')
+      $form = $modal.find('form')
+      $modal.attr('id', modalId)
+      $modal.foundation()
+
+      // Populate modal with content & filters
+      $modal.find('[data-title]').html($button.data('recent-activity-title'))
+      $modal.find('[data-timeline]').html($button.closest('.card').find('.timeline').html())
+      $form.find("input[name='grid[user]']").val($button.data('recent-activity-user'))
+      $form.find("input[name='grid[object]']").val($button.data('recent-activity-object'))
+      $form.find("input[name='grid[created_at]']").val($button.data('recent-activity-created-at'))
+      $form.find("input[name='grid[item_id]']").val($button.data('recent-activity-item-id'))
+
+      $form.on( "ajax:success", function(event, response) {
+        if (response.last_created_at != null) {
+          $modal.find('[data-timeline]').append(response.content)
+          $form.find("input[name='grid[created_at]']").val(response.last_created_at)
+        } else {
+          $form.find("input[type='submit']").hide()
+        }
+      });
+
+      $modal.foundation('open')
+      $form.submit()
+    }
+  });
+
+  // Hijack context menu click for rows which have a URL
+  $("tr[data-href]").on("contextmenu", function(ev) {
+    $('#' + ev.currentTarget.dataset.contextMenu).foundation('open');
+
+    return false;
+  });
+
+  // Capture clicks on rows which have a URL and visit that URL
+  $("tr[data-href]").on("click", function(ev) {
+    // Do not follow if the click is within a data-toggle
+    if (($(ev.target).closest('[data-toggle]').length == 0) && ($(ev.target).closest('[data-dropdown]').length == 0)) {
+      document.location = $(ev.currentTarget).data('href');
+    }
+  });
+
+  $("[data-button-delete-category]").on("ajax:success", function(ev) {
+    $(ev.currentTarget).closest('tr').fadeOut();
+  });
+
+  $("[data-button-delete-category]").on("ajax:error", function(ev) {
+    toastr["error"](I18n.t('integral.remote_form.error'));
+  });
+
+  $("#new_category_modal").on("open.zf.reveal", function(ev) {
+    $(ev.currentTarget).find('form').enableClientSideValidations();
+  });
+
+  $("[data-button-edit-category]").on( "click", function(ev) {
+    modalId = '#' + ev.currentTarget.dataset.buttonEditCategory;
+    modalUrl = ev.currentTarget.dataset.modalUrl;
+
+    if ($(modalId).length == 0) {
+      $.ajax({url: modalUrl, success: function(response){
+        $('body').append(response.content);
+        modal = $(modalId);
+        modal.foundation().foundation('open');
+        modal.find('form').enableClientSideValidations();
+        new RemoteForm(modal.find('form'));
+        SlugGenerator.check_for_slugs();
+      }});
+    } else {
+      $(modalId).foundation('open');
+    }
+  });
+
   if (($('body.lists.new').length > 0) || ($('body.lists.show').length > 0) || ($('body.lists.edit').length > 0)) {
     new List();
   }
@@ -226,25 +308,34 @@ function ready() {
   };
 
   // Material Tags
-  $("input[data-role=materialtags]").each(function( index ) {
-    suggestableInput = $(this)
-      typeaheadSuggestions = suggestableInput.data('typeahead').split(' ')
-
-      // Initialize suggest engine
-      suggestEngine = new Bloodhound({
-        datumTokenizer: Bloodhound.tokenizers.whitespace,
-        queryTokenizer: Bloodhound.tokenizers.whitespace,
-        local: typeaheadSuggestions
-      });
+  $("[data-suggest-tags]").each(function( index ) {
+    suggestableInput = $(this);
+    typeaheadSuggestions = suggestableInput.data('suggestTagsTypeahead').split(' ');
+    freeInput = suggestableInput.data('suggestTagsFreeInput');
+
+    if (typeof freeInput === 'undefined') {
+      freeInput = true;
+    }
+
+    // Initialize suggest engine
+    suggestEngine = new Bloodhound({
+      datumTokenizer: Bloodhound.tokenizers.whitespace,
+      queryTokenizer: Bloodhound.tokenizers.whitespace,
+      local: typeaheadSuggestions
+    });
 
     // Initialize materialtags
     suggestableInput.materialtags({
+      freeInput: freeInput,
       typeaheadjs: {
         source: function(query, cb) {
           suggestEngine.search(query, function(suggestions) {
             cb(filterSuggestions(suggestableInput, suggestions));
           });
-        }
+        },
+        // TODO: These two options don't currently work but would be nice to add in
+        autoselect: true,
+        highlight: true
       }
     });
   });

data/app/assets/javascripts/integral/frontend.js

@@ -9,6 +9,10 @@
 //= require toastr
 //= require rails.validations
 //= require rails.validations.simple_form
+//= require integral/support/lib/lazysizes
+//= require integral/support/ls.twitter
+//= require integral/support/ls.instagram
+//= require integral/support/date_picker
 //= require integral/support/date_picker
 //= require integral/support/click_to_copy
 //= require integral/support/google_analytics
@@ -33,6 +37,39 @@ function ready() {
   new RemoteForm($('.remote-form'));
   new DatePicker('.datepicker');
   GoogleAnalytics.trackRead();
+
+  // Move most read posts widget to middle of post listing (can't do this serverside due to caching)
+  $mostReadWidget = $('[data-most-read-posts]');
+  if ($mostReadWidget.length == 1) {
+    $('[data-most-read-posts]').insertAfter('[data-post-list] div:nth-child(5)');
+  }
+
+  // Scroll Container
+  // TODO
+  // in future allow to configure each scroll-container how it activiates
+  // also update when changing size
+  $(".scroll-container").each(function( index ) {
+    container = $(this);
+    wrapper = container.find('.scroll-wrapper');
+    visibleChildren = wrapper.children(':visible');
+    //elementWidth = '250';
+    elementWidth = parseInt(container.data('item-width'))
+
+    validSizes = ['small', 'medium']
+    //if (Foundation.MediaQuery.current == 'small') {
+    if (validSizes.includes(Foundation.MediaQuery.current)) {
+
+      visibleChildren.each(function(index) {
+        $(this).css('width', elementWidth);
+        $(this).css('max-width', 'unset');
+      });
+
+      firstChild = visibleChildren.first()
+      wrapperWidth = (elementWidth + (parseInt(firstChild.css('marginLeft')) + parseInt(firstChild.css('marginRight')))) * visibleChildren.size();
+      widthCss = wrapperWidth + 'px';
+      wrapper.css('width', widthCss);
+    }
+  });
 };
 
 // Initial Page load event handler

data/app/assets/javascripts/integral/support/confirm_modal.coffee

@@ -16,8 +16,8 @@ $.rails.buildConfirmationDialog = (message, modalId, confirmBtnId, cancelBtnId)
     </div>
 
     <div class='modal-footer'>
-       <a id='#{cancelBtnId}' class='button secondary hollow'>#{I18n.t('integral.actions.cancel')}</a>
-       <a id='#{confirmBtnId}' class='button primary'>#{I18n.t('integral.actions.confirm')}</a>
+       <button id='#{cancelBtnId}' class='button secondary hollow'>#{I18n.t('integral.actions.cancel')}</button>
+       <button id='#{confirmBtnId}' class='button primary'>#{I18n.t('integral.actions.confirm')}</button>
     </div>
      <button class='close-button' data-close aria-label='Close modal' type='button'>
        <span aria-hidden='true'>&times;</span>

data/app/assets/javascripts/integral/support/gallery.coffee

@@ -1,68 +1,65 @@
 # Handles interaction with galleries
 class this.Gallery
   @init: ->
-    new Gallery()
-
-  # Initiate a Gallery
-  #
-  # @usage new Gallery($('form'))
-  constructor: (opts={}) ->
-    @placeholder = $('#gallery-placeholder')
-    @_setupEvents()
-
-
-  # Create listeners and handlers for form events
-  _setupEvents: =>
     # Watch for when a user opens a gallery
     $('.js-gallery-link').on "click", (event) =>
-      @_open_or_create_gallery(event)
+      target = event.currentTarget.dataset.target
+      url = event.currentTarget.dataset.url
+      @open_or_create_gallery(target, url)
 
-  # Open Gallery or create it and open placeholder
-  _open_or_create_gallery: (event) =>
-    galleryId = event.currentTarget.dataset.target
-    return @_handleError() if galleryId == undefined
+  # Open Gallery or create new one
+  @open_or_create_gallery: (id, url) =>
+    return Gallery.handleError() if id == undefined
 
-    gallery = $("##{galleryId}")
+    gallery = $("##{id}")
     if gallery.length > 0
       gallery.foundation('open')
     else
-      url = event.currentTarget.dataset.url
-      return @_handleError() if url == undefined
-      @_createGallery(galleryId, url)
+      return Gallery.handleError() if url == undefined
+      new Gallery(id, url)
+
+  @handleError: =>
+    toastr['error']('Sorry, an unexpected error occurred. Please try again later.')
+
+  # Initiate a Gallery
+  #
+  # @usage new Gallery('myGallery', 'link-to-gallery-content')
+  constructor: (id, url, opts={}) ->
+    placeholder = $('#gallery-placeholder')
 
-  # What happens after AJAX request is complete
-  _createGallery: (id, url) =>
     # Copy placeholder gallery, set ID, initialize & open
-    gallery = @placeholder.clone().appendTo('body')
-    gallery.attr('id', id)
-    gallery.foundation()
-    gallery.foundation('open')
+    @$container = placeholder.clone().appendTo('body')
+    @youtubeEmbeds = []
+    @$container.attr('id', id)
+    @$container.foundation()
+    @$container.foundation('open')
 
     # Download gallery content
     $.ajax
       url: url,
-      context: gallery
     .success (data, textStatus, jqXHR) =>
-      @_setupGallery(gallery, data)
+      @_setupGallery(data)
     .error (e, data, status, xhr) =>
-      @_handleError()
+      Gallery.handleError()
 
-  _setupGallery: (gallery, data) =>
+  _setupGallery: (data) =>
     # Copy gallery into Modal
-    gallery.find('.content').html(data)
-    galleryContent = gallery.find('.content')
+    @$container.find('.content').html(data)
+    @$galleryContent = @$container.find('.content')
 
-    mainSwiper = galleryContent.find('.main-swiper')
-    # Setup galleries
-    if mainSwiper.length > 0
-      projectGalleryTop = new Swiper(mainSwiper[0], {
+    @_setupYoutube()
+
+    @$mainSwiper = @$galleryContent.find('.main-swiper')
+    # Setup galleries (when present)
+    if @$mainSwiper.length > 0
+      projectGalleryTop = new Swiper(@$mainSwiper[0], {
         spaceBetween: 10,
         navigation: {
           nextEl: '.swiper-button-next',
           prevEl: '.swiper-button-prev',
         },
       })
-      projectGalleryThumbs = new Swiper(galleryContent.find('.thumb-swiper'), {
+      projectGalleryThumbs = new Swiper(@$galleryContent.find('.thumb-swiper'), {
         spaceBetween: 10,
         centeredSlides: true,
         slidesPerView: 'auto',
@@ -72,22 +69,14 @@ class this.Gallery
       projectGalleryTop.controller.control = projectGalleryThumbs
       projectGalleryThumbs.controller.control = projectGalleryTop
 
-    # Set main swiper size
-    revealHeight = gallery.height()
-    thumbSwiperHeight = galleryContent.find('.thumb-swiper').height()
-    revealAvailableHeight = revealHeight - thumbSwiperHeight
-    mainSwiper.height(revealAvailableHeight)
+    @_setSwiperSize()
 
     window.addEventListener 'resize', =>
-      # TODO: Tidy up this duplication
-      revealHeight = gallery.height()
-      thumbSwiperHeight = galleryContent.find('.thumb-swiper').height()
-      revealAvailableHeight = revealHeight - thumbSwiperHeight
-      mainSwiper.height(revealAvailableHeight)
+      @_setSwiperSize()
 
     # Listen for arrow keys
     $(document).keydown (event) =>
-      return unless gallery.is(':focus')
+      return unless @$container.is(':focus')
 
       switch event.which
         when 37 # Left
@@ -98,10 +87,38 @@ class this.Gallery
           return # Exit this handler for other keys
 
     # Show/hide content and placeholder
-    gallery.find('.placeholder').css('display', 'none')
-    galleryContent.css('visibility', 'initial')
-
-  _handleError: =>
-    toastr['error']('Sorry, an unexpected error occurred. Please try again later.')
+    @$container.find('.placeholder').css('display', 'none')
+    @$galleryContent.css('visibility', 'initial')
 
+  _setSwiperSize: =>
+    revealHeight = @$container.height()
+    if @$mainSwiper.length > 0
+      thumbSwiperHeight = @$galleryContent.find('.thumb-swiper').height()
+      revealAvailableHeight = revealHeight - thumbSwiperHeight
+      @$mainSwiper.height(revealAvailableHeight)
+    else
+      @$galleryContent.height(revealHeight)
+
+  _setupYoutube: =>
+    embeds = @$container.find('iframe')
+    if embeds.length > 0
+      if typeof YT == 'undefined'
+        # Download YT script and wait until API is ready
+        # TODO: Clean up wait hack
+        console.log('Downloading YT script')
+        $.getScript "https://www.youtube.com/iframe_api", =>
+          setTimeout =>
+            @_setupEmbeds(embeds)
+          , 1500
+      else
+        @_setupEmbeds(embeds)
+
+  _setupEmbeds: (embeds) =>
+    embeds.each (index, element) =>
+      player = new YT.Player(element)
+      @youtubeEmbeds.push(player)
+
+      @$container.on 'closed.zf.reveal', =>
+        @youtubeEmbeds.forEach (element) =>
+          element.pauseVideo()
 

data/app/assets/javascripts/integral/support/lib/lazysizes.js

@@ -0,0 +1,755 @@
+/* 5.2.0 - https://github.com/aFarkas/lazysizes */
+(function(window, factory) {
+	var lazySizes = factory(window, window.document, Date);
+	window.lazySizes = lazySizes;
+	if(typeof module == 'object' && module.exports){
+		module.exports = lazySizes;
+	}
+}(typeof window != 'undefined' ?
+      window : {}, function l(window, document, Date) { // Pass in the windoe Date function also for SSR because the Date class can be lost
+	'use strict';
+	/*jshint eqnull:true */
+
+	var lazysizes, lazySizesCfg;
+
+	(function(){
+		var prop;
+
+		var lazySizesDefaults = {
+			lazyClass: 'lazyload',
+			loadedClass: 'lazyloaded',
+			loadingClass: 'lazyloading',
+			preloadClass: 'lazypreload',
+			errorClass: 'lazyerror',
+			//strictClass: 'lazystrict',
+			autosizesClass: 'lazyautosizes',
+			srcAttr: 'data-src',
+			srcsetAttr: 'data-srcset',
+			sizesAttr: 'data-sizes',
+			//preloadAfterLoad: false,
+			minSize: 40,
+			customMedia: {},
+			init: true,
+			expFactor: 1.5,
+			hFac: 0.8,
+			loadMode: 2,
+			loadHidden: true,
+			ricTimeout: 0,
+			throttleDelay: 125,
+		};
+
+		lazySizesCfg = window.lazySizesConfig || window.lazysizesConfig || {};
+
+		for(prop in lazySizesDefaults){
+			if(!(prop in lazySizesCfg)){
+				lazySizesCfg[prop] = lazySizesDefaults[prop];
+			}
+		}
+	})();
+
+	if (!document || !document.getElementsByClassName) {
+		return {
+			init: function () {},
+			cfg: lazySizesCfg,
+			noSupport: true,
+		};
+	}
+
+	var docElem = document.documentElement;
+
+	var supportPicture = window.HTMLPictureElement;
+
+	var _addEventListener = 'addEventListener';
+
+	var _getAttribute = 'getAttribute';
+
+	/**
+	 * Update to bind to window because 'this' becomes null during SSR
+	 * builds.
+	 */
+	var addEventListener = window[_addEventListener].bind(window);
+
+	var setTimeout = window.setTimeout;
+
+	var requestAnimationFrame = window.requestAnimationFrame || setTimeout;
+
+	var requestIdleCallback = window.requestIdleCallback;
+
+	var regPicture = /^picture$/i;
+
+	var loadEvents = ['load', 'error', 'lazyincluded', '_lazyloaded'];
+
+	var regClassCache = {};
+
+	var forEach = Array.prototype.forEach;
+
+	var hasClass = function(ele, cls) {
+		if(!regClassCache[cls]){
+			regClassCache[cls] = new RegExp('(\\s|^)'+cls+'(\\s|$)');
+		}
+		return regClassCache[cls].test(ele[_getAttribute]('class') || '') && regClassCache[cls];
+	};
+
+	var addClass = function(ele, cls) {
+		if (!hasClass(ele, cls)){
+			ele.setAttribute('class', (ele[_getAttribute]('class') || '').trim() + ' ' + cls);
+		}
+	};
+
+	var removeClass = function(ele, cls) {
+		var reg;
+		if ((reg = hasClass(ele,cls))) {
+			ele.setAttribute('class', (ele[_getAttribute]('class') || '').replace(reg, ' '));
+		}
+	};
+
+	var addRemoveLoadEvents = function(dom, fn, add){
+		var action = add ? _addEventListener : 'removeEventListener';
+		if(add){
+			addRemoveLoadEvents(dom, fn);
+		}
+		loadEvents.forEach(function(evt){
+			dom[action](evt, fn);
+		});
+	};
+
+	var triggerEvent = function(elem, name, detail, noBubbles, noCancelable){
+		var event = document.createEvent('Event');
+
+		if(!detail){
+			detail = {};
+		}
+
+		detail.instance = lazysizes;
+
+		event.initEvent(name, !noBubbles, !noCancelable);
+
+		event.detail = detail;
+
+		elem.dispatchEvent(event);
+		return event;
+	};
+
+	var updatePolyfill = function (el, full){
+		var polyfill;
+		if( !supportPicture && ( polyfill = (window.picturefill || lazySizesCfg.pf) ) ){
+			if(full && full.src && !el[_getAttribute]('srcset')){
+				el.setAttribute('srcset', full.src);
+			}
+			polyfill({reevaluate: true, elements: [el]});
+		} else if(full && full.src){
+			el.src = full.src;
+		}
+	};
+
+	var getCSS = function (elem, style){
+		return (getComputedStyle(elem, null) || {})[style];
+	};
+
+	var getWidth = function(elem, parent, width){
+		width = width || elem.offsetWidth;
+
+		while(width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth){
+			width =  parent.offsetWidth;
+			parent = parent.parentNode;
+		}
+
+		return width;
+	};
+
+	var rAF = (function(){
+		var running, waiting;
+		var firstFns = [];
+		var secondFns = [];
+		var fns = firstFns;
+
+		var run = function(){
+			var runFns = fns;
+
+			fns = firstFns.length ? secondFns : firstFns;
+
+			running = true;
+			waiting = false;
+
+			while(runFns.length){
+				runFns.shift()();
+			}
+
+			running = false;
+		};
+
+		var rafBatch = function(fn, queue){
+			if(running && !queue){
+				fn.apply(this, arguments);
+			} else {
+				fns.push(fn);
+
+				if(!waiting){
+					waiting = true;
+					(document.hidden ? setTimeout : requestAnimationFrame)(run);
+				}
+			}
+		};
+
+		rafBatch._lsFlush = run;
+
+		return rafBatch;
+	})();
+
+	var rAFIt = function(fn, simple){
+		return simple ?
+			function() {
+				rAF(fn);
+			} :
+			function(){
+				var that = this;
+				var args = arguments;
+				rAF(function(){
+					fn.apply(that, args);
+				});
+			}
+		;
+	};
+
+	var throttle = function(fn){
+		var running;
+		var lastTime = 0;
+		var gDelay = lazySizesCfg.throttleDelay;
+		var rICTimeout = lazySizesCfg.ricTimeout;
+		var run = function(){
+			running = false;
+			lastTime = Date.now();
+			fn();
+		};
+		var idleCallback = requestIdleCallback && rICTimeout > 49 ?
+			function(){
+				requestIdleCallback(run, {timeout: rICTimeout});
+
+				if(rICTimeout !== lazySizesCfg.ricTimeout){
+					rICTimeout = lazySizesCfg.ricTimeout;
+				}
+			} :
+			rAFIt(function(){
+				setTimeout(run);
+			}, true)
+		;
+
+		return function(isPriority){
+			var delay;
+
+			if((isPriority = isPriority === true)){
+				rICTimeout = 33;
+			}
+
+			if(running){
+				return;
+			}
+
+			running =  true;
+
+			delay = gDelay - (Date.now() - lastTime);
+
+			if(delay < 0){
+				delay = 0;
+			}
+
+			if(isPriority || delay < 9){
+				idleCallback();
+			} else {
+				setTimeout(idleCallback, delay);
+			}
+		};
+	};
+
+	//based on http://modernjavascript.blogspot.de/2013/08/building-better-debounce.html
+	var debounce = function(func) {
+		var timeout, timestamp;
+		var wait = 99;
+		var run = function(){
+			timeout = null;
+			func();
+		};
+		var later = function() {
+			var last = Date.now() - timestamp;
+
+			if (last < wait) {
+				setTimeout(later, wait - last);
+			} else {
+				(requestIdleCallback || run)(run);
+			}
+		};
+
+		return function() {
+			timestamp = Date.now();
+
+			if (!timeout) {
+				timeout = setTimeout(later, wait);
+			}
+		};
+	};
+
+	var loader = (function(){
+		var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
+
+		var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden;
+
+		var regImg = /^img$/i;
+		var regIframe = /^iframe$/i;
+
+		var supportScroll = ('onscroll' in window) && !(/(gle|ing)bot/.test(navigator.userAgent));
+
+		var shrinkExpand = 0;
+		var currentExpand = 0;
+
+		var isLoading = 0;
+		var lowRuns = -1;
+
+		var resetPreloading = function(e){
+			isLoading--;
+			if(!e || isLoading < 0 || !e.target){
+				isLoading = 0;
+			}
+		};
+
+		var isVisible = function (elem) {
+			if (isBodyHidden == null) {
+				isBodyHidden = getCSS(document.body, 'visibility') == 'hidden';
+			}
+
+			return isBodyHidden || !(getCSS(elem.parentNode, 'visibility') == 'hidden' && getCSS(elem, 'visibility') == 'hidden');
+		};
+
+		var isNestedVisible = function(elem, elemExpand){
+			var outerRect;
+			var parent = elem;
+			var visible = isVisible(elem);
+
+			eLtop -= elemExpand;
+			eLbottom += elemExpand;
+			eLleft -= elemExpand;
+			eLright += elemExpand;
+
+			while(visible && (parent = parent.offsetParent) && parent != document.body && parent != docElem){
+				visible = ((getCSS(parent, 'opacity') || 1) > 0);
+
+				if(visible && getCSS(parent, 'overflow') != 'visible'){
+					outerRect = parent.getBoundingClientRect();
+					visible = eLright > outerRect.left &&
+						eLleft < outerRect.right &&
+						eLbottom > outerRect.top - 1 &&
+						eLtop < outerRect.bottom + 1
+					;
+				}
+			}
+
+			return visible;
+		};
+
+		var checkElements = function() {
+			var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal,
+				beforeExpandVal, defaultExpand, preloadExpand, hFac;
+			var lazyloadElems = lazysizes.elements;
+
+			if((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)){
+
+				i = 0;
+
+				lowRuns++;
+
+				for(; i < eLlen; i++){
+
+					if(!lazyloadElems[i] || lazyloadElems[i]._lazyRace){continue;}
+
+					if(!supportScroll || (lazysizes.prematureUnveil && lazysizes.prematureUnveil(lazyloadElems[i]))){unveilElement(lazyloadElems[i]);continue;}
+
+					if(!(elemExpandVal = lazyloadElems[i][_getAttribute]('data-expand')) || !(elemExpand = elemExpandVal * 1)){
+						elemExpand = currentExpand;
+					}
+
+					if (!defaultExpand) {
+						defaultExpand = (!lazySizesCfg.expand || lazySizesCfg.expand < 1) ?
+							docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 :
+							lazySizesCfg.expand;
+
+						lazysizes._defEx = defaultExpand;
+
+						preloadExpand = defaultExpand * lazySizesCfg.expFactor;
+						hFac = lazySizesCfg.hFac;
+						isBodyHidden = null;
+
+						if(currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document.hidden){
+							currentExpand = preloadExpand;
+							lowRuns = 0;
+						} else if(loadMode > 1 && lowRuns > 1 && isLoading < 6){
+							currentExpand = defaultExpand;
+						} else {
+							currentExpand = shrinkExpand;
+						}
+					}
+
+					if(beforeExpandVal !== elemExpand){
+						eLvW = innerWidth + (elemExpand * hFac);
+						elvH = innerHeight + elemExpand;
+						elemNegativeExpand = elemExpand * -1;
+						beforeExpandVal = elemExpand;
+					}
+
+					rect = lazyloadElems[i].getBoundingClientRect();
+
+					if ((eLbottom = rect.bottom) >= elemNegativeExpand &&
+						(eLtop = rect.top) <= elvH &&
+						(eLright = rect.right) >= elemNegativeExpand * hFac &&
+						(eLleft = rect.left) <= eLvW &&
+						(eLbottom || eLright || eLleft || eLtop) &&
+						(lazySizesCfg.loadHidden || isVisible(lazyloadElems[i])) &&
+						((isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4)) || isNestedVisible(lazyloadElems[i], elemExpand))){
+						unveilElement(lazyloadElems[i]);
+						loadedSomething = true;
+						if(isLoading > 9){break;}
+					} else if(!loadedSomething && isCompleted && !autoLoadElem &&
+						isLoading < 4 && lowRuns < 4 && loadMode > 2 &&
+						(preloadElems[0] || lazySizesCfg.preloadAfterLoad) &&
+						(preloadElems[0] || (!elemExpandVal && ((eLbottom || eLright || eLleft || eLtop) || lazyloadElems[i][_getAttribute](lazySizesCfg.sizesAttr) != 'auto')))){
+						autoLoadElem = preloadElems[0] || lazyloadElems[i];
+					}
+				}
+
+				if(autoLoadElem && !loadedSomething){
+					unveilElement(autoLoadElem);
+				}
+			}
+		};
+
+		var throttledCheckElements = throttle(checkElements);
+
+		var switchLoadingClass = function(e){
+			var elem = e.target;
+
+			if (elem._lazyCache) {
+				delete elem._lazyCache;
+				return;
+			}
+
+			resetPreloading(e);
+			addClass(elem, lazySizesCfg.loadedClass);
+			removeClass(elem, lazySizesCfg.loadingClass);
+			addRemoveLoadEvents(elem, rafSwitchLoadingClass);
+			triggerEvent(elem, 'lazyloaded');
+		};
+		var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
+		var rafSwitchLoadingClass = function(e){
+			rafedSwitchLoadingClass({target: e.target});
+		};
+
+		var changeIframeSrc = function(elem, src){
+			try {
+				elem.contentWindow.location.replace(src);
+			} catch(e){
+				elem.src = src;
+			}
+		};
+
+		var handleSources = function(source){
+			var customMedia;
+
+			var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr);
+
+			if( (customMedia = lazySizesCfg.customMedia[source[_getAttribute]('data-media') || source[_getAttribute]('media')]) ){
+				source.setAttribute('media', customMedia);
+			}
+
+			if(sourceSrcset){
+				source.setAttribute('srcset', sourceSrcset);
+			}
+		};
+
+		var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg){
+			var src, srcset, parent, isPicture, event, firesLoad;
+
+			if(!(event = triggerEvent(elem, 'lazybeforeunveil', detail)).defaultPrevented){
+
+				if(sizes){
+					if(isAuto){
+						addClass(elem, lazySizesCfg.autosizesClass);
+					} else {
+						elem.setAttribute('sizes', sizes);
+					}
+				}
+
+				srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr);
+				src = elem[_getAttribute](lazySizesCfg.srcAttr);
+
+				if(isImg) {
+					parent = elem.parentNode;
+					isPicture = parent && regPicture.test(parent.nodeName || '');
+				}
+
+				firesLoad = detail.firesLoad || (('src' in elem) && (srcset || src || isPicture));
+
+				event = {target: elem};
+
+				addClass(elem, lazySizesCfg.loadingClass);
+
+				if(firesLoad){
+					clearTimeout(resetPreloadingTimer);
+					resetPreloadingTimer = setTimeout(resetPreloading, 2500);
+					addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
+				}
+
+				if(isPicture){
+					forEach.call(parent.getElementsByTagName('source'), handleSources);
+				}
+
+				if(srcset){
+					elem.setAttribute('srcset', srcset);
+				} else if(src && !isPicture){
+					if(regIframe.test(elem.nodeName)){
+						changeIframeSrc(elem, src);
+					} else {
+						elem.src = src;
+					}
+				}
+
+				if(isImg && (srcset || isPicture)){
+					updatePolyfill(elem, {src: src});
+				}
+			}
+
+			if(elem._lazyRace){
+				delete elem._lazyRace;
+			}
+			removeClass(elem, lazySizesCfg.lazyClass);
+
+			rAF(function(){
+				// Part of this can be removed as soon as this fix is older: https://bugs.chromium.org/p/chromium/issues/detail?id=7731 (2015)
+				var isLoaded = elem.complete && elem.naturalWidth > 1;
+
+				if( !firesLoad || isLoaded){
+					if (isLoaded) {
+						addClass(elem, 'ls-is-cached');
+					}
+					switchLoadingClass(event);
+					elem._lazyCache = true;
+					setTimeout(function(){
+						if ('_lazyCache' in elem) {
+							delete elem._lazyCache;
+						}
+					}, 9);
+				}
+				if (elem.loading == 'lazy') {
+					isLoading--;
+				}
+			}, true);
+		});
+
+		var unveilElement = function (elem){
+			if (elem._lazyRace) {return;}
+			var detail;
+
+			var isImg = regImg.test(elem.nodeName);
+
+			//allow using sizes="auto", but don't use. it's invalid. Use data-sizes="auto" or a valid value for sizes instead (i.e.: sizes="80vw")
+			var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]('sizes'));
+			var isAuto = sizes == 'auto';
+
+			if( (isAuto || !isCompleted) && isImg && (elem[_getAttribute]('src') || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)){return;}
+
+			detail = triggerEvent(elem, 'lazyunveilread').detail;
+
+			if(isAuto){
+				 autoSizer.updateElem(elem, true, elem.offsetWidth);
+			}
+
+			elem._lazyRace = true;
+			isLoading++;
+
+			lazyUnveil(elem, detail, isAuto, sizes, isImg);
+		};
+
+		var afterScroll = debounce(function(){
+			lazySizesCfg.loadMode = 3;
+			throttledCheckElements();
+		});
+
+		var altLoadmodeScrollListner = function(){
+			if(lazySizesCfg.loadMode == 3){
+				lazySizesCfg.loadMode = 2;
+			}
+			afterScroll();
+		};
+
+		var onload = function(){
+			if(isCompleted){return;}
+			if(Date.now() - started < 999){
+				setTimeout(onload, 999);
+				return;
+			}
+
+
+			isCompleted = true;
+
+			lazySizesCfg.loadMode = 3;
+
+			throttledCheckElements();
+
+			addEventListener('scroll', altLoadmodeScrollListner, true);
+		};
+
+		return {
+			_: function(){
+				started = Date.now();
+
+				lazysizes.elements = document.getElementsByClassName(lazySizesCfg.lazyClass);
+				preloadElems = document.getElementsByClassName(lazySizesCfg.lazyClass + ' ' + lazySizesCfg.preloadClass);
+
+				addEventListener('scroll', throttledCheckElements, true);
+
+				addEventListener('resize', throttledCheckElements, true);
+
+				addEventListener('pageshow', function (e) {
+					if (e.persisted) {
+						var loadingElements = document.querySelectorAll('.' + lazySizesCfg.loadingClass);
+
+						if (loadingElements.length && loadingElements.forEach) {
+							requestAnimationFrame(function () {
+								loadingElements.forEach( function (img) {
+									if (img.complete) {
+										unveilElement(img);
+									}
+								});
+							});
+						}
+					}
+				});
+
+				if(window.MutationObserver){
+					new MutationObserver( throttledCheckElements ).observe( docElem, {childList: true, subtree: true, attributes: true} );
+				} else {
+					docElem[_addEventListener]('DOMNodeInserted', throttledCheckElements, true);
+					docElem[_addEventListener]('DOMAttrModified', throttledCheckElements, true);
+					setInterval(throttledCheckElements, 999);
+				}
+
+				addEventListener('hashchange', throttledCheckElements, true);
+
+				//, 'fullscreenchange'
+				['focus', 'mouseover', 'click', 'load', 'transitionend', 'animationend'].forEach(function(name){
+					document[_addEventListener](name, throttledCheckElements, true);
+				});
+
+				if((/d$|^c/.test(document.readyState))){
+					onload();
+				} else {
+					addEventListener('load', onload);
+					document[_addEventListener]('DOMContentLoaded', throttledCheckElements);
+					setTimeout(onload, 20000);
+				}
+
+				if(lazysizes.elements.length){
+					checkElements();
+					rAF._lsFlush();
+				} else {
+					throttledCheckElements();
+				}
+			},
+			checkElems: throttledCheckElements,
+			unveil: unveilElement,
+			_aLSL: altLoadmodeScrollListner,
+		};
+	})();
+
+
+	var autoSizer = (function(){
+		var autosizesElems;
+
+		var sizeElement = rAFIt(function(elem, parent, event, width){
+			var sources, i, len;
+			elem._lazysizesWidth = width;
+			width += 'px';
+
+			elem.setAttribute('sizes', width);
+
+			if(regPicture.test(parent.nodeName || '')){
+				sources = parent.getElementsByTagName('source');
+				for(i = 0, len = sources.length; i < len; i++){
+					sources[i].setAttribute('sizes', width);
+				}
+			}
+
+			if(!event.detail.dataAttr){
+				updatePolyfill(elem, event.detail);
+			}
+		});
+		var getSizeElement = function (elem, dataAttr, width){
+			var event;
+			var parent = elem.parentNode;
+
+			if(parent){
+				width = getWidth(elem, parent, width);
+				event = triggerEvent(elem, 'lazybeforesizes', {width: width, dataAttr: !!dataAttr});
+
+				if(!event.defaultPrevented){
+					width = event.detail.width;
+
+					if(width && width !== elem._lazysizesWidth){
+						sizeElement(elem, parent, event, width);
+					}
+				}
+			}
+		};
+
+		var updateElementsSizes = function(){
+			var i;
+			var len = autosizesElems.length;
+			if(len){
+				i = 0;
+
+				for(; i < len; i++){
+					getSizeElement(autosizesElems[i]);
+				}
+			}
+		};
+
+		var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
+
+		return {
+			_: function(){
+				autosizesElems = document.getElementsByClassName(lazySizesCfg.autosizesClass);
+				addEventListener('resize', debouncedUpdateElementsSizes);
+			},
+			checkElems: debouncedUpdateElementsSizes,
+			updateElem: getSizeElement
+		};
+	})();
+
+	var init = function(){
+		if(!init.i && document.getElementsByClassName){
+			init.i = true;
+			autoSizer._();
+			loader._();
+		}
+	};
+
+	setTimeout(function(){
+		if(lazySizesCfg.init){
+			init();
+		}
+	});
+
+	lazysizes = {
+		cfg: lazySizesCfg,
+		autoSizer: autoSizer,
+		loader: loader,
+		init: init,
+		uP: updatePolyfill,
+		aC: addClass,
+		rC: removeClass,
+		hC: hasClass,
+		fire: triggerEvent,
+		gW: getWidth,
+		rAF: rAF,
+	};
+
+	return lazysizes;
+}
+));