https://congresoneurologia.com.ar/js/theme.js

1// Theme
2(function( $ ) {
3
4	'use strict';
5
6	window.theme = {};
7
8	// Theme Common Functions
9	window.theme.fn = {
10
11		getOptions: function(opts) {
12
13			if (typeof(opts) == 'object') {
14
15				return opts;
16
17			} else if (typeof(opts) == 'string') {
18
19				try {
20					return JSON.parse(opts.replace(/'/g,'"').replace(';',''));
21				} catch(e) {
22					return {};
23				}
24
25			} else {
26
27				return {};
28
29			}
30
31		},
32
33		getOptionsSemicolon: function(opts) {
34
35			if (typeof(opts) == 'object') {
36
37				return opts;
38
39			} else if (typeof(opts) == 'string') {
40
41				try {
42					return JSON.parse(opts.replace(/'/g,'"'));
43				} catch(e) {
44					return {};
45				}
46
47			} else {
48
49				return {};
50
51			}
52
53		}
54
55	};
56
57}).apply( this, [ jQuery ]);
58
59// Animate
60(function(theme, $) {
61
62	'use strict';
63
64	theme = theme || {};
65
66	var instanceName = '__animate';
67
68	var PluginAnimate = function($el, opts) {
69		return this.initialize($el, opts);
70	};
71
72	PluginAnimate.defaults = {
73		accX: 0,
74		accY: -80,
75		delay: 100,
76		duration: '750ms'
77	};
78
79	PluginAnimate.prototype = {
80		initialize: function($el, opts) {
81			if ($el.data(instanceName)) {
82				return this;
83			}
84
85			this.$el = $el;
86
87			this
88				.setData()
89				.setOptions(opts)
90				.build();
91
92			return this;
93		},
94
95		setData: function() {
96			this.$el.data(instanceName, this);
97
98			return this;
99		},
100
101		setOptions: function(opts) {
102			this.options = $.extend(true, {}, PluginAnimate.defaults, opts, {
103				wrapper: this.$el
104			});
105
106			return this;
107		},
108
109		build: function() {
110			var self = this,
111				$el = this.options.wrapper,
112				delay = 0,
113				duration = this.options.duration,
114				elTopDistance = $el.offset().top + 100,
115				windowTopDistance = $(window).scrollTop();
116
117			$el.addClass('appear-animation animated');
118
119			if (!$('html').hasClass('no-csstransitions') && $(window).width() > 767 && elTopDistance >= windowTopDistance) {
120
121				$el.appear(function() {
122
123					$el.one('animation:show', function(ev) {
124						delay = ($el.attr('data-appear-animation-delay') ? $el.attr('data-appear-animation-delay') : self.options.delay);
125						duration = ($el.attr('data-appear-animation-duration') ? $el.attr('data-appear-animation-duration') : self.options.duration);
126
127						if (duration != '750ms') {
128							$el.css('animation-duration', duration);
129						}
130
131						$el.css('animation-delay', delay + 'ms');
132
133						$el.addClass($el.attr('data-appear-animation') + ' appear-animation-visible');
134					});
135
136					$el.trigger('animation:show');
137
138				}, {
139					accX: self.options.accX,
140					accY: self.options.accY
141				});
142
143			} else {
144
145				$el.addClass('appear-animation-visible');
146
147			}
148
149			return this;
150		}
151	};
152
153	// expose to scope
154	$.extend(theme, {
155		PluginAnimate: PluginAnimate
156	});
157
158	// jquery plugin
159	$.fn.themePluginAnimate = function(opts) {
160		return this.map(function() {
161			var $this = $(this);
162
163			if ($this.data(instanceName)) {
164				return $this.data(instanceName);
165			} else {
166				return new PluginAnimate($this, opts);
167			}
168
169		});
170	};
171
172}).apply(this, [window.theme, jQuery]);
173
174// Carousel
175(function(theme, $) {
176
177	'use strict';
178
179	theme = theme || {};
180
181	var instanceName = '__carousel';
182
183	var PluginCarousel = function($el, opts) {
184		return this.initialize($el, opts);
185	};
186
187	PluginCarousel.defaults = {
188		loop: true,
189		responsive: {
190			0: {
191				items: 1
192			},
193			575: {
194				items: 1
195			},
196			767: {
197				items: 2
198			},
199			991: {
200				items: 3
201			},
202			1199: {
203				items: 4
204			}
205		},
206		navText: [],
207		clonePrevNext: false,
208		vertical: false,
209		rewind: false
210	};
211
212	PluginCarousel.prototype = {
213		initialize: function($el, opts) {
214			if ($el.data(instanceName)) {
215				return this;
216			}
217
218			this.$el = $el;
219
220			this
221				.setData()
222				.setOptions(opts)
223				.build();
224
225			return this;
226		},
227
228		setData: function() {
229			this.$el.data(instanceName, this);
230
231			return this;
232		},
233
234		setOptions: function(opts) {
235			this.options = $.extend(true, {}, PluginCarousel.defaults, opts, {
236				wrapper: this.$el
237			});
238
239			return this;
240		},
241
242		build: function() {
243			if (!($.isFunction($.fn.owlCarousel))) {
244				return this;
245			}
246
247			var self = this,
248				$el = this.options.wrapper;
249
250			// Add Theme Class
251			$el.addClass('owl-theme');
252
253			// Force RTL according to HTML dir attribute
254			if ($('html').attr('dir') == 'rtl') {
255				this.options = $.extend(true, {}, this.options, {
256					rtl: true
257				});
258			}
259
260			if (this.options.items == 1) {
261				this.options.responsive = {}
262			}
263
264			// Auto Height Fixes
265			if (this.options.autoHeight) {
266				var itemsHeight = [];
267
268				$el.find('.owl-item').each(function(){
269					if( $(this).hasClass('active') ) {
270						itemsHeight.push( $(this).height() );
271					}
272				});
273
274				$(window).afterResize(function() {
275					$el.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
276				});
277
278				$(window).on('load', function() {
279					$el.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
280				});
281			}
282
283			// Initialize OwlCarousel

284			$el.owlCarousel(this.options).addClass('owl-carousel-init');
285
286			// Carousel Corner Left Bottom Style
287			if( $('.carousel-corner-left-bottom').get(0) ) {
288				$('.carousel-corner-left-bottom').on('drag.owl.carousel change.owl.carousel', function(e){
289					$(this).find('.owl-item').addClass('changing');
290				});
291
292				$('.carousel-corner-left-bottom').on('changed.owl.carousel', function(e){
293					setTimeout(function(){
294						$('.carousel-corner-left-bottom').find('.owl-item').removeClass('changing');
295					}, 500);
296				});
297			}
298
299			// Carousel Center Active Items Style
300			if( $el.hasClass('carousel-center-active-items') ) {
301				var itemsActive    = $el.find('.owl-item.active'),
302					indexCenter    = Math.floor( ($el.find('.owl-item.active').length - 1) / 2 ),
303					itemCenter     = itemsActive.eq(indexCenter),
304					itemCenterPrev = itemCenter.prev(),
305					itemCenterNext = itemCenter.next();
306
307				itemCenter.addClass('current');
308				itemCenterPrev.addClass('remove-blur');
309				itemCenterNext.addClass('remove-blur');
310
311				$el.on('change.owl.carousel', function(event) {
312				  	$el.find('.owl-item').removeClass('current');
313					
314					setTimeout(function(){
315					  	var itemsActive    = $el.find('.owl-item.active'),

316					  		itemCenter     = itemsActive.eq(indexCenter);
317
318					  	itemCenter.addClass('current');
319
320						// Add blur effect for first and last active items
321					  	itemsActive.first().removeClass('remove-blur');
322						itemsActive.last().removeClass('remove-blur');
323
324					  	// Remove blur effect for elements at right and left of current item
325					  	itemCenter.prev().addClass('remove-blur');
326						itemCenter.next().addClass('remove-blur');
327
328					}, 100);
329				});
330
331				$el.on('resized.owl.carousel', function(event) {
332					if( $el.find('.owl-item.active').length == 1 ) {
333						$el
334							.css({
335								width: '100%'
336							})
337							.addClass('rm-degrade-now');
338					} else {
339						$el
340							.css({
341								width: ''
342							})
343							.removeClass('rm-degrade-now');
344					}
345
346					$el.trigger('refresh.owl.carousel');
347				});
348
349				// Refresh
350				$el.trigger('refresh.owl.carousel');
351			}
352
353			// Clone Prev Next
354			if (this.options.clonePrevNext) {
355				$el.find('.owl-item').each(function() {
356					$(this).prev().find('div:not(.clone-inside)').clone().addClass('clone-inside prev').prependTo($(this));
357					$(this).next().find('div:not(.clone-inside)').clone().addClass('clone-inside next').appendTo($(this));
358				});
359
360				$el.on('change.owl.carousel', function(){
361					$el.find('.owl-item.active div:not(.prev)').css('opacity', 0);
362				});
363
364				$el.on('changed.owl.carousel', function(){
365					$el.find('.owl-item').one('animationend', function(){
366						$el.find('.owl-item div:not(.prev)').css('opacity', 1);
367						$el.find('.owl-item.cloned div:not(.prev)').css('opacity', 0);
368						$el.find('.owl-item.active div:not(.prev)').css('opacity', 1);
369					});
370						
371				});
372
373				$el.on('drag.owl.carousel', function(){
374					$el.find('.owl-item div:not(.prev)').css('opacity', 1);
375				});
376			}
377
378			return this;
379		}
380	};
381
382	// expose to scope
383	$.extend(theme, {
384		PluginCarousel: PluginCarousel
385	});
386
387	// jquery plugin
388	$.fn.themePluginCarousel = function(opts) {
389		return this.map(function() {
390			var $this = $(this);
391
392			if ($this.data(instanceName)) {
393				return $this.data(instanceName);
394			} else {
395				return new PluginCarousel($this, opts);
396			}
397
398		});
399	}
400
401}).apply(this, [window.theme, jQuery]);
402
403// Chart Circular
404(function(theme, $) {
405
406	'use strict';
407
408	theme = theme || {};
409
410	var instanceName = '__chartCircular';
411
412	var PluginChartCircular = function($el, opts) {
413		return this.initialize($el, opts);
414	};
415
416	PluginChartCircular.defaults = {
417		accX: 0,
418		accY: -150,
419		delay: 1,
420		barColor: '#2388ed',
421		trackColor: '#F1F3F7',
422		scaleColor: false,
423		scaleLength: 5,
424		lineCap: 'square',
425		lineWidth: 3,
426		size: 150,
427		rotate: 0,
428		animate: ({
429			duration: 2500,
430			enabled: true
431		})
432	};
433
434	PluginChartCircular.prototype = {
435		initialize: function($el, opts) {
436			if ($el.data(instanceName)) {
437				return this;
438			}
439
440			this.$el = $el;
441
442			this
443				.setData()
444				.setOptions(opts)
445				.build();
446
447			return this;
448		},
449
450		setData: function() {
451			this.$el.data(instanceName, this);
452
453			return this;
454		},
455
456		setOptions: function(opts) {
457			this.options = $.extend(true, {}, PluginChartCircular.defaults, opts, {
458				wrapper: this.$el
459			});
460
461			return this;
462		},
463
464		build: function() {
465			if (!($.isFunction($.fn.appear)) || !($.isFunction($.fn.easyPieChart))) {
466				return this;
467			}
468
469			var self = this,
470				$el = this.options.wrapper,
471				value = ($el.attr('data-percent') ? $el.attr('data-percent') : 0),
472				percentEl = $el.find('.percent');
473
474			$.extend(true, self.options, {
475				onStep: function(from, to, currentValue) {
476					percentEl.html(parseInt(currentValue));
477				}
478			});
479
480			$el.attr('data-percent', 0);
481
482			$el.appear(function() {
483
484				$el.easyPieChart(self.options);
485
486				setTimeout(function() {
487
488					$el.data('easyPieChart').update(value);
489					$el.attr('data-percent', value);
490
491				}, self.options.delay);
492
493			}, {
494				accX: self.options.accX,
495				accY: self.options.accY
496			});
497
498			return this;
499		}
500	};
501
502	// expose to scope
503	$.extend(theme, {
504		PluginChartCircular: PluginChartCircular
505	});
506
507	// jquery plugin
508	$.fn.themePluginChartCircular = function(opts) {
509		return this.map(function() {
510			var $this = $(this);
511
512			if ($this.data(instanceName)) {
513				return $this.data(instanceName);
514			} else {
515				return new PluginChartCircular($this, opts);
516			}
517
518		});
519	}
520
521}).apply(this, [window.theme, jQuery]);
522
523// Counter
524(function(theme, $) {
525
526	'use strict';
527
528	theme = theme || {};
529
530	var instanceName = '__counter';
531
532	var PluginCounter = function($el, opts) {
533		return this.initialize($el, opts);
534	};
535
536	PluginCounter.defaults = {
537		accX: 0,
538		accY: 0,
539		speed: 3000,
540		refreshInterval: 100,
541		decimals: 0,
542		onUpdate: null,
543		onComplete: null
544	};
545
546	PluginCounter.prototype = {
547		initialize: function($el, opts) {
548			if ($el.data(instanceName)) {
549				return this;
550			}
551
552			this.$el = $el;
553
554			this
555				.setData()
556				.setOptions(opts)
557				.build();
558
559			return this;
560		},
561
562		setData: function() {
563			this.$el.data(instanceName, this);
564
565			return this;
566		},
567
568		setOptions: function(opts) {
569			this.options = $.extend(true, {}, PluginCounter.defaults, opts, {
570				wrapper: this.$el
571			});
572
573			return this;
574		},
575
576		build: function() {
577			if (!($.isFunction($.fn.countTo))) {
578				return this;
579			}
580
581			var self = this,
582				$el = this.options.wrapper;
583
584			$.extend(self.options, {
585				onComplete: function() {
586					if ($el.data('append')) {
587						$el.html($el.html() + $el.data('append'));
588					}
589
590					if ($el.data('prepend')) {
591						$el.html($el.data('prepend') + $el.html());
592					}
593				}
594			});
595

596			$el.appear(function() {
597
598				$el.countTo(self.options);
599
600			}, {
601				accX: self.options.accX,
602				accY: self.options.accY
603			});
604
605			return this;
606		}
607	};
608
609	// expose to scope
610	$.extend(theme, {
611		PluginCounter: PluginCounter
612	});
613
614	// jquery plugin
615	$.fn.themePluginCounter = function(opts) {
616		return this.map(function() {
617			var $this = $(this);
618
619			if ($this.data(instanceName)) {
620				return $this.data(instanceName);
621			} else {
622				return new PluginCounter($this, opts);
623			}
624
625		});
626	}
627
628}).apply(this, [window.theme, jQuery]);
629
630// Double Carousel
631(function(theme, $) {
632
633	'use strict';
634
635	theme = theme || {};
636
637	var instanceName = '__doubleCarousel';
638
639	var PluginDoubleCarousel = function($el, opts) {
640		return this.initialize($el, opts);
641	};
642
643	PluginDoubleCarousel.defaults = {
644		loop: true,
645		responsive: {
646			0: {
647				items: 1
648			},
649			479: {
650				items: 1
651			},
652			768: {
653				items: 1
654			},
655			979: {
656				items: 2
657			},
658			1199: {
659				items: 3
660			}
661		},
662		margin: 20,
663		mouseDrag: false,
664		navText: [],
665		autoplay: true,
666		autoplayTimeout: 5000,
667		rewind: false
668	};
669
670	PluginDoubleCarousel.prototype = {
671		initialize: function($el, opts) {
672			if ($el.data(instanceName)) {
673				return this;
674			}
675
676			this.$el = $el;
677			this.$carousels = $el.find('.owl-carousel');
678			this.$mainCarousel = $el.find('.wrapper-right .owl-carousel');
679			this.$mirrorCarousel = $el.find('.wrapper-left .owl-carousel');
680
681			this
682				.setData()
683				.setOptions(opts)
684				.build()
685				.navigation();
686
687			return this;
688		},
689
690		setData: function() {
691			this.$el.data(instanceName, this);
692
693			return this;
694		},
695
696		setOptions: function(opts) {
697			this.options = $.extend(true, {}, PluginDoubleCarousel.defaults, opts, {
698				wrapper: this.$el
699			});
700
701			return this;
702		},
703
704		build: function() {
705			if (!($.isFunction($.fn.owlCarousel))) {
706				return this;
707			}
708
709			var self 	  = this,
710				$el 	  = this.options.wrapper,
711				firstLoad = true;
712
713			// Add Theme Class
714			self.$carousels.addClass('owl-theme');
715
716			if (this.options.items == 1) {
717				this.options.responsive = {}
718			}
719
720			// Auto Height Fixes
721			if (this.options.autoHeight) {
722				var itemsHeight = [];
723
724				self.$carousels.find('.owl-item').each(function(){
725					if( $(this).hasClass('active') ) {
726						itemsHeight.push( $(this).height() );
727					}
728				});
729
730				$(window).afterResize(function() {
731					self.$carousels.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
732				});
733
734				$(window).on('load', function() {
735					self.$carousels.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
736				});
737			}
738
739			// If Mobile
740			if ($.browser.mobile) {
741				this.options = $.extend(true, {}, this.options, {
742					mouseDrag: true,
743					margin: 0
744				});
745			}
746
747			// Initialize Main Carousel
748			self.$mainCarousel.owlCarousel(this.options).addClass('owl-carousel-init mirrored');
749
750			// Remove autoplay from Mirror Carousel
751			if( this.options.autoplay ) {
752				this.options = $.extend(true, {}, this.options, {
753					autoplay: false
754				});
755			}
756
757			// Initialize Mirror Carousel
758			self.$mirrorCarousel.owlCarousel(this.options).addClass('owl-carousel-init mirrored');			
759
760			// Set the first item position of Mirror Carousel
761			for( var i=1; i <= self.$mirrorCarousel.find('.owl-item.active').length - 1; i++ ) {
762				self.$mirrorCarousel.trigger('prev.owl.carousel');
763			}
764			
765			self.events();
766			self.recalcCarouselsWidth();
767
768			if( firstLoad == true ) {
769				firstLoad = false;
770				self.recalcCarouselsWidth();
771
772				setTimeout(function(){
773	        		self.$mirrorCarousel.addClass('show-carousel');
774	        		self.$mainCarousel.addClass('show-carousel');
775
776	        		self.refreshOnResize();
777        		}, 500);
778    		}
779
780    		if( firstLoad == false ) {
781    			self.setCurrentItem();
782    		}
783
784			return this;
785		},
786
787		setCurrentItem: function() {
788			var self = this,
789				flag = false;
790
791			self.$mainCarousel.on('change.owl.carousel', function(event) {
792			  	if (event.namespace && event.property.name === 'position' && flag == false) {
793				    var target = event.relatedTarget.relative(event.property.value, true);
794				    flag = true;
795
796				    self.$mirrorCarousel.owlCarousel('to', target - (self.$mirrorCarousel.find('.owl-item.active').length - 1), 300, true);
797				    self.$mirrorCarousel.find('.owl-item').removeClass('current');
798			        self.$mainCarousel.find('.owl-item').removeClass('current');
799			        
800			        setTimeout(function(){
801			        	self.$mirrorCarousel.find('.owl-item.active').eq( self.$mirrorCarousel.find('.owl-item.active').length - 1 ).addClass('current');
802			        	self.$mainCarousel.find('.owl-item.active').eq(0).addClass('current');
803			        }, 10);
804
805			        flag = false;

806			  	}
807			});
808
809			if( $.browser.mobile ) {
810				self.$mirrorCarousel.on('change.owl.carousel', function(event) {
811				  	if (event.namespace && event.property.name === 'position' && flag == false) {
812					    var target = event.relatedTarget.relative(event.property.value, true);
813					    flag = true;
814
815					    self.$mainCarousel.owlCarousel('to', target - (self.$mainCarousel.find('.owl-item.active').length - 1), 300, true);
816					    self.$mainCarousel.find('.owl-item').removeClass('current');
817				        self.$mirrorCarousel.find('.owl-item').removeClass('current');
818				        
819				        setTimeout(function(){
820				        	self.$mainCarousel.find('.owl-item.active').eq( self.$mainCarousel.find('.owl-item.active').length - 1 ).addClass('current');
821				        	self.$mirrorCarousel.find('.owl-item.active').eq(0).addClass('current');
822				        }, 10);
823
824				     	flag = false;
825				  	}
826				});
827			}
828		},
829		
830		recalcCarouselsWidth: function() {
831			var self 		     = this,
832				$el 		     = this.options.wrapper,
833				itemSize         = self.$mirrorCarousel.find('.owl-item').outerWidth(true),
834				dividedItemSize  = itemSize / 2,
835				totalActiveItems = self.$mirrorCarousel.find('.owl-item.active').length;
836
837			if( totalActiveItems > 1 ) {
838				
839				self.$mirrorCarousel.width( $el.find('.wrapper-left').width() + divi

839dedItemSize );
840				setTimeout(function(){
841					self.$mirrorCarousel.css({
842						right: dividedItemSize
843					});
844				}, 500);
845				
846				self.$mainCarousel.width( $el.find('.wrapper-right').width() + dividedItemSize );
847
848			} else {
849				
850				self.$mirrorCarousel.width( $el.find('.wrapper-left').width() );
851				setTimeout(function(){
852					self.$mirrorCarousel.css({
853						right: 0
854					});
855				}, 500);
856				
857				self.$mainCarousel.width( $el.find('.wrapper-right').width() );
858
859			}
860
861			$(document).trigger('double.carousel.recalc.width');
862		},
863
864		refreshOnResize: function() {
865			var self = this;
866
867			$(document).ready(function(){
868				$(window).afterResize(function(){
869					
870					// First - Refresh both carousels to set new sizes
871					self.$mirrorCarousel.trigger('refresh.owl.carousel');
872					self.$mainCarousel.trigger('refresh.owl.carousel');
873
874					// Second - Recalc Carousels width based on new sizes
875					setTimeout(function(){
876						self.recalcCarouselsWidth();
877					}, 600);
878
879				}, false, 300);
880			});
881		},
882
883		navigation: function() {
884			var self       = this,
885				$el        = this.options.wrapper,
886				$leftArrow  = $el.find('.arrow-left'),
887				$rightArrow = $el.find('.arrow-right');
888
889			$leftArrow.on('click', function(e){
890				self.$mainCarousel.trigger('prev.owl.carousel');
891			});
892
893			$rightArrow.on('click', function(e){
894				self.$mainCarousel.trigger('next.owl.carousel');
895			});
896		},
897
898		events: function() {
899			var self = this;
900
901			$(window).on('double.carousel.recalc.width', function(e){
902					
903				// Refresh carousels to set new sizes
904				self.$mirrorCarousel.trigger('refresh.owl.carousel');
905				self.$mainCarousel.trigger('refresh.owl.carousel');
906				
907				// Set current item
908				self.$mirrorCarousel.find('.owl-item.active').eq( self.$mirrorCarousel.find('.owl-item.active').length - 1 ).addClass('current');
909	        	self.$mainCarousel.find('.owl-item.active').eq(0).addClass('current');
910
911				// Position the first item
912				self.$mainCarousel.trigger('prev.owl.carousel').trigger('next.owl.carousel');
913        		
914			});
915		}
916	};
917
918	// expose to scope
919	$.extend(theme, {
920		PluginDoubleCarousel: PluginDoubleCarousel
921	});
922
923	// jquery plugin
924	$.fn.themePluginDoubleCarousel = function(opts) {
925		return this.map(function() {
926			var $this = $(this);
927
928			if ($this.data(instanceName)) {
929				return $this.data(instanceName);
930			} else {
931				return new PluginDoubleCarousel($this, opts);
932			}
933
934		});
935	}
936
937}).apply(this, [window.theme, jQuery]);
938
939// Float Element
940(function(theme, $) {
941
942	'use strict';
943
944	theme = theme || {};
945
946	var instanceName = '__floatElement';
947
948	var PluginFloatElement = function($el, opts) {
949		return this.initialize($el, opts);
950	};
951
952	PluginFloatElement.defaults = {
953		startPos: 'top',
954		speed: 3,
955		horizontal: false,
956		transition: false
957	};
958
959	PluginFloatElement.prototype = {
960		initialize: function($el, opts) {
961			if ($el.data(instanceName)) {
962				return this;
963			}
964
965			this.$el = $el;
966
967			this
968				.setData()
969				.setOptions(opts)
970				.build();
971
972			return this;
973		},
974
975		setData: function() {
976			this.$el.data(instanceName, this);
977
978			return this;
979		},
980
981		setOptions: function(opts) {
982			this.options = $.extend(true, {}, PluginFloatElement.defaults, opts, {
983				wrapper: this.$el
984			});
985
986			return this;
987		},
988
989		build: function() {
990			var self = this,
991				$el = this.options.wrapper,
992				$window = $(window),
993				minus;
994
995			if( self.options.style ) {
996				console.log(self.options.style);
997				$el.attr('style', self.options.style);
998			}
999
1000			if( $window.width() > 767 ) {
1001
1002				// Set Start Position
1003				if( self.options.startPos == 'none' ) {
1004					minus = '';
1005				} else if( self.options.startPos == 'top' ) {
1006					$el.css({
1007						top: 0
1008					});
1009					minus = '';
1010				} else {
1011					$el.css({
1012						bottom: 0
1013					});
1014					minus = '-';
1015				}
1016
1017				// Set Transition
1018				if( self.options.transition ) {
1019					$el.css({
1020						transition: 'ease transform 500ms'
1021					});
1022				}
1023
1024				// First Load
1025				self.movement(minus);	
1026
1027				// Scroll
1028				$window.on('scroll', function(){
1029					self.movement(minus);				   
1030				});
1031
1032			}
1033
1034			return this;
1035		},
1036
1037		movement: function(minus) {
1038			var self = this,
1039				$el = this.options.wrapper,
1040				$window = $(window),
1041				scrollTop = $window.scrollTop(),
1042		    	elementOffset = $el.offset().top,
1043		     	currentElementOffset = (elementOffset - scrollTop);
1044
1045		   	var scrollPercent = 100 * currentElementOffset / ($window.height());
1046
1047		   	if( $el.visible( true ) ) {
1048
1049		   		if( !self.options.horizontal ) {
1050
1051		   			$el.css({
1052			   			transform: 'translate3d(0, '+ minus + scrollPercent / self.options.speed +'%, 0)'
1053			   		});
1054
1055		   		} else {
1056
1057		   			$el.css({

1058			   			transform: 'translate3d('+ minus + scrollPercent / self.options.speed +'%, '+ minus + scrollPercent / self.options.speed +'%, 0)'
1059			   		});
1060
1061		   		}
1062		   		
1063		   	}
1064		}
1065	};
1066
1067	// expose to scope
1068	$.extend(theme, {
1069		PluginFloatElement: PluginFloatElement
1070	});
1071
1072	// jquery plugin
1073	$.fn.themePluginFloatElement = function(opts) {
1074		return this.map(function() {
1075			var $this = $(this);
1076
1077			if ($this.data(instanceName)) {
1078				return $this.data(instanceName);
1079			} else {
1080				return new PluginFloatElement($this, opts);
1081			}
1082
1083		});
1084	}
1085
1086}).apply(this, [window.theme, jQuery]);
1087
1088// Icon
1089(function(theme, $) {
1090
1091	'use strict';
1092
1093	theme = theme || {};
1094
1095	var instanceName = '__icon';
1096
1097	var PluginIcon = function($el, opts) {
1098		return this.initialize($el, opts);
1099	};
1100
1101	PluginIcon.defaults = {
1102		color: '#2388ED',
1103		animated: false,
1104		delay: 300
1105	};
1106
1107	PluginIcon.prototype = {
1108		initialize: function($el, opts) {
1109			if ($el.data(instanceName)) {
1110				return this;
1111			}
1112
1113			this.$el = $el;
1114
1115			this
1116				.setData()
1117				.setOptions(opts)
1118				.build();
1119
1120			return this;
1121		},
1122
1123		setData: function() {
1124			this.$el.data(instanceName, this);
1125
1126			return this;
1127		},
1128
1129		setOptions: function(opts) {
1130			this.options = $.extend(true, {}, PluginIcon.defaults, opts, {
1131				wrapper: this.$el
1132			});
1133
1134			return this;
1135		},
1136
1137		build: function() {
1138			var self  	 = this,
1139				$el   	 = this.options.wrapper,
1140				color 	 = self.options.color,
1141				elTopDistance = $el.offset().top,
1142				windowTopDistance = $(window).scrollTop(),
1143				duration = ( self.options.animated && !self.options.strokeBased ) ? 200 : 100;
1144
1145			// Check origin
1146			if( window.location.origin === 'file://' ) {
1147				$el.css('opacity', 1);
1148				return;
1149			}
1150
1151			// Duration
1152			if( self.options.duration ) {
1153				duration = self.options.duration;
1154			}
1155
1156			// Icon Wrapper
1157			var iconWrapper = $('<object class="animated-icon" type="image/svg+xml" data="'+ $el.attr('src') +'"></object>');
1158
1159			if( $el.attr('style') ) {
1160				iconWrapper.attr('style', $el.attr('style'));
1161			}
1162
1163			if( $el.attr('width') ) {
1164				iconWrapper.attr('width', $el.attr('width'));
1165			}
1166
1167			iconWrapper.css('height', $el.height());
1168
1169			$el.replaceWith(iconWrapper);
1170
1171			$el = iconWrapper;
1172
1173			var icon = new Vivus($($el)[0], {start: 'manual', type: 'sync', selfDestroy: true, duration: duration, onReady: function(obj){
1174				var styleElement = document.createElementNS("http://www.w3.org/2000/svg", "style"),
1175					animateStyle = '';
1176
1177				// SVG Fill Based
1178				if( self.options.animated && !self.options.strokeBased || !self.options.animated && color && !self.options.strokeBased ) {
1179					animateStyle = 'stroke-width: 0.1px; fill-opacity: 0; transition: ease fill-opacity 300ms;';
1180					
1181					// Set Style on SVG inside object
1182					styleElement.textContent = 'path, line, rect, circle, line, polyline { fill: '+ color +'; stroke: '+ color +'; '+ animateStyle + (self.options.svgStyle ? self.options.svgStyle : "") + ' } .finished path { fill-opacity: 1; }';
1183					obj.el.appendChild(styleElement);
1184				}
1185
1186				// SVG Stroke Based
1187				if( self.options.animated && self.options.strokeBased || !self.options.animated && color && self.options.strokeBased ) {
1188
1189					// Set Style on SVG inside object
1190					styleElement.textContent = 'path, line, rect, circle, line, polyline { stroke: '+ color +'; ' + (self.options.svgStyle ? self.options.svgStyle : "") + '}';
1191					obj.el.appendChild(styleElement);
1192				}
1193
1194				// devcode: !production
1195				$(window).on('styleSwitcher.modifyVars', function(e){
1196					if( self.options.color.toUpperCase() != '#FFF' ) {
1197						if( e.options.colorPrimary.toUpperCase() != self.options.color.toUpperCase() ) {
1198							
1199							var	styleElement = document.createElementNS("http://www.w3.org/2000/svg", "style"),
1200								svg          = obj.el;
1201
1202							if( self.options.strokeBased ) {
1203								styleElement.textContent = 'path, line, rect, circle, line, polyline { stroke: '+ e.options.colorPrimary +'; }';
1204							} else {
1205								styleElement.textContent = 'path, line, rect, circle, line, polyline { fill: '+ e.options.colorPrimary +'; stroke: '+ e.options.colorPrimary +'; }';
1206							}
1207							svg.appendChild(styleElement);
1208						
1209						}
1210					}
1211				});
1212				// endcode
1213
1214				$.event.trigger('theme.plugin.icon.svg.ready');
1215			}});
1216
1217			// Isn't animated
1218			if( !self.options.animated ) {
1219				setTimeout(function(){
1220					icon.finish();
1221				}, 10);
1222				$el.css({ opacity: 1 });
1223			}
1224
1225			// Animated
1226			if( self.options.animated && $(window).width() > 767 ) {
1227				
1228				// First Load
1229				if( $el.visible( true ) ) {
1230					self.startIconAnimation( icon, $el );
1231				} else if( elTopDistance < windowTopDistance ) {
1232					self.startIconAnimation( icon, $el );
1233				}
1234
1235				// On Scroll
1236				$(window).on('scroll', function(){
1237					if( $el.visible( true ) ) {
1238						self.startIconAnimation( icon, $el );
1239					}
1240				});
1241
1242			} else {
1243				
1244				$el.css({ opacity: 1 });
1245
1246				$(window).on('theme.plugin.icon.svg.ready', function(){
1247					setTimeout(function(){
1248						icon.el.setAttribute('class', 'finished');
1249					}, 300);
1250				});
1251				
1252			}
1253
1254			return this;
1255		},
1256		startIconAnimation: function(icon, $el) {
1257			var self = this;
1258
1259			// Animate for better performance
1260			$({to:0}).animate({to:1}, ((self.options.strokeBased) ? self.options.delay : self.options.delay + 300 ), function() {
1261				$el.css({ opacity: 1 });
1262			});
1263
1264			$({to:0}).animate({to:1}, self.options.delay, function() {
1265				icon.play(1);
1266
1267				setTimeout(function(){
1268					icon.el.setAttribute('class', 'finished');
1269				}, icon.duration * 5 );
1270			});
1271		}
1272	};
1273
1274	// expose to scope
1275	$.extend(theme, {
1276		PluginIcon: PluginIcon
1277	});
1278
1279	// jquery plugin
1280	$.fn.themePluginIcon = function(opts) {
1281		return this.map(function() {
1282			var $this = $(this);
1283
1284			if ($this.data(instanceName)) {
1285				return $this.data(instanceName);
1286			} else {
1287				return new PluginIcon($this, opts);
1288			}
1289
1290		});
1291	};
1292
1293}).apply(this, [window.theme, jQuery]);
1294

1295// Image Background
1296(function(theme, $) {
1297
1298	'use strict';
1299
1300	theme = theme || {};
1301
1302	var instanceName = '__imageBackground';
1303
1304	var PluginImageBackground = function($el, opts) {
1305		return this.initialize($el, opts);
1306	};
1307
1308	PluginImageBackground.defaults = {
1309		bgSize: 'cover',
1310		bgPosition: 'center'
1311	};
1312
1313	PluginImageBackground.prototype = {
1314		initialize: function($el, opts) {
1315			if ($el.data(instanceName)) {
1316				return this;
1317			}
1318
1319			this.$el = $el;
1320
1321			this
1322				.setData()
1323				.setOptions(opts)
1324				.build();
1325
1326			return this;
1327		},
1328
1329		setData: function() {
1330			this.$el.data(instanceName, this);
1331
1332			return this;
1333		},
1334
1335		setOptions: function(opts) {
1336			this.options = $.extend(true, {}, PluginImageBackground.defaults, opts, {
1337				wrapper: this.$el
1338			});
1339
1340			return this;
1341		},
1342
1343		build: function() {
1344			var self = this,
1345				$el = self.options.wrapper,
1346				important;
1347
1348			if( !self.options.imageUrl ) {
1349				return;
1350			}
1351
1352			$el.css({
1353				'background-image': 'url(' + self.options.imageUrl + ')',
1354				'background-size' : self.options.bgSize,
1355				'background-position': self.options.bgPosition,
1356				'background-repeat': 'no-repeat'
1357			});
1358
1359			return this;
1360		}
1361	};
1362
1363	// expose to scope
1364	$.extend(theme, {
1365		PluginImageBackground: PluginImageBackground
1366	});
1367
1368	// jquery plugin
1369	$.fn.themePluginImageBackground = function(opts) {
1370		return this.map(function() {
1371			var $this = $(this);
1372
1373			if ($this.data(instanceName)) {
1374				return $this.data(instanceName);
1375			} else {
1376				return new PluginImageBackground($this, opts);
1377			}
1378
1379		});
1380	}
1381
1382}).apply(this, [window.theme, jQuery]);
1383
1384// Lazy Load
1385(function(theme, $) {
1386
1387	'use strict';
1388
1389	theme = theme || {};
1390
1391	var instanceName = '__lazyload';
1392
1393	var PluginLazyLoad = function($el, opts) {
1394		return this.initialize($el, opts);
1395	};
1396
1397	PluginLazyLoad.defaults = {
1398		effect: 'show',
1399		appearEffect: '',
1400		appear: function(elements_left, settings) {
1401			
1402		},
1403		load: function(elements_left, settings) {
1404			$(this).addClass($.trim('lazy-load-loaded ' + settings.appearEffect));
1405		}
1406	};
1407
1408	PluginLazyLoad.prototype = {
1409		initialize: function($el, opts) {
1410			if ($el.data(instanceName)) {
1411				return this;
1412			}
1413
1414			this.$el = $el;
1415
1416			this
1417				.setData()
1418				.setOptions(opts)
1419				.build();
1420
1421			return this;
1422		},
1423
1424		setData: function() {
1425			this.$el.data(instanceName, this);
1426
1427			return this;
1428		},
1429
1430		setOptions: function(opts) {
1431			this.options = $.extend(true, {}, PluginLazyLoad.defaults, opts, {
1432				wrapper: this.$el
1433			});
1434
1435			return this;
1436		},
1437
1438		build: function() {
1439			if (!($.isFunction($.fn.lazyload))) {
1440				return this;
1441			}
1442
1443			var self = this;
1444
1445			self.options.wrapper.lazyload(this.options);
1446
1447			return this;
1448		}
1449	};
1450
1451	// expose to scope
1452	$.extend(theme, {
1453		PluginLazyLoad: PluginLazyLoad
1454	});
1455
1456	// jquery plugin
1457	$.fn.themePluginLazyLoad = function(opts) {
1458		return this.map(function() {
1459			var $this = $(this);
1460
1461			if ($this.data(instanceName)) {
1462				return $this.data(instanceName);
1463			} else {
1464				return new PluginLazyLoad($this, opts);
1465			}
1466
1467		});
1468	}
1469
1470}).apply(this, [window.theme, jQuery]);
1471
1472// Lightbox
1473(function(theme, $) {
1474
1475	'use strict';
1476
1477	theme = theme || {};
1478
1479	var instanceName = '__lightbox';
1480
1481	var PluginLightbox = function($el, opts) {
1482		return this.initialize($el, opts);
1483	};
1484
1485	PluginLightbox.defaults = {
1486		tClose: 'Close (Esc)', // Alt text on close button
1487		tLoading: 'Loading...', // Text that is displayed during loading. Can contain %curr% and %total% keys
1488		gallery: {
1489			tPrev: 'Previous (Left arrow key)', // Alt text on left arrow
1490			tNext: 'Next (Right arrow key)', // Alt text on right arrow
1491			tCounter: '%curr% of %total%' // Markup for "1 of 7" counter
1492		},
1493		image: {
1494			tError: '<a href="%url%">The image</a> could not be loaded.' // Error message when image could not be loaded
1495		},
1496		ajax: {
1497			tError: '<a href="%url%">The content</a> could not be loaded.' // Error message when ajax request failed
1498		},
1499		callbacks: {
1500			open: function() {
1501				$('html').addClass('lightbox-open');
1502			},
1503			close: function() {
1504				$('html').removeClass('lightbox-open');
1505			}
1506		}
1507	};
1508
1509	PluginLightbox.prototype = {
1510		initialize: function($el, opts) {
1511			if ($el.data(instanceName)) {
1512				return this;
1513			}
1514
1515			this.$el = $el;
1516
1517			this
1518				.setData()
1519				.setOptions(opts)
1520				.build();
1521
1522			return this;
1523		},
1524
1525		setData: function() {
1526			this.$el.data(instanceName, this);
1527
1528			return this;
1529		},
1530
1531		setOptions: function(opts) {
1532			this.options = $.extend(true, {}, PluginLightbox.defaults, opts, {
1533				wrapper: this.$el
1534			});
1535
1536			return this;
1537		},
1538
1539		build: function() {
1540			if (!($.isFunction($.fn.magnificPopup))) {
1541				return this;
1542			}
1543
1544			this.options.wrapper.magnificPopup(this.options);
1545
1546			return this;
1547		}
1548	};
1549
1550	// expose to scope
1551	$.extend(theme, {
1552		PluginLightbox: PluginLightbox
1553	});
1554
1555	// jquery plugin
1556	$.fn.themePluginLightbox = function(opts) {
1557		return this.map(function() {
1558			var $this = $(this);
1559
1560			if ($this.data(instanceName)) {
1561				return $this.data(instanceName);
1562			} else {
1563				return new PluginLightbox($this, opts);
1564			}
1565
1566		});
1567	}
1568
1569}).apply(this, [window.theme, jQuery]);
1570
1571// Loading Overlay
1572(function(theme, $) {
1573
1574	'use strict';
1575
1576	theme = theme || {};
1577
1578	var loadingOverlayTemplate = [
1579		'<div class="loading-overlay">',
1580			'<div class="bounce-loader"><div class="bounce1"></div><div class="bounce2"></div><div class="bounce3"></div></div>',
1581		'</div>'
1582	].join('');
1583
1584	var LoadingOverlay = function( $wrapper, options ) {
1585		return this.initialize( $wrapper, options );
1586	};
1587
1588	LoadingOverlay.prototype = {
1589
1590		options: {
1591			css: {}
1592		},
1593
1594		initialize: function( $wrapper, options ) {
1595			this.$wrapper = $wrapper;
1596
1597			this
1598				.setVars()
1599				.setOptions( options )
1600				.build()
1601				.events();
1602
1603			this.$wrapper.data( 'loadingOverlay', this );
1604		},
1605
1606		setVars: function() {

1607			this.$overlay = this.$wrapper.find('.loading-overlay');
1608
1609			return this;
1610		},
1611
1612		setOptions: function( options ) {
1613			if ( !this.$overlay.get(0) ) {
1614				this.matchProperties();
1615			}
1616			this.options     = $.extend( true, {}, this.options, options );
1617			this.loaderClass = this.getLoaderClass( this.options.css.backgroundColor );
1618
1619			return this;
1620		},
1621
1622		build: function() {
1623			if ( !this.$overlay.closest(document.documentElement).get(0) ) {
1624				if ( !this.$cachedOverlay ) {
1625					this.$overlay = $( loadingOverlayTemplate ).clone();
1626
1627					if ( this.options.css ) {
1628						this.$overlay.css( this.options.css );
1629						this.$overlay.find( '.loader' ).addClass( this.loaderClass );
1630					}
1631				} else {
1632					this.$overlay = this.$cachedOverlay.clone();
1633				}
1634
1635				this.$wrapper.append( this.$overlay );
1636			}
1637
1638			if ( !this.$cachedOverlay ) {
1639				this.$cachedOverlay = this.$overlay.clone();
1640			}
1641
1642			return this;
1643		},
1644
1645		events: function() {
1646			var _self = this;
1647
1648			if ( this.options.startShowing ) {
1649				_self.show();
1650			}
1651
1652			if ( this.$wrapper.is('body') || this.options.hideOnWindowLoad ) {
1653				$( window ).on( 'load error', function() {
1654					_self.hide();
1655				});
1656			}
1657
1658			if ( this.options.listenOn ) {
1659				$( this.options.listenOn )
1660					.on( 'loading-overlay:show beforeSend.ic', function( e ) {
1661						e.stopPropagation();
1662						_self.show();
1663					})
1664					.on( 'loading-overlay:hide complete.ic', function( e ) {
1665						e.stopPropagation();
1666						_self.hide();
1667					});
1668			}
1669
1670			this.$wrapper
1671				.on( 'loading-overlay:show beforeSend.ic', function( e ) {
1672					if ( e.target === _self.$wrapper.get(0) ) {
1673						e.stopPropagation();
1674						_self.show();
1675						return true;
1676					}
1677					return false;
1678				})
1679				.on( 'loading-overlay:hide complete.ic', function( e ) {
1680					if ( e.target === _self.$wrapper.get(0) ) {
1681						e.stopPropagation();
1682						_self.hide();
1683						return true;
1684					}
1685					return false;
1686				});
1687
1688			return this;
1689		},
1690
1691		show: function() {
1692			this.build();
1693
1694			this.position = this.$wrapper.css( 'position' ).toLowerCase();
1695			if ( this.position != 'relative' || this.position != 'absolute' || this.position != 'fixed' ) {
1696				this.$wrapper.css({
1697					position: 'relative'
1698				});
1699			}
1700			this.$wrapper.addClass( 'loading-overlay-showing' );
1701		},
1702
1703		hide: function() {
1704			var _self = this;
1705
1706			this.$wrapper.removeClass( 'loading-overlay-showing' );
1707			setTimeout(function() {
1708				if ( this.position != 'relative' || this.position != 'absolute' || this.position != 'fixed' ) {
1709					_self.$wrapper.css({ position: '' });
1710				}
1711			}, 500);
1712		},
1713
1714		matchProperties: function() {
1715			var i,
1716				l,
1717				properties;
1718
1719			properties = [
1720				'backgroundColor',
1721				'borderRadius'
1722			];
1723
1724			l = properties.length;
1725
1726			for( i = 0; i < l; i++ ) {
1727				var obj = {};
1728				obj[ properties[ i ] ] = this.$wrapper.css( properties[ i ] );
1729
1730				$.extend( this.options.css, obj );
1731			}
1732		},
1733
1734		getLoaderClass: function( backgroundColor ) {
1735			if ( !backgroundColor || backgroundColor === 'transparent' || backgroundColor === 'inherit' ) {
1736				return 'black';
1737			}
1738
1739			var hexColor,
1740				r,
1741				g,
1742				b,
1743				yiq;
1744
1745			var colorToHex = function( color ){
1746				var hex,
1747					rgb;
1748
1749				if( color.indexOf('#') >- 1 ){
1750					hex = color.replace('#', '');
1751				} else {
1752					rgb = color.match(/\d+/g);
1753					hex = ('0' + parseInt(rgb[0], 10).toString(16)).slice(-2) + ('0' + parseInt(rgb[1], 10).toString(16)).slice(-2) + ('0' + parseInt(rgb[2], 10).toString(16)).slice(-2);
1754				}
1755
1756				if ( hex.length === 3 ) {
1757					hex = hex + hex;
1758				}
1759
1760				return hex;
1761			};
1762
1763			hexColor = colorToHex( backgroundColor );
1764
1765			r = parseInt( hexColor.substr( 0, 2), 16 );
1766			g = parseInt( hexColor.substr( 2, 2), 16 );
1767			b = parseInt( hexColor.substr( 4, 2), 16 );
1768			yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
1769
1770			return ( yiq >= 128 ) ? 'black' : 'white';
1771		}
1772
1773	};
1774
1775	// expose to scope
1776	$.extend(theme, {
1777		LoadingOverlay: LoadingOverlay
1778	});
1779
1780	// expose as a jquery plugin
1781	$.fn.loadingOverlay = function( opts ) {
1782		return this.each(function() {
1783			var $this = $( this );
1784
1785			var loadingOverlay = $this.data( 'loadingOverlay' );
1786			if ( loadingOverlay ) {
1787				return loadingOverlay;
1788			} else {
1789				var options = opts || $this.data( 'loading-overlay-options' ) || {};
1790				return new LoadingOverlay( $this, options );
1791			}
1792		});
1793	}
1794
1795	// auto init
1796	$('[data-loading-overlay]').loadingOverlay();
1797
1798}).apply(this, [window.theme, jQuery]);
1799
1800// Masonry
1801(function(theme, $) {
1802
1803	'use strict';
1804
1805	theme = theme || {};
1806
1807	var instanceName = '__masonry';
1808
1809	var PluginMasonry = function($el, opts) {
1810		return this.initialize($el, opts);
1811	};
1812
1813	PluginMasonry.defaults = {
1814		itemSelector: '.isotope-item'
1815	};
1816
1817	PluginMasonry.prototype = {
1818		initialize: function($el, opts) {
1819			if ($el.data(instanceName)) {
1820				return this;
1821			}
1822
1823			this.$el = $el;
1824
1825			this
1826				.setData()
1827				.setOptions(opts)
1828				.build();
1829
1830			return this;
1831		},
1832
1833		setData: function() {
1834			this.$el.data(instanceName, this);
1835
1836			return this;
1837		},
1838
1839		setOptions: function(opts) {
1840			this.options = $.extend(true, {}, PluginMasonry.defaults, opts, {
1841				wrapper: this.$el
1842			});
1843
1844			return this;
1845		},
1846
1847		build: function() {
1848			if (!($.isFunction($.fn.isotope))) {
1849				return this;
1850			}
1851
1852			var self = this,
1853				$window = $(window);
1854
1855			self.$loader = false;

1856
1857			if (self.options.wrapper.closest('.masonry-loader').get(0)) {
1858				self.$loader = self.options.wrapper.closest('.masonry-loader');
1859				self.createLoader();
1860			}
1861
1862			self.options.wrapper.one('layoutComplete', function(event, laidOutItems) {
1863				self.removeLoader();
1864			});
1865
1866			self.options.wrapper.waitForImages(function() {
1867				self.options.wrapper.isotope(self.options);
1868			});
1869
1870			setTimeout(function() {
1871				self.removeLoader();
1872			}, 3000);
1873
1874			$window.afterResize(function(){
1875				self.options.wrapper.isotope('layout');
1876			});
1877
1878			return this;
1879		},
1880
1881		createLoader: function() {
1882			var self = this;
1883
1884			var loaderTemplate = [
1885				'<div class="bounce-loader">',
1886					'<div class="bounce1"></div>',
1887					'<div class="bounce2"></div>',
1888					'<div class="bounce3"></div>',
1889				'</div>'
1890			].join('');
1891
1892			self.$loader.append(loaderTemplate);
1893
1894			return this;
1895		},
1896
1897		removeLoader: function() {
1898
1899			var self = this;
1900
1901			if (self.$loader) {
1902
1903				self.$loader.removeClass('masonry-loader-showing');
1904
1905				setTimeout(function() {
1906					self.$loader.addClass('masonry-loader-loaded');
1907				}, 300);
1908
1909			}
1910
1911		}
1912	};
1913
1914	// expose to scope
1915	$.extend(theme, {
1916		PluginMasonry: PluginMasonry
1917	});
1918
1919	// jquery plugin
1920	$.fn.themePluginMasonry = function(opts) {
1921		return this.map(function() {
1922			var $this = $(this);
1923
1924			if ($this.data(instanceName)) {
1925				return $this.data(instanceName);
1926			} else {
1927				return new PluginMasonry($this, opts);
1928			}
1929
1930		});
1931	}
1932
1933}).apply(this, [window.theme, jQuery]);
1934
1935// Match Height
1936(function(theme, $) {
1937
1938	'use strict';
1939
1940	theme = theme || {};
1941
1942	var instanceName = '__matchHeight';
1943
1944	var PluginMatchHeight = function($el, opts) {
1945		return this.initialize($el, opts);
1946	};
1947
1948	PluginMatchHeight.defaults = {
1949		byRow: true,
1950		property: 'height',
1951		target: null,
1952		remove: false
1953	};
1954
1955	PluginMatchHeight.prototype = {
1956		initialize: function($el, opts) {
1957			if ($el.data(instanceName)) {
1958				return this;
1959			}
1960
1961			this.$el = $el;
1962
1963			this
1964				.setData()
1965				.setOptions(opts)
1966				.build();
1967
1968			return this;
1969		},
1970
1971		setData: function() {
1972			this.$el.data(instanceName, this);
1973
1974			return this;
1975		},
1976
1977		setOptions: function(opts) {
1978			this.options = $.extend(true, {}, PluginMatchHeight.defaults, opts, {
1979				wrapper: this.$el
1980			});
1981
1982			return this;
1983		},
1984
1985		build: function() {
1986			if (!($.isFunction($.fn.matchHeight))) {
1987				return this;
1988			}
1989
1990			var self = this;
1991
1992			self.options.wrapper.matchHeight(self.options);
1993
1994			return this;
1995		}
1996
1997	};
1998
1999	// expose to scope
2000	$.extend(theme, {
2001		PluginMatchHeight: PluginMatchHeight
2002	});
2003
2004	// jquery plugin
2005	$.fn.themePluginMatchHeight = function(opts) {
2006		return this.map(function() {
2007			var $this = $(this);
2008
2009			if ($this.data(instanceName)) {
2010				return $this.data(instanceName);
2011			} else {
2012				return new PluginMatchHeight($this, opts);
2013			}
2014
2015		});
2016	}
2017
2018}).apply(this, [window.theme, jQuery]);
2019
2020// Parallax
2021(function(theme, $) {
2022
2023	'use strict';
2024
2025	theme = theme || {};
2026
2027	var instanceName = '__parallax';
2028
2029	var PluginParallax = function($el, opts) {
2030		return this.initialize($el, opts);
2031	};
2032
2033	PluginParallax.defaults = {
2034		speed: 1.5,
2035		horizontalPosition: '50%',
2036		offset: 0,
2037		responsiveOffset: false,
2038		parallaxHeight: '180%'
2039	};
2040
2041	PluginParallax.prototype = {
2042		initialize: function($el, opts) {
2043			if ($el.data(instanceName)) {
2044				return this;
2045			}
2046
2047			this.$el = $el;
2048
2049			this
2050				.setData()
2051				.setOptions(opts)
2052				.build();
2053
2054			return this;
2055		},
2056
2057		setData: function() {
2058			this.$el.data(instanceName, this);
2059
2060			return this;
2061		},
2062
2063		setOptions: function(opts) {
2064			this.options = $.extend(true, {}, PluginParallax.defaults, opts, {
2065				wrapper: this.$el
2066			});
2067
2068			return this;
2069		},
2070
2071		build: function() {
2072			var self = this,
2073				$window = $(window),
2074				offset,
2075				optOffset,
2076				yPos,
2077				plxPos,
2078				bgpos,
2079				background;
2080
2081			// Create Parallax Element
2082			background = $('<div class="parallax-background"></div>');
2083
2084			// Set Style for Parallax Element
2085			background.css({
2086				'background-image' : 'url(' + self.options.wrapper.data('image-src') + ')',
2087				'background-size' : 'cover',
2088				'background-position' : 'center',
2089				'position' : 'absolute',
2090				'top' : 0,
2091				'left' : 0,
2092				'width' : '100%',
2093				'height' : (!$.browser.mobile) ? self.options.parallaxHeight : '100%'
2094			});
2095
2096			// Add Parallax Element on DOM
2097			self.options.wrapper.prepend(background);
2098
2099			// Set Overlfow Hidden / Position Relative / Min height to Parallax Wrapper
2100			self.options.wrapper.css({
2101				'position' : 'relative',
2102				'overflow' : 'hidden',
2103				'min-height': (self.options.minHeight) ? self.options.minHeight : ''
2104			});
2105
2106			// Parallax Effect on Scroll & Resize
2107			var parallaxEffectOnScrolResize = function() {
2108				// Offset
2109				optOffset = self.options.offset;
2110
2111				$window.on('scroll resize', function() {
2112					
2113					// Responsive Offset
2114					if( self.options.responsiveOffset ) {
2115						var window_w = $window.width(),
2116							responsiveOffset = self.options.responsiveOffset;
2117
2118						if( responsiveOffset.constructor === Array ) {
2119							if( window_w > 1199 ) {
2120								optOffset = responsiveOffset[2];
2121							} else if( window_w > 991 ) {
2122								optOffset = responsiveOffset[1];
2123							} else if( window_w > 767 ) {
2124								optOffset = responsiveOffset[0];
2125							}
2126						}
2127					}
2128
2129					offset  = self.options.wrapper.offset();
2130					yPos    = -($window.scrollTop() - (offset.top - 100)) / ((self.options.speed + 2 ));
2131					plxPos  = (yPos < 0) ? Math.abs(yPos) : -Math.abs(yPos);
2132					background.css({
2133						'transform' : 'translate3d(0, '+ ( (plxPos - 50) + (optOffset) ) +'px, 0)',
2134						'background-position-x' : self.options.horizontalPosition
2135					});
2136					
2137				});
2138
2139				$window.trigger('scroll');
2140			}
2141
2142			if (!$.browser.mobile) {
2143				parallaxEffectOnScrolResize();
2144			} else {
2145				if( self.options.enableOnMobile == true ) {
2146					parallaxEffectOnScrolResize();
2147				} else {
2148					self.options.wrapper.addClass('parallax-disabled');
2149				}
2150			}
2151
2152			return this;
2153		}
2154	};
2155
2156	// expose to scope
2157	$.extend(theme, {
2158		PluginParallax: PluginParallax
2159	});
2160
2161	// jquery plugin
2162	$.fn.themePluginParallax = function(opts) {
2163		return this.map(function() {
2164			var $this = $(this);
2165
2166			if ($this.data(instanceName)) {
2167				return $this.data(instanceName);
2168			} else {
2169				return new PluginParallax($this, opts);
2170			}
2171
2172		});
2173	}
2174
2175}).apply(this, [window.theme, jQuery]);
2176
2177// Progress Bar
2178(function(theme, $) {
2179
2180	'use strict';
2181
2182	theme = theme || {};
2183
2184	var instanceName = '__progressBar';
2185
2186	var PluginProgressBar = function($el, opts) {
2187		return this.initialize($el, opts);
2188	};
2189
2190	PluginProgressBar.defaults = {
2191		accX: 0,
2192		accY: -50,
2193		delay: 1
2194	};
2195
2196	PluginProgressBar.prototype = {
2197		initialize: function($el, opts) {
2198			if ($el.data(instanceName)) {
2199				return this;
2200			}
2201
2202			this.$el = $el;
2203
2204			this
2205				.setData()
2206				.setOptions(opts)
2207				.build();
2208
2209			return this;
2210		},
2211
2212		setData: function() {
2213			this.$el.data(instanceName, this);
2214
2215			return this;
2216		},
2217
2218		setOptions: function(opts) {
2219			this.options = $.extend(true, {}, PluginProgressBar.defaults, opts, {
2220				wrapper: this.$el
2221			});
2222
2223			return this;
2224		},
2225
2226		build: function() {
2227			if (!($.isFunction($.fn.appear))) {
2228				return this;
2229			}
2230
2231			var self = this,
2232				$el = this.options.wrapper,

2233				delay = 1;
2234
2235			$el.appear(function() {
2236
2237				delay = ($el.attr('data-appear-animation-delay') ? $el.attr('data-appear-animation-delay') : self.options.delay);
2238
2239				$el.addClass($el.attr('data-appear-animation'));
2240
2241				setTimeout(function() {
2242
2243					$el.animate({
2244						width: $el.attr('data-appear-progress-animation')
2245					}, 1500, 'easeOutQuad', function() {
2246						$el.find('.progress-bar-tooltip').animate({
2247							opacity: 1
2248						}, 500, 'easeOutQuad');
2249					});
2250
2251				}, delay);
2252
2253			}, {
2254				accX: self.options.accX,
2255				accY: self.options.accY
2256			});
2257
2258			return this;
2259		}
2260	};
2261
2262	// expose to scope
2263	$.extend(theme, {
2264		PluginProgressBar: PluginProgressBar
2265	});
2266
2267	// jquery plugin
2268	$.fn.themePluginProgressBar = function(opts) {
2269		return this.map(function() {
2270			var $this = $(this);
2271
2272			if ($this.data(instanceName)) {
2273				return $this.data(instanceName);
2274			} else {
2275				return new PluginProgressBar($this, opts);
2276			}
2277
2278		});
2279	}
2280
2281}).apply(this, [window.theme, jQuery]);
2282
2283// Rmove Min Height Adter Load
2284(function(theme, $) {
2285
2286	'use strict';
2287
2288	theme = theme || {};
2289
2290	var instanceName = '__removeMinHeight';
2291
2292	var PluginRemoveMinHeight = function($el, opts) {
2293		return this.initialize($el, opts);
2294	};
2295
2296	PluginRemoveMinHeight.prototype = {
2297		initialize: function($el, opts) {
2298			if ($el.data(instanceName)) {
2299				return this;
2300			}
2301
2302			this.$el = $el;
2303
2304			this
2305				.setData()
2306				.build();
2307
2308			return this;
2309		},
2310
2311		setData: function() {
2312			this.$el.data(instanceName, this);
2313
2314			return this;
2315		},
2316
2317		build: function() {
2318			var self = this;
2319
2320			$(window).on('load', function(){
2321				self.$el.css('min-height', 0);
2322			});
2323
2324			return this;
2325		}
2326	};
2327
2328	// expose to scope
2329	$.extend(theme, {
2330		PluginRemoveMinHeight: PluginRemoveMinHeight
2331	});
2332
2333	// jquery plugin
2334	$.fn.themePluginRemoveMinHeight = function(opts) {
2335		return this.map(function() {
2336			var $this = $(this);
2337
2338			if ($this.data(instanceName)) {
2339				return $this.data(instanceName);
2340			} else {
2341				return new PluginRemoveMinHeight($this, opts);
2342			}
2343
2344		});
2345	}
2346
2347}).apply(this, [window.theme, jQuery]);
2348
2349// Revolution Slider
2350(function(theme, $) {
2351
2352	'use strict';
2353
2354	theme = theme || {};
2355
2356	var instanceName = '__revolution';
2357
2358	var PluginRevolutionSlider = function($el, opts) {
2359		return this.initialize($el, opts);
2360	};
2361
2362	PluginRevolutionSlider.defaults = {
2363		sliderType: 'standard',
2364		sliderLayout: 'fullwidth',
2365		delay: 9000,
2366		gridwidth: 1170,
2367		gridheight: 500,
2368		spinner: 'spinner3',
2369		disableProgressBar: 'on',
2370		parallax: {
2371			type: 'off',
2372			bgparallax: 'off'
2373		},
2374		navigation: {
2375			keyboardNavigation: 'off',
2376			keyboard_direction: 'horizontal',
2377			mouseScrollNavigation: 'off',
2378			onHoverStop: 'off',
2379			touch: {
2380				touchenabled: 'on',
2381				swipe_threshold: 75,
2382				swipe_min_touches: 1,
2383				swipe_direction: 'horizontal',
2384				drag_block_vertical: false
2385			},
2386			arrows: {
2387				enable: true,
2388				hide_onmobile: false,
2389				hide_under: 0,
2390				hide_onleave: true,
2391				hide_delay: 200,
2392				hide_delay_mobile: 1200,
2393				left: {
2394					h_align: 'left',
2395					v_align: 'center',
2396					h_offset: 30,
2397					v_offset: 0
2398				},
2399				right: {
2400					h_align: 'right',
2401					v_align: 'center',
2402					h_offset: 30,
2403					v_offset: 0
2404				}
2405			}
2406		}
2407	};
2408
2409	PluginRevolutionSlider.prototype = {
2410		initialize: function($el, opts) {
2411			if ($el.data(instanceName)) {
2412				return this;
2413			}
2414
2415			this.$el = $el;
2416
2417			this
2418				.setData()
2419				.setOptions(opts)
2420				.build()
2421				.events();
2422
2423			return this;
2424		},
2425
2426		setData: function() {
2427			this.$el.data(instanceName, this);
2428
2429			return this;
2430		},
2431
2432		setOptions: function(opts) {
2433			this.options = $.extend(true, {}, PluginRevolutionSlider.defaults, opts, {
2434				wrapper: this.$el
2435			});
2436
2437			return this;
2438		},
2439
2440		build: function() {
2441			if (!($.isFunction($.fn.revolution))) {
2442				return this;
2443			}
2444
2445			// Single Slider Class
2446			if(this.options.wrapper.find('> ul > li').length == 1) {
2447				this.options.wrapper.addClass('slider-single-slide');
2448			}
2449
2450			this.options.wrapper.revolution(this.options);
2451
2452			return this;
2453		},
2454
2455		events: function() {
2456
2457			return this;
2458		}
2459	};
2460
2461	// expose to scope
2462	$.extend(theme, {
2463		PluginRevolutionSlider: PluginRevolutionSlider
2464	});
2465
2466	// jquery plugin
2467	$.fn.themePluginRevolutionSlider = function(opts) {
2468		return this.map(function() {
2469			var $this = $(this);
2470
2471			if ($this.data(instanceName)) {
2472				return $this.data(instanceName);
2473			} else {
2474				return new PluginRevolutionSlider($this, opts);
2475			}
2476
2477		});
2478	}
2479
2480}).apply(this, [window.theme, jQuery]);
2481
2482// Scroll to Top
2483(function(theme, $) {
2484
2485	'use strict';
2486
2487	theme = theme || {};
2488
2489	var initialized = false;

2490
2491	$.extend(theme, {
2492
2493		PluginScrollToTop: {
2494
2495			defaults: {
2496				wrapper: $('body'),
2497				offset: 150,
2498				buttonClass: 'scroll-to-top',
2499				iconClass: 'fas fa-chevron-up',
2500				delay: 1000,
2501				visibleMobile: false,
2502				label: false,
2503				easing: 'easeOutBack'
2504			},
2505
2506			initialize: function(opts) {
2507				initialized = true;
2508
2509				this
2510					.setOptions(opts)
2511					.build()
2512					.events();
2513
2514				return this;
2515			},
2516
2517			setOptions: function(opts) {
2518				this.options = $.extend(true, {}, this.defaults, opts);
2519
2520				return this;
2521			},
2522
2523			build: function() {
2524				var self = this,
2525					$el;
2526
2527				// Base HTML Markup
2528				$el = $('<a />')
2529					.addClass(self.options.buttonClass)
2530					.attr({
2531						'href': '#',
2532					})
2533					.append(
2534						$('<i />')
2535						.addClass(self.options.iconClass)
2536				);
2537
2538				// Visible Mobile
2539				if (!self.options.visibleMobile) {
2540					$el.addClass('hidden-mobile');
2541				}
2542
2543				// Label
2544				if (self.options.label) {
2545					$el.append(
2546						$('<span />').html(self.options.label)
2547					);
2548				}
2549
2550				this.options.wrapper.append($el);
2551
2552				this.$el = $el;
2553
2554				return this;
2555			},
2556
2557			events: function() {
2558				var self = this,
2559					_isScrolling = false;
2560
2561				// Click Element Action
2562				self.$el.on('click', function(e) {
2563					e.preventDefault();
2564					$('body, html').animate({
2565						scrollTop: 0
2566					}, self.options.delay, self.options.easing);
2567					return false;
2568				});
2569
2570				// Show/Hide Button on Window Scroll event.
2571				$(window).scroll(function() {
2572
2573					if (!_isScrolling) {
2574
2575						_isScrolling = true;
2576
2577						if ($(window).scrollTop() > self.options.offset) {
2578
2579							self.$el.stop(true, true).addClass('visible');
2580							_isScrolling = false;
2581
2582						} else {
2583
2584							self.$el.stop(true, true).removeClass('visible');
2585							_isScrolling = false;
2586
2587						}
2588
2589					}
2590
2591				});
2592
2593				return this;
2594			}
2595
2596		}
2597
2598	});
2599
2600}).apply(this, [window.theme, jQuery]);
2601
2602// Counter
2603(function(theme, $) {
2604
2605	'use strict';
2606
2607	theme = theme || {};
2608
2609	var instanceName = '__sliderRange';
2610
2611	var PluginSliderRange = function($el, opts) {
2612		return this.initialize($el, opts);
2613	};
2614
2615	PluginSliderRange.defaults = {
2616		start: [ 50, 250 ],
2617		connect: true,
2618		step: 1,
2619		range: {
2620			min: 0,
2621			max: 300
2622		}
2623	};
2624
2625	PluginSliderRange.prototype = {
2626		initialize: function($el, opts) {
2627			if ($el.data(instanceName)) {
2628				return this;
2629			}
2630
2631			this.$el = $el;
2632
2633			this
2634				.setData()
2635				.setOptions(opts)
2636				.build();
2637
2638			return this;
2639		},
2640
2641		setData: function() {
2642			this.$el.data(instanceName, this);
2643
2644			return this;
2645		},
2646
2647		setOptions: function(opts) {
2648			this.options = $.extend(true, {}, PluginSliderRange.defaults, opts, {
2649				wrapper: this.$el
2650			});
2651
2652			return this;
2653		},
2654
2655		build: function() {
2656			if (!($.isFunction($.fn.countTo))) {
2657				return this;
2658			}
2659
2660			var self = this,
2661				$el = this.options.wrapper,
2662				priceLow = $('.price-range-low'),
2663				priceHigh = $('.price-range-high'),
2664				hiddenPriceLow = $('.hidden-price-range-low'),
2665				hiddenPriceHigh = $('.hidden-price-range-high');
2666
2667			// Create Slider
2668			noUiSlider.create($el[0], {
2669				start: [ 50, 250 ],
2670				connect: true,
2671				step: 1,
2672				range: {
2673					'min': 0,
2674					'max': 300
2675				}
2676			});
2677
2678			// Update Input values
2679			$el[0].noUiSlider.on('update', function( values, handle ) {
2680				var value = values[handle];
2681
2682				if ( handle ) {
2683					priceHigh.text(Math.round(value));
2684					hiddenPriceHigh.val(Math.round(value));
2685				} else {
2686					priceLow.text(Math.round(value));
2687					hiddenPriceLow.val(Math.round(value));
2688				}
2689			});
2690
2691			return this;
2692		}
2693	};
2694
2695	// expose to scope
2696	$.extend(theme, {
2697		PluginSliderRange: PluginSliderRange
2698	});
2699
2700	// jquery plugin
2701	$.fn.themePluginSliderRange = function(opts) {
2702		return this.map(function() {
2703			var $this = $(this);
2704
2705			if ($this.data(instanceName)) {
2706				return $this.data(instanceName);
2707			} else {
2708				return new PluginSliderRange($this, opts);
2709			}
2710
2711		});
2712	}
2713
2714}).apply(this, [window.theme, jQuery]);
2715
2716// Sort
2717(function(theme, $) {
2718
2719	'use strict';
2720
2721	theme = theme || {};
2722
2723	var instanceName = '__sort';
2724
2725	var PluginSort = function($el, opts) {
2726		return this.initialize($el, opts);
2727	};
2728
2729	PluginSort.defaults = {
2730		useHash: true,
2731		itemSelector: '.isotope-item',
2732		layoutMode: 'masonry',
2733		filter: '*',
2734		hiddenStyle: {
2735			opacity: 0
2736		},
2737		visibleStyle: {
2738			opacity: 1
2739		},
2740		stagger: 30,
2741		isOriginLeft: ($('html').attr('dir') == 'rtl' ? false : true)
2742	};
2743
2744	PluginSort.prototype = {
2745		initialize: function($el, opts) {
2746			if ($el.data(instanceName)) {
2747				return this;
2748			}
2749
2750			this.$el = $el;
2751
2752			this
2753				.setData()
2754				.setOptions(opts)
2755				.build();
2756
2757			return this;
2758		},
2759
2760		setData: function() {
2761			this.$el.data(instanceName, this);
2762
2763			return this;
2764		},
2765
2766		setOptions: function(opts) {
2767			this.options = $.extend(true, {}, PluginSort.defaults, opts, {
2768				wrapper: this.$el
2769			});
2770
2771			return this;
2772		},
2773
2774		build: function() {
2775			if (!($.isFunction($.fn.isotope))) {
2776				return this;
2777			}
2778
2779			var self = this,
2780				$source = this.options.wrapper,
2781				$destination = $('.sort-destination[data-sort-id="' + $source.attr('data-sort-id') + '"]'),
2782				$window = $(window);
2783
2784			if ($destination.get(0)) {
2785
2786				self.$source = $source;
2787				self.$destination = $destination;
2788				self.$loader = false;