https://assetpackgames.com/js/theme.js

1/*
2Name: 			Theme Base
3Written by: 	Okler Themes - (http://www.okler.net)
4Theme Version:	7.6.0
5*/
6
7// Theme
8window.theme = {};
9
10// Theme Common Functions
11window.theme.fn = {
12
13	getOptions: function(opts) {
14
15		if (typeof(opts) == 'object') {
16
17			return opts;
18
19		} else if (typeof(opts) == 'string') {
20
21			try {
22				return JSON.parse(opts.replace(/'/g,'"').replace(';',''));
23			} catch(e) {
24				return {};
25			}
26
27		} else {
28
29			return {};
30
31		}
32
33	}
34
35};
36
37// Animate
38(function(theme, $) {
39
40	theme = theme || {};
41
42	var instanceName = '__animate';
43
44	var PluginAnimate = function($el, opts) {
45		return this.initialize($el, opts);
46	};
47
48	PluginAnimate.defaults = {
49		accX: 0,
50		accY: -80,
51		delay: 100,
52		duration: '750ms',
53		minWindowWidth: 767
54	};
55
56	PluginAnimate.prototype = {
57		initialize: function($el, opts) {
58			if ($el.data(instanceName)) {
59				return this;
60			}
61
62			this.$el = $el;
63
64			this
65				.setData()
66				.setOptions(opts)
67				.build();
68
69			return this;
70		},
71
72		setData: function() {
73			this.$el.data(instanceName, this);
74
75			return this;
76		},
77
78		setOptions: function(opts) {
79			this.options = $.extend(true, {}, PluginAnimate.defaults, opts, {
80				wrapper: this.$el
81			});
82
83			return this;
84		},
85
86		build: function() {
87			var self = this;
88
89			if($('body').hasClass('loading-overlay-showing')) {
90				$(window).on('loading.overlay.ready', function(){
91					self.animate();
92				});
93			} else {
94				self.animate();
95			}
96
97			return this;
98		},
99
100		animate: function() {
101			var self = this,
102				$el = this.options.wrapper,
103				delay = 0,
104				duration = this.options.duration,
105				elTopDistance = $el.offset().top,
106				windowTopDistance = $(window).scrollTop();
107
108			$el.addClass('appear-animation animated');
109
110			if (!$('html').hasClass('no-csstransitions') && $(window).width() > self.options.minWindowWidth && elTopDistance >= windowTopDistance) {
111
112				$el.appear(function() {
113
114					$el.one('animation:show', function(ev) {
115						delay = ($el.attr('data-appear-animation-delay') ? $el.attr('data-appear-animation-delay') : self.options.delay);
116						duration = ($el.attr('data-appear-animation-duration') ? $el.attr('data-appear-animation-duration') : self.options.duration);
117
118						if (duration != '750ms') {
119							$el.css('animation-duration', duration);
120						}
121
122						$el.css('animation-delay', delay + 'ms');
123
124						$el.addClass($el.attr('data-appear-animation') + ' appear-animation-visible');
125					});
126
127					$el.trigger('animation:show');
128
129				}, {
130					accX: self.options.accX,
131					accY: self.options.accY
132				});
133
134			} else {
135
136				$el.addClass('appear-animation-visible');
137
138			}
139
140			return this;
141		}
142	};
143
144	// expose to scope
145	$.extend(theme, {
146		PluginAnimate: PluginAnimate
147	});
148
149	// jquery plugin
150	$.fn.themePluginAnimate = function(opts) {
151		return this.map(function() {
152			var $this = $(this);
153
154			if ($this.data(instanceName)) {
155				return $this.data(instanceName);
156			} else {
157				return new PluginAnimate($this, opts);
158			}
159
160		});
161	};
162
163}).apply(this, [window.theme, jQuery]);
164
165// Before / After
166(function(theme, $) {
167
168	theme = theme || {};
169
170	var instanceName = '__beforeafter';
171
172	var PluginBeforeAfter = function($el, opts) {
173		return this.initialize($el, opts);
174	};
175
176	PluginBeforeAfter.defaults = {
177		
178	};
179
180	PluginBeforeAfter.prototype = {
181		initialize: function($el, opts) {
182			this.$el = $el;
183
184			this
185				.setData()
186				.setOptions(opts)
187				.build();
188
189			return this;
190		},
191
192		setData: function() {
193			this.$el.data(instanceName, this);
194
195			return this;
196		},
197
198		setOptions: function(opts) {
199			this.options = $.extend(true, {}, PluginBeforeAfter.defaults, opts, {
200				wrapper: this.$el
201			});
202
203			return this;
204		},
205
206		build: function() {
207
208			if (!($.isFunction($.fn.twentytwenty))) {
209				return this;
210			}
211
212			var self = this;
213
214			self.options.wrapper
215				.twentytwenty(self.options);
216
217			return this;
218
219		}
220	};
221
222	// expose to scope
223	$.extend(theme, {
224		PluginBeforeAfter: PluginBeforeAfter
225	});
226
227	// jquery plugin
228	$.fn.themePluginBeforeAfter = function(opts) {
229		return this.map(function() {
230			var $this = $(this);
231
232			if ($this.data(instanceName)) {
233				return $this.data(instanceName);
234			} else {
235				return new PluginBeforeAfter($this, opts);
236			}
237
238		});
239	}
240
241}).apply(this, [window.theme, jQuery]);
242
243// Carousel

244(function(theme, $) {
245
246	theme = theme || {};
247
248	var instanceName = '__carousel';
249
250	var PluginCarousel = function($el, opts) {
251		return this.initialize($el, opts);
252	};
253
254	PluginCarousel.defaults = {
255		loop: true,
256		responsive: {
257			0: {
258				items: 1
259			},
260			479: {
261				items: 1
262			},
263			768: {
264				items: 2
265			},
266			979: {
267				items: 3
268			},
269			1199: {
270				items: 4
271			}
272		},
273		navText: []
274	};
275
276	PluginCarousel.prototype = {
277		initialize: function($el, opts) {
278			if ($el.data(instanceName)) {
279				return this;
280			}
281
282			this.$el = $el;
283
284			this
285				.setData()
286				.setOptions(opts)
287				.build();
288
289			return this;
290		},
291
292		setData: function() {
293			this.$el.data(instanceName, this);
294
295			return this;
296		},
297
298		setOptions: function(opts) {
299			this.options = $.extend(true, {}, PluginCarousel.defaults, opts, {
300				wrapper: this.$el
301			});
302
303			return this;
304		},
305
306		build: function() {
307			if (!($.isFunction($.fn.owlCarousel))) {
308				return this;
309			}
310
311			var self = this,
312				$el = this.options.wrapper;
313
314			// Add Theme Class
315			$el.addClass('owl-theme');
316
317			// Add Loading
318			$el.addClass('owl-loading');
319
320			// Force RTL according to HTML dir attribute
321			if ($('html').attr('dir') == 'rtl') {
322				this.options = $.extend(true, {}, this.options, {
323					rtl: true
324				});
325			}
326
327			if (this.options.items == 1) {
328				this.options.responsive = {}
329			}
330
331			if (this.options.items > 4) {
332				this.options = $.extend(true, {}, this.options, {
333					responsive: {
334						1199: {
335							items: this.options.items
336						}
337					}
338				});
339			}
340
341			// Auto Height Fixes
342			if (this.options.autoHeight) {
343				var itemsHeight = [];
344
345				$el.find('.owl-item').each(function(){
346					if( $(this).hasClass('active') ) {
347						itemsHeight.push( $(this).height() );
348					}
349				});
350
351				$(window).afterResize(function() {
352					$el.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
353				});
354
355				$(window).on('load', function() {
356					$el.find('.owl-stage-outer').height( Math.max.apply(null, itemsHeight) );
357				});
358			}
359
360			// Initialize OwlCarousel
361			$el.owlCarousel(this.options).addClass('owl-carousel-init');
362
363			// Sync
364			if ($el.attr('data-sync')) {
365				$el.on('change.owl.carousel', function(event) {
366					if (event.namespace && event.property.name === 'position') {
367					    var target = event.relatedTarget.relative(event.property.value, true);
368					    $( $el.data('sync') ).owlCarousel('to', target, 300, true);				        
369				  	}
370				});
371			}
372
373			// Carousel Center Active Item
374			if( $el.hasClass('carousel-center-active-item') ) {
375				var itemsActive    = $el.find('.owl-item.active'),
376					indexCenter    = Math.floor( ($el.find('.owl-item.active').length - 1) / 2 ),

377					itemCenter     = itemsActive.eq(indexCenter);
378
379				itemCenter.addClass('current');
380
381				$el.on('change.owl.carousel', function(event) {
382				  	$el.find('.owl-item').removeClass('current');
383					
384					setTimeout(function(){
385					  	var itemsActive    = $el.find('.owl-item.active'),
386					  		indexCenter    = Math.floor( ($el.find('.owl-item.active').length - 1) / 2 ),
387					  		itemCenter     = itemsActive.eq(indexCenter);
388
389					  	itemCenter.addClass('current');
390					}, 100);
391				});
392
393				// Refresh
394				$el.trigger('refresh.owl.carousel');
395
396			}
397
398			// Remove Loading
399			$el.removeClass('owl-loading');
400
401			// Remove Height
402			$el.css('height', 'auto');
403
404			return this;
405		}
406	};
407
408	// expose to scope
409	$.extend(theme, {
410		PluginCarousel: PluginCarousel
411	});
412
413	// jquery plugin
414	$.fn.themePluginCarousel = function(opts) {
415		return this.map(function() {
416			var $this = $(this);
417
418			if ($this.data(instanceName)) {
419				return $this.data(instanceName);
420			} else {
421				return new PluginCarousel($this, opts);
422			}
423
424		});
425	}
426
427}).apply(this, [window.theme, jQuery]);
428
429// Chart Circular
430(function(theme, $) {
431
432	theme = theme || {};
433
434	var instanceName = '__chartCircular';
435
436	var PluginChartCircular = function($el, opts) {
437		return this.initialize($el, opts);
438	};
439
440	PluginChartCircular.defaults = {
441		accX: 0,
442		accY: -150,
443		delay: 1,
444		barColor: '#0088CC',
445		trackColor: '#f2f2f2',
446		scaleColor: false,
447		scaleLength: 5,
448		lineCap: 'round',
449		lineWidth: 13,
450		size: 175,
451		rotate: 0,
452		animate: ({
453			duration: 2500,
454			enabled: true
455		})
456	};
457
458	PluginChartCircular.prototype = {
459		initialize: function($el, opts) {
460			if ($el.data(instanceName)) {
461				return this;
462			}
463
464			this.$el = $el;
465
466			this
467				.setData()
468				.setOptions(opts)
469				.build();
470
471			return this;
472		},
473
474		setData: function() {
475			this.$el.data(instanceName, this);
476
477			return this;
478		},
479
480		setOptions: function(opts) {
481			this.options = $.extend(true, {}, PluginChartCircular.defaults, opts, {
482				wrapper: this.$el
483			});
484
485			return this;
486		},
487
488		build: function() {
489			if (!($.isFunction($.fn.appear)) || !($.isFunction($.fn.easyPieChart))) {
490				return this;
491			}
492
493			var self = this,
494				$el = this.options.wrapper,
495				value = ($el.attr('data-percent') ? $el.attr('data-percent') : 0),
496				percentEl = $el.find('.percent');
497
498			$.extend(true, self.options, {
499				onStep: function(from, to, currentValue) {
500					percentEl.html(parseInt(currentValue));
501				}
502			});
503
504			$el.attr('data-percent', 0);
505
506			$el.appear(function() {
507
508				$el.easyPieChart(self.options);
509
510				setTimeout(function() {
511
512					$el.data('easyPieChart').update(value);
513					$el.attr('data-percent', value);
514
515				}, self.options.delay);
516
517			}, {
518				accX: self.options.accX,
519				accY: self.options.accY
520			});
521
522			return this;
523		}
524	};
525
526	// expose to scope
527	$.extend(theme, {
528		PluginChartCircular: PluginChartCircular
529	});
530
531	// jquery plugin
532	$.fn.themePluginChartCircular = function(opts) {
533		return this.map(function() {
534			var $this = $(this);
535
536			if ($this.data(instanceName)) {
537				return $this.data(instanceName);
538			} else {
539				return new PluginChartCircular($this, opts);
540			}
541
542		});
543	}
544
545}).apply(this, [window.theme, jQuery]);
546
547// Countdown
548(function(theme, $) {
549
550	theme = theme || {};
551
552	var instanceName = '__countdown';
553
554	var PluginCountdown = function($el, opts) {
555		return this.initialize($el, opts);
556	};
557
558	PluginCountdown.defaults = {
559		date: '2030/06/10 12:00:00',
560		textDay: 'DAY',
561		textHour: 'HRS',
562		textMin: 'MIN',
563		textSec: 'SEC',
564		uppercase: true,
565		numberClass: '',
566		wrapperClass: '',
567		insertHTMLbefore: '',
568		insertHTMLafter: ''
569	};
570
571	PluginCountdown.prototype = {
572		initialize: function($el, opts) {
573			if ($el.data(instanceName)) {
574				return this;
575			}
576
577			this.$el = $el;
578
579			this
580				.setData()
581				.setOptions(opts)
582				.build();
583
584			return this;
585		},
586
587		setData: function() {
588			this.$el.data(instanceName, this);
589
590			return this;
591		},
592
593		setOptions: function(opts) {
594			this.options = $.extend(true, {}, PluginCountdown.defaults, opts, {
595				wrapper: this.$el
596			});
597
598			return this;
599		},
600
601		build: function() {
602			if (!($.isFunction($.fn.countTo))) {
603				return this;
604			}
605
606			var self = this,
607				$el = this.options.wrapper,
608				numberClass = ( self.options.numberClass ) ? ' ' + self.options.numberClass : '',
609				wrapperClass = ( self.options.wrapperClass ) ? ' ' + self.options.wrapperClass : '';
610
611			if( self.options.uppercase ) {
612				$el.countdown(self.options.date).on('update.countdown', function(event) {
613					var $this = $(this).html(event.strftime(self.options.insertHTMLbefore
614						+ '<span class="days'+ wrapperClass +'"><span class="'+ numberClass +'">%D</span> '+ self.options.textDay +'<div class="d-inline text-uppercase">%!d</div></span> '
615						+ '<span class="hours'+ wrapperClass +'"><span class="'+ numberClass +'">%H</span> '+ self.options.textHour +'</span> '
616						+ '<span class="minutes'+ wrapperClass +'"><span class="'+ numberClass +'">%M</span> '+ self.options.textMin +'</span> '
617						+ '<span class="seconds'+ wrapperClass +'"><span class="'+ numberClass +'">%S</span> '+ self.options.textSec +'</span> '
618						+ self.options.insertHTMLafter
619					));
620				});
621			} else {
622				$el.countdown(self.options.date).on('update.countdown', function(event) {
623					var $this = $(this).html(event.strftime(self.options.insertHTMLbefore
624						+ '<span class="days'+ wrapperClass +'"><span class="'+ numberClass +'">%D</span> '+ self.options.textDay +'%!d</span> '
625						+ '<span class="hours'+ wrapperClass +'"><span class="'+ numberClass +'">%H</span> '+ self.options.textHour +'</span> '
626						+ '<span class="minutes'+ wrapperClass +'"><span class="'+ numberClass +'">%M</span> '+ self.options.textMin +'</span> '
627						+ '<span class="seconds'+ wrapperClass +'"><span class="'+ numberClass +'">%S</span> '+ self.options.textSec +'</span> '
628						+ self.options.insertHTMLafter
629					));
630				});
631			}
632
633			return this;
634		}
635	};
636
637	// expose to scope
638	$.extend(theme, {
639		PluginCountdown: PluginCountdown
640	});
641
642	// jquery plugin
643	$.fn.themePluginCountdown = function(opts) {
644		return this.map(function() {
645			var $this = $(this);
646
647			if ($this.data(instanceName)) {
648				return $this.data(instanceName);
649			} else {
650				return new PluginCountdown($this, opts);
651			}
652
653		});
654	}
655
656}).apply(this, [window.theme, jQuery]);
657
658// Counter
659(function(theme, $) {
660
661	theme = theme || {};
662
663	var instanceName = '__counter';
664
665	var PluginCounter = function($el, opts) {
666		return this.initialize($el, opts);
667	};
668
669	PluginCounter.defaults = {
670		accX: 0,
671		accY: 0,
672		speed: 3000,
673		refreshInterval: 100,
674		decimals: 0,
675		onUpdate: null,
676		onComplete: null
677	};
678
679	PluginCounter.prototype = {
680		initialize: function($el, opts) {
681			if ($el.data(instanceName)) {
682				return this;
683			}
684
685			this.$el = $el;
686
687			this
688				.setData()
689				.setOptions(opts)
690				.build();
691
692			return this;
693		},
694
695		setData: function() {
696			this.$el.data(instanceName, this);
697
698			return this;
699		},
700
701		setOptions: function(opts) {
702			this.options = $.extend(true, {}, PluginCounter.defaults, opts, {
703				wrapper: this.$el
704			});
705
706			return this;
707		},
708
709		build: function() {
710			if (!($.isFunction($.fn.countTo))) {
711				return this;
712			}
713
714			var self = this,
715				$el = this.options.wrapper;
716
717			$.extend(self.options, {
718				onComplete: function() {
719					if ($el.data('append')) {
720						$el.html($el.html() + $el.data('append'));
721					}
722
723					if ($el.data('prepend')) {
724						$el.html($el.data('prepend') + $el.html());
725					}
726				}
727			});
728

729			$el.appear(function() {
730
731				$el.countTo(self.options);
732
733			}, {
734				accX: self.options.accX,
735				accY: self.options.accY
736			});
737
738			return this;
739		}
740	};
741
742	// expose to scope
743	$.extend(theme, {
744		PluginCounter: PluginCounter
745	});
746
747	// jquery plugin
748	$.fn.themePluginCounter = function(opts) {
749		return this.map(function() {
750			var $this = $(this);
751
752			if ($this.data(instanceName)) {
753				return $this.data(instanceName);
754			} else {
755				return new PluginCounter($this, opts);
756			}
757
758		});
759	}
760
761}).apply(this, [window.theme, jQuery]);
762
763// Float Element
764(function(theme, $) {
765
766	'use strict';
767
768	theme = theme || {};
769
770	var instanceName = '__floatElement';
771
772	var PluginFloatElement = function($el, opts) {
773		return this.initialize($el, opts);
774	};
775
776	PluginFloatElement.defaults = {
777		startPos: 'top',
778		speed: 3,
779		horizontal: false,
780		transition: false
781	};
782
783	PluginFloatElement.prototype = {
784		initialize: function($el, opts) {
785			if ($el.data(instanceName)) {
786				return this;
787			}
788
789			this.$el = $el;
790
791			this
792				.setData()
793				.setOptions(opts)
794				.build();
795
796			return this;
797		},
798
799		setData: function() {
800			this.$el.data(instanceName, this);
801
802			return this;
803		},
804
805		setOptions: function(opts) {
806			this.options = $.extend(true, {}, PluginFloatElement.defaults, opts, {
807				wrapper: this.$el
808			});
809
810			return this;
811		},
812
813		build: function() {
814			var self = this,
815				$el = this.options.wrapper,
816				$window = $(window),
817				minus;
818
819			if( self.options.style ) {
820				$el.attr('style', self.options.style);
821			}
822
823			if( $window.width() > 767 ) {
824
825				// Set Start Position
826				if( self.options.startPos == 'none' ) {
827					minus = '';
828				} else if( self.options.startPos == 'top' ) {
829					$el.css({
830						top: 0
831					});
832					minus = '';
833				} else {
834					$el.css({
835						bottom: 0
836					});
837					minus = '-';
838				}
839
840				// Set Transition
841				if( self.options.transition ) {
842					$el.css({
843						transition: 'ease transform 500ms'
844					});
845				}
846
847				// First Load
848				self.movement(minus);	
849
850				// Scroll
851				$window.on('scroll', function(){
852					self.movement(minus);				   
853				});
854
855			}
856
857			return this;
858		},
859
860		movement: function(minus) {
861			var self = this,
862				$el = this.options.wrapper,
863				$window = $(window),
864				scrollTop = $window.scrollTop(),
865		    	elementOffset = $el.offset().top,
866		     	currentElementOffset = (elementOffset - scrollTop);
867
868		   	var scrollPercent = 100 * currentElementOffset / ($window.height());
869
870		   	if( $el.visible( true ) ) {
871
872		   		if( !self.options.horizontal ) {
873
874		   			$el.css({
875			   			transform: 'translate3d(0, '+ minus + scrollPercent / self.options.speed +'%, 0)'
876			   		});
877
878		   		} else {
879
880		   			$el.css({
881			   			transform: 'translate3d('+ minus + scrollPercent / self.options.speed +'%, '+ minus + scrollPercent / self.options.speed +'%, 0)'
882			   		});
883
884		   		}
885		   		
886		   	}
887		}
888	};
889
890	// expose to scope
891	$.extend(theme, {
892		PluginFloatElement: PluginFloatElement
893	});
894
895	// jquery plugin
896	$.fn.themePluginFloatElement = function(opts) {
897		return this.map(function() {
898			var $this = $(this);
899
900			if ($this.data(instanceName)) {
901				return $this.data(instanceName);
902			} else {
903				return new PluginFloatElement($this, opts);
904			}
905
906		});
907	}
908
909}).apply(this, [window.theme, jQuery]);
910
911// Icon
912(function(theme, $) {
913
914	'use strict';
915
916	theme = theme || {};
917
918	var instanceName = '__icon';
919
920	var PluginIcon = function($el, opts) {
921		return this.initialize($el, opts);
922	};
923
924	PluginIcon.defaults = {
925		color: '#2388ED',
926		animated: false,
927		delay: 300
928	};
929
930	PluginIcon.prototype = {
931		initialize: function($el, opts) {
932			if ($el.data(instanceName)) {
933				return this;
934			}
935
936			this.$el = $el;
937
938			this
939				.setData()
940				.setOptions(opts)
941				.build();
942
943			return this;
944		},
945
946		setData: function() {
947			this.$el.data(instanceName, this);
948
949			return this;
950		},
951
952		setOptions: function(opts) {
953			this.options = $.extend(true, {}, PluginIcon.defaults, opts, {
954				wrapper: this.$el
955			});
956
957			return this;
958		},
959
960		build: function() {
961			var self  	 = this,
962				$el   	 = this.options.wrapper,
963				color 	 = self.options.color,
964				elTopDistance = $el.offset().top,
965				windowTopDistance = $(window).scrollTop(),
966				duration = ( self.options.animated && !self.options.strokeBased ) ? 200 : 100;
967
968			// Check origin
969			if( window.location.origin === 'file://' ) {
970				$el.css('opacity', 1);
971				return;
972			}
973
974			// Duration
975			if( self.options.duration ) {
976				duration = self.options.duration;
977			}
978
979			// SVG Content
980			var SVGContent = $.get({
981				url: $el.attr('src'), 
982				success: function(data, status, xhr){

983					var iconWrapper = $('<div class="animated-icon">'+ xhr.responseText +'</div>'),
984						uniqid = 'icon_' + Math.floor(Math.random() * 26) + Date.now();
985
986					iconWrapper.find('svg').attr('id', uniqid);
987
988					if( $el.attr('width') ) {
989						iconWrapper.find('svg')
990							.attr('width', $el.attr('width'))
991							.attr('height', $el.attr('width'));						
992					}
993
994					$el.replaceWith(iconWrapper);
995
996					$el = iconWrapper;
997
998					var icon = new Vivus(uniqid, {start: 'manual', type: 'sync', selfDestroy: true, duration: duration, onReady: function(obj){
999						var styleElement = document.createElementNS("http://www.w3.org/2000/svg", "style"),
1000							animateStyle = '';
1001
1002						// SVG Fill Based
1003						if( self.options.animated && !self.options.strokeBased || !self.options.animated && color && !self.options.strokeBased ) {
1004							animateStyle = 'stroke-width: 0.1px; fill-opacity: 0; transition: ease fill-opacity 300ms;';
1005							
1006							// Set Style on SVG inside object
1007							styleElement.textContent = '#' + uniqid + ' path, #' + uniqid + ' line, #' + uniqid + ' rect, #' + uniqid + ' circle, #' + uniqid + ' polyline { fill: '+ color +'; stroke: '+ color +'; '+ animateStyle + (self.options.svgStyle ? self.options.svgStyle : "") + ' } .finished path { fill-opacity: 1; }';
1008							obj.el.appendChild(styleElement);
1009						}
1010
1011						// SVG Stroke Based
1012						if( self.options.animated && self.options.strokeBased || !self.options.animated && color && self.options.strokeBased ) {
1013
1014							// Set Style on SVG inside object
1015							styleElement.textContent = '#' + uniqid + ' path, #' + uniqid + ' line, #' + uniqid + ' rect, #' + uniqid + ' circle, #' + uniqid + ' polyline { stroke: '+ color +'; ' + (self.options.svgStyle ? self.options.svgStyle : "") + '}';
1016							obj.el.appendChild(styleElement);
1017						}
1018
1019						$.event.trigger('theme.plugin.icon.svg.ready');
1020					}});
1021
1022					// Isn't animated
1023					if( !self.options.animated ) {
1024						setTimeout(function(){
1025							icon.finish();
1026						}, 10);
1027						$el.css({ opacity: 1 });
1028					}
1029
1030					// Animated
1031					if( self.options.animated && $(window).width() > 767 ) {
1032						// First Load
1033						if( $el.visible( true ) ) {
1034							self.startIconAnimation( icon, $el );
1035						} else if( elTopDistance < windowTopDistance ) {
1036							self.startIconAnimation( icon, $el );
1037						}
1038
1039						// On Scroll
1040						$(window).on('scroll', function(){
1041							if( $el.visible( true ) ) {
1042								self.startIconAnimation( icon, $el );
1043							}
1044						});
1045
1046					} else {
1047						
1048						$el.css({ opacity: 1 });
1049						icon.finish();
1050						
1051						$(window).on('theme.plugin.icon.svg.ready', function(){
1052							setTimeout(function(){
1053								icon.el.setAttribute('class', 'finished');
1054								icon.finish();
1055							}, 300);
1056						});
1057						
1058					}
1059
1060				}
1061			});
1062
1063			return this;
1064		},
1065		startIconAnimation: function(icon, $el) {
1066			var self = this;
1067
1068			// Animate for better performance
1069			$({to:0}).animate({to:1}, ((self.options.strokeBased) ? self.options.delay : self.options.delay + 300 ), function() {
1070				$el.css({ opacity: 1 });
1071			});
1072
1073			$({to:0}).animate({to:1}, self.options.delay, function() {
1074				icon.play(1);
1075
1076				setTimeout(function(){
1077					icon.el.setAttribute('class', 'finished');
1078				}, icon.duration * 5 );
1079			});
1080		}
1081	};
1082
1083	// expose to scope
1084	$.extend(theme, {
1085		PluginIcon: PluginIcon
1086	});
1087
1088	// jquery plugin
1089	$.fn.themePluginIcon = function(opts) {
1090		return this.map(function() {
1091			var $this = $(this);
1092
1093			if ($this.data(instanceName)) {
1094				return $this.data(instanceName);
1095			} else {
1096				return new PluginIcon($this, opts);
1097			}
1098
1099		});
1100	};
1101
1102}).apply(this, [window.theme, jQuery]);
1103
1104// Lazy Load
1105(function(theme, $) {
1106
1107	theme = theme || {};
1108
1109	var instanceName = '__lazyload';
1110
1111	var PluginLazyLoad = function($el, opts) {
1112		return this.initialize($el, opts);
1113	};
1114
1115	PluginLazyLoad.defaults = {
1116		effect: 'show',
1117		appearEffect: '',
1118		imgFluid: true,
1119		appear: function(elements_left, settings) {
1120			
1121		},
1122		load: function(elements_left, settings) {
1123			$(this).addClass($.trim('lazy-load-loaded ' + settings.appearEffect)).css({
1124				'animation-duration': '1s'
1125			});
1126		}
1127	};
1128
1129	PluginLazyLoad.prototype = {
1130		initialize: function($el, opts) {
1131			if ($el.data(instanceName)) {
1132				return this;
1133			}
1134
1135			this.$el = $el;
1136
1137			this
1138				.setData()
1139				.setOptions(opts)
1140				.build()
1141				.events();
1142
1143			return this;
1144		},
1145
1146		setData: function() {
1147			this.$el.data(instanceName, this);
1148
1149			return this;
1150		},
1151
1152		setOptions: function(opts) {
1153			this.options = $.extend(true, {}, PluginLazyLoad.defaults, opts, {
1154				wrapper: this.$el
1155			});
1156
1157			return this;
1158		},
1159
1160		build: function() {
1161			if (!($.isFunction($.fn.lazyload))) {
1162				return this;
1163			}
1164
1165			var self = this;
1166
1167			self.options.wrapper.lazyload(this.options);
1168
1169			return this;
1170		},
1171
1172		events: function() {
1173			var self = this;
1174
1175			if( self.options.imgFluid && self.options.wrapper.is('img') ) {
1176				self.options.wrapper.on('appear', function(){
1177					setTimeout(function(){
1178						self.options.wrapper.addClass('img-fluid');
1179					}, 500);
1180				});
1181			}
1182
1183			return this;
1184		}
1185	};
1186
1187	// expose to scope
1188	$.extend(theme, {
1189		PluginLazyLoad: PluginLazyLoad
1190	});
1191
1192	// jquery plugin
1193	$.fn.themePluginLazyLoad = function(opts) {
1194		return this.map(function() {
1195			var $this = $(this);
1196
1197			if ($this.data(instanceName)) {
1198				return $this.data(instanceName);
1199			} else {
1200				return new PluginLazyLoad($this, opts);
1201			}
1202
1203		});
1204	}
1205
1206}).apply(this, [window.theme, jQuery]);
1207
1208// Lightbox
1209(function(theme, $) {
1210
1211	theme = theme || {};
1212
1213	var instanceName = '__lightbox';
1214
1215	var PluginLightbox = function($el, opts) {
1216		return this.initialize($el, opts);
1217	};
1218
1219	PluginLightbox.defaults = {
1220		tClose: 'Close (Esc)', // Alt text on close button
1221		tLoading: 'Loading...', // Text that is displayed during loading. Can contain %curr% and %total% keys
1222		gallery: {
1223			tPrev: 'Previous (Left arrow key)', // Alt text on left arrow
1224			tNext: 'Next (Right arrow key)', // Alt text on right arrow
1225			tCounter: '%curr% of %total%' // Markup for "1 of 7" counter
1226		},
1227		image: {
1228			tError: '<a href="%url%">The image</a> could not be loaded.' // Error message when image could not be loaded
1229		},
1230		ajax: {
1231			tError: '<a href="%url%">The content</a> could not be loaded.' // Error message when ajax request failed
1232		},
1233		callbacks: {
1234			open: function() {
1235				$('html').addClass('lightbox-opened');
1236			},
1237			close: function() {
1238				$('html').removeClass('lightbox-opened');
1239			}
1240		}
1241	};
1242
1243	PluginLightbox.prototype = {
1244		initialize: function($el, opts) {
1245			if ($el.data(instanceName)) {
1246				return this;
1247			}
1248
1249			this.$el = $el;
1250
1251			this
1252				.setData()
1253				.setOptions(opts)
1254				.build();
1255
1256			return this;
1257		},
1258
1259		setData: function() {
1260			this.$el.data(instanceName, this);
1261
1262			return this;
1263		},
1264
1265		setOptions: function(opts) {
1266			this.options = $.extend(true, {}, PluginLightbox.defaults, opts, {
1267				wrapper: this.$el
1268			});
1269
1270			return this;
1271		},
1272
1273		build: function() {
1274			if (!($.isFunction($.fn.magnificPopup))) {
1275				return this;
1276			}
1277
1278			this.options.wrapper.magnificPopup(this.options);
1279
1280			return this;
1281		}
1282	};
1283
1284	// expose to scope
1285	$.extend(theme, {
1286		PluginLightbox: PluginLightbox
1287	});
1288
1289	// jquery plugin
1290	$.fn.themePluginLightbox = function(opts) {
1291		return this.map(function() {
1292			var $this = $(this);
1293
1294			if ($this.data(instanceName)) {
1295				return $this.data(instanceName);
1296			} else {
1297				return new PluginLightbox($this, opts);
1298			}
1299
1300		});
1301	}
1302
1303}).apply(this, [window.theme, jQuery]);
1304
1305// Loading Overlay
1306(function(theme, $) {
1307
1308	'use strict';
1309
1310	theme = theme || {};
1311
1312	var loadingOverlayTemplate = [
1313		'<div class="loading-overlay">',
1314			'<div class="bounce-loader"><div class="bounce1"></div><div class="bounce2"></div><div class="bounce3"></div></div>',
1315		'</div>'
1316	].join('');
1317
1318	var LoadingOverlay = function( $wrapper, options ) {
1319		return this.initialize( $wrapper, options );
1320	};
1321
1322	LoadingOverlay.prototype = {
1323
1324		options: {
1325			css: {},
1326			hideDelay: 500
1327		},
1328
1329		initialize: function( $wrapper, options ) {
1330			this.$wrapper = $wrapper;
1331
1332			this
1333				.setVars()
1334				.setOptions( options )
1335				.build()
1336				.events();
1337
1338			this.$wrapper.data( 'loadingOverlay', this );
1339		},
1340
1341		setVars: function() {

1342			this.$overlay = this.$wrapper.find('.loading-overlay');
1343
1344			return this;
1345		},
1346
1347		setOptions: function( options ) {
1348			if ( !this.$overlay.get(0) ) {
1349				this.matchProperties();
1350			}
1351			this.options     = $.extend( true, {}, this.options, options, theme.fn.getOptions(this.$wrapper.data('plugin-options')) );
1352
1353			this.loaderClass = this.getLoaderClass( this.options.css.backgroundColor );
1354
1355			return this;
1356		},
1357
1358		build: function() {
1359			if ( !this.$overlay.closest(document.documentElement).get(0) ) {
1360				if ( !this.$cachedOverlay ) {
1361					this.$overlay = $( loadingOverlayTemplate ).clone();
1362
1363					if ( this.options.css ) {
1364						this.$overlay.css( this.options.css );
1365						this.$overlay.find( '.loader' ).addClass( this.loaderClass );
1366					}
1367				} else {
1368					this.$overlay = this.$cachedOverlay.clone();
1369				}
1370
1371				this.$wrapper.append( this.$overlay );
1372			}
1373
1374			if ( !this.$cachedOverlay ) {
1375				this.$cachedOverlay = this.$overlay.clone();
1376			}
1377
1378			return this;
1379		},
1380
1381		events: function() {
1382			var _self = this;
1383
1384			if ( this.options.startShowing ) {
1385				_self.show();
1386			}
1387
1388			if ( this.$wrapper.is('body') || this.options.hideOnWindowLoad ) {
1389				$( window ).on( 'load error', function() {
1390					_self.hide();
1391				});
1392			}
1393
1394			if ( this.options.listenOn ) {
1395				$( this.options.listenOn )
1396					.on( 'loading-overlay:show beforeSend.ic', function( e ) {
1397						e.stopPropagation();
1398						_self.show();
1399					})
1400					.on( 'loading-overlay:hide complete.ic', function( e ) {
1401						e.stopPropagation();
1402						_self.hide();
1403					});
1404			}
1405
1406			this.$wrapper
1407				.on( 'loading-overlay:show beforeSend.ic', function( e ) {
1408					if ( e.target === _self.$wrapper.get(0) ) {
1409						e.stopPropagation();
1410						_self.show();
1411						return true;
1412					}
1413					return false;
1414				})
1415				.on( 'loading-overlay:hide complete.ic', function( e ) {
1416					if ( e.target === _self.$wrapper.get(0) ) {
1417						e.stopPropagation();
1418						_self.hide();
1419						return true;
1420					}
1421					return false;
1422				});
1423
1424			return this;
1425		},
1426
1427		show: function() {
1428			this.build();
1429
1430			this.position = this.$wrapper.css( 'position' ).toLowerCase();
1431			if ( this.position != 'relative' || this.position != 'absolute' || this.position != 'fixed' ) {
1432				this.$wrapper.css({
1433					position: 'relative'
1434				});
1435			}
1436			this.$wrapper.addClass( 'loading-overlay-showing' );
1437		},
1438
1439		hide: function() {
1440			var _self = this;
1441
1442			setTimeout(function() {
1443				_self.$wrapper.removeClass( 'loading-overlay-showing' );
1444				
1445				if ( this.position != 'relative' || this.position != 'absolute' || this.position != 'fixed' ) {
1446					_self.$wrapper.css({ position: '' });
1447				}
1448
1449				$(window).trigger('loading.overlay.ready');
1450			}, _self.options.hideDelay);
1451		},
1452
1453		matchProperties: function() {
1454			var i,
1455				l,
1456				properties;
1457
1458			properties = [
1459				'backgroundColor',
1460				'borderRadius'
1461			];
1462
1463			l = properties.length;
1464
1465			for( i = 0; i < l; i++ ) {
1466				var obj = {};
1467				obj[ properties[ i ] ] = this.$wrapper.css( properties[ i ] );
1468
1469				$.extend( this.options.css, obj );
1470			}
1471		},
1472
1473		getLoaderClass: function( backgroundColor ) {
1474			if ( !backgroundColor || backgroundColor === 'transparent' || backgroundColor === 'inherit' ) {
1475				return 'black';
1476			}
1477
1478			var hexColor,
1479				r,
1480				g,
1481				b,
1482				yiq;
1483
1484			var colorToHex = function( color ){
1485				var hex,
1486					rgb;
1487
1488				if( color.indexOf('#') >- 1 ){
1489					hex = color.replace('#', '');
1490				} else {
1491					rgb = color.match(/\d+/g);
1492					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);
1493				}
1494
1495				if ( hex.length === 3 ) {
1496					hex = hex + hex;
1497				}
1498
1499				return hex;
1500			};
1501
1502			hexColor = colorToHex( backgroundColor );
1503
1504			r = parseInt( hexColor.substr( 0, 2), 16 );
1505			g = parseInt( hexColor.substr( 2, 2), 16 );
1506			b = parseInt( hexColor.substr( 4, 2), 16 );
1507			yiq = ((r * 299) + (g * 587) + (b * 114)) / 1000;
1508
1509			return ( yiq >= 128 ) ? 'black' : 'white';
1510		}
1511
1512	};
1513
1514	// expose to scope
1515	$.extend(theme, {
1516		LoadingOverlay: LoadingOverlay
1517	});
1518
1519	// expose as a jquery plugin
1520	$.fn.loadingOverlay = function( opts ) {
1521		return this.each(function() {
1522			var $this = $( this );
1523
1524			var loadingOverlay = $this.data( 'loadingOverlay' );
1525			if ( loadingOverlay ) {
1526				return loadingOverlay;
1527			} else {
1528				var options = opts || $this.data( 'loading-overlay-options' ) || {};
1529				return new LoadingOverlay( $this, options );
1530			}
1531		});
1532	}
1533
1534	// auto init
1535	$('[data-loading-overlay]').loadingOverlay();
1536
1537}).apply(this, [window.theme, jQuery]);
1538
1539// Masonry
1540(function(theme, $) {
1541
1542	theme = theme || {};
1543
1544	var instanceName = '__masonry';
1545
1546	var PluginMasonry = function($el, opts) {
1547		return this.initialize($el, opts);
1548	};
1549
1550	PluginMasonry.defaults = {
1551
1552	};
1553
1554	PluginMasonry.prototype = {
1555		initialize: function($el, opts) {
1556			if ($el.data(instanceName)) {
1557				return this;
1558			}
1559
1560			this.$el = $el;
1561
1562			this
1563				.setData()
1564				.setOptions(opts)
1565				.build();
1566
1567			return this;
1568		},
1569
1570		setData: function() {
1571			this.$el.data(instanceName, this);
1572
1573			return this;
1574		},
1575
1576		setOptions: function(opts) {
1577			this.options = $.extend(true, {}, PluginMasonry.defaults, opts, {
1578				wrapper: this.$el
1579			});
1580
1581			return this;
1582		},
1583
1584		build: function() {
1585			if (!($.isFunction($.fn.isotope))) {
1586				return this;
1587			}
1588
1589			var self = this,
1590				$window = $(window);
1591
1592			self.$loader = false;

1593
1594			if (self.options.wrapper.parents('.masonry-loader').get(0)) {
1595				self.$loader = self.options.wrapper.parents('.masonry-loader');
1596				self.createLoader();
1597			}
1598
1599			self.options.wrapper.one('layoutComplete', function(event, laidOutItems) {
1600				self.removeLoader();
1601			});
1602
1603			self.options.wrapper.waitForImages(function() {
1604				self.options.wrapper.isotope(self.options);	
1605			});
1606
1607			// IE10/11 fix
1608			if( $('html').hasClass('ie10') || $('html').hasClass('ie11') ) {
1609				var padding = parseInt( self.options.wrapper.children().css('padding-left') ) + parseInt( self.options.wrapper.children().css('padding-right') );
1610			}
1611
1612			$(window).on('resize', function() {
1613				setTimeout(function() {
1614					self.options.wrapper.isotope('layout');
1615				}, 300);
1616			});
1617
1618			setTimeout(function() {
1619				self.removeLoader();
1620			}, 3000);
1621
1622			return this;
1623		},
1624
1625		createLoader: function() {
1626			var self = this;
1627
1628			var loaderTemplate = [
1629				'<div class="bounce-loader">',
1630					'<div class="bounce1"></div>',
1631					'<div class="bounce2"></div>',
1632					'<div class="bounce3"></div>',
1633				'</div>'
1634			].join('');
1635
1636			self.$loader.append(loaderTemplate);
1637
1638			return this;
1639		},
1640
1641		removeLoader: function() {
1642
1643			var self = this;
1644
1645			if (self.$loader) {
1646
1647				self.$loader.removeClass('masonry-loader-showing');
1648
1649				setTimeout(function() {
1650					self.$loader.addClass('masonry-loader-loaded');
1651				}, 300);
1652
1653			}
1654
1655		}
1656	};
1657
1658	// expose to scope
1659	$.extend(theme, {
1660		PluginMasonry: PluginMasonry
1661	});
1662
1663	// jquery plugin
1664	$.fn.themePluginMasonry = function(opts) {
1665		return this.map(function() {
1666			var $this = $(this);
1667
1668			if ($this.data(instanceName)) {
1669				return $this.data(instanceName);
1670			} else {
1671				return new PluginMasonry($this, opts);
1672			}
1673
1674		});
1675	}
1676
1677}).apply(this, [window.theme, jQuery]);
1678
1679// Match Height
1680(function(theme, $) {
1681
1682	theme = theme || {};
1683
1684	var instanceName = '__matchHeight';
1685
1686	var PluginMatchHeight = function($el, opts) {
1687		return this.initialize($el, opts);
1688	};
1689
1690	PluginMatchHeight.defaults = {
1691		byRow: true,
1692		property: 'height',
1693		target: null,
1694		remove: false
1695	};
1696
1697	PluginMatchHeight.prototype = {
1698		initialize: function($el, opts) {
1699			if ($el.data(instanceName)) {
1700				return this;
1701			}
1702
1703			this.$el = $el;
1704
1705			this
1706				.setData()
1707				.setOptions(opts)
1708				.build();
1709
1710			return this;
1711		},
1712
1713		setData: function() {
1714			this.$el.data(instanceName, this);
1715
1716			return this;
1717		},
1718
1719		setOptions: function(opts) {
1720			this.options = $.extend(true, {}, PluginMatchHeight.defaults, opts, {
1721				wrapper: this.$el
1722			});
1723
1724			return this;
1725		},
1726
1727		build: function() {
1728			if (!($.isFunction($.fn.matchHeight))) {
1729				return this;
1730			}
1731
1732			var self = this;
1733
1734			self.options.wrapper.matchHeight(self.options);
1735
1736			return this;
1737		}
1738
1739	};
1740
1741	// expose to scope
1742	$.extend(theme, {
1743		PluginMatchHeight: PluginMatchHeight
1744	});
1745
1746	// jquery plugin
1747	$.fn.themePluginMatchHeight = function(opts) {
1748		return this.map(function() {
1749			var $this = $(this);
1750
1751			if ($this.data(instanceName)) {
1752				return $this.data(instanceName);
1753			} else {
1754				return new PluginMatchHeight($this, opts);
1755			}
1756
1757		});
1758	}
1759
1760}).apply(this, [window.theme, jQuery]);
1761
1762// Parallax
1763(function(theme, $) {
1764
1765	theme = theme || {};
1766
1767	var instanceName = '__parallax';
1768
1769	var PluginParallax = function($el, opts) {
1770		return this.initialize($el, opts);
1771	};
1772
1773	PluginParallax.defaults = {
1774		speed: 1.5,
1775		horizontalPosition: '50%',
1776		offset: 0,
1777		parallaxHeight: '180%'
1778	};
1779
1780	PluginParallax.prototype = {
1781		initialize: function($el, opts) {
1782			if ($el.data(instanceName)) {
1783				return this;
1784			}
1785
1786			this.$el = $el;
1787
1788			this
1789				.setData()
1790				.setOptions(opts)
1791				.build();
1792
1793			return this;
1794		},
1795
1796		setData: function() {
1797			this.$el.data(instanceName, this);
1798
1799			return this;
1800		},
1801
1802		setOptions: function(opts) {
1803			this.options = $.extend(true, {}, PluginParallax.defaults, opts, {
1804				wrapper: this.$el
1805			});
1806
1807			return this;
1808		},
1809
1810		build: function() {
1811			var self = this,
1812				$window = $(window),
1813				offset,
1814				yPos,
1815				bgpos,
1816				background;
1817
1818			// Create Parallax Element
1819			background = $('<div class="parallax-background"></div>');
1820
1821			// Set Style for Parallax Element
1822			background.css({
1823				'background-image' : 'url(' + self.options.wrapper.data('image-src') + ')',
1824				'background-size' : 'cover',
1825				'position' : 'absolute',
1826				'top' : 0,
1827				'left' : 0,
1828				'width' : '100%',
1829				'height' : self.options.parallaxHeight
1830			});
1831
1832			// Add Parallax Element on DOM
1833			self.options.wrapper.prepend(background);
1834
1835			// Set Overlfow Hidden and Position Relative to Parallax Wrapper
1836			self.options.wrapper.css({
1837				'position' : 'relative',
1838				'overflow' : 'hidden'
1839			});
1840
1841			// Parallax Effect on Scroll & Resize
1842			var parallaxEffectOnScrolResize = function() {
1843				$window.on('scroll resize', function() {
1844					offset  = self.options.wrapper.offset();
1845					yPos    = -($window.scrollTop() - (offset.top - 100)) / ((self.options.speed + 2 ));
1846					plxPos  = (yPos < 0) ? Math.abs(yPos) : -Math.abs(yPos);
1847					background.css({
1848						'transform' : 'translate3d(0, '+ ( (plxPos - 50) + (self.options.offset) ) +'px, 0)',
1849						'background-position-x' : self.options.horizontalPosition
1850					});
1851				});
1852
1853				$window.trigger('scroll');
1854			}
1855
1856			if (!$.browser.mobile) {
1857				parallaxEffectOnScrolResize();
1858			} else {
1859				if( self.options.enableOnMobile == true ) {
1860					parallaxEffectOnScrolResize();
1861				} else {
1862					self.options.wrapper.addClass('parallax-disabled');
1863				}
1864			}
1865
1866			return this;
1867		}
1868	};
1869
1870	// expose to scope
1871	$.extend(theme, {
1872		PluginParallax: PluginParallax
1873	});
1874
1875	// jquery plugin
1876	$.fn.themePluginParallax = function(opts) {
1877		return this.map(function() {
1878			var $this = $(this);
1879
1880			if ($this.data(instanceName)) {
1881				return $this.data(instanceName);
1882			} else {
1883				return new PluginParallax($this, opts);
1884			}
1885
1886		});
1887	}
1888
1889}).apply(this, [window.theme, jQuery]);
1890
1891// Progress Bar
1892(function(theme, $) {
1893
1894	theme = theme || {};
1895
1896	var instanceName = '__progressBar';
1897
1898	var PluginProgressBar = function($el, opts) {
1899		return this.initialize($el, opts);
1900	};
1901
1902	PluginProgressBar.defaults = {
1903		accX: 0,
1904		accY: -50,
1905		delay: 1
1906	};
1907
1908	PluginProgressBar.prototype = {
1909		initialize: function($el, opts) {
1910			if ($el.data(instanceName)) {
1911				return this;
1912			}
1913
1914			this.$el = $el;
1915
1916			this
1917				.setData()
1918				.setOptions(opts)
1919				.build();
1920
1921			return this;
1922		},
1923
1924		setData: function() {
1925			this.$el.data(instanceName, this);
1926
1927			return this;
1928		},
1929
1930		setOptions: function(opts) {
1931			this.options = $.extend(true, {}, PluginProgressBar.defaults, opts, {
1932				wrapper: this.$el
1933			});
1934
1935			return this;
1936		},
1937
1938		build: function() {
1939			if (!($.isFunction($.fn.appear))) {
1940				return this;
1941			}
1942
1943			var self = this,
1944				$el = this.options.wrapper,

1945				delay = 1;
1946
1947			$el.appear(function() {
1948
1949				delay = ($el.attr('data-appear-animation-delay') ? $el.attr('data-appear-animation-delay') : self.options.delay);
1950
1951				$el.addClass($el.attr('data-appear-animation'));
1952
1953				setTimeout(function() {
1954
1955					$el.animate({
1956						width: $el.attr('data-appear-progress-animation')
1957					}, 1500, 'easeOutQuad', function() {
1958						$el.find('.progress-bar-tooltip').animate({
1959							opacity: 1
1960						}, 500, 'easeOutQuad');
1961					});
1962
1963				}, delay);
1964
1965			}, {
1966				accX: self.options.accX,
1967				accY: self.options.accY
1968			});
1969
1970			return this;
1971		}
1972	};
1973
1974	// expose to scope
1975	$.extend(theme, {
1976		PluginProgressBar: PluginProgressBar
1977	});
1978
1979	// jquery plugin
1980	$.fn.themePluginProgressBar = function(opts) {
1981		return this.map(function() {
1982			var $this = $(this);
1983
1984			if ($this.data(instanceName)) {
1985				return $this.data(instanceName);
1986			} else {
1987				return new PluginProgressBar($this, opts);
1988			}
1989
1990		});
1991	}
1992
1993}).apply(this, [window.theme, jQuery]);
1994
1995// Revolution Slider
1996(function(theme, $) {
1997
1998	theme = theme || {};
1999
2000	var instanceName = '__revolution';
2001
2002	var PluginRevolutionSlider = function($el, opts) {
2003		return this.initialize($el, opts);
2004	};
2005
2006	PluginRevolutionSlider.defaults = {
2007		sliderType: 'standard',
2008		sliderLayout: 'fullwidth',
2009		delay: 9000,
2010		gridwidth: 1170,
2011		gridheight: 500,
2012		spinner: 'spinner3',
2013		disableProgressBar: 'on',
2014		parallax: {
2015			type: 'off',
2016			bgparallax: 'off'
2017		},
2018		navigation: {
2019			keyboardNavigation: 'off',
2020			keyboard_direction: 'horizontal',
2021			mouseScrollNavigation: 'off',
2022			onHoverStop: 'off',
2023			touch: {
2024				touchenabled: 'on',
2025				swipe_threshold: 75,
2026				swipe_min_touches: 1,
2027				swipe_direction: 'horizontal',
2028				drag_block_vertical: false
2029			},
2030			arrows: {
2031				enable: true,
2032				hide_onmobile: false,
2033				hide_under: 0,
2034				hide_onleave: true,
2035				hide_delay: 200,
2036				hide_delay_mobile: 1200,
2037				left: {
2038					h_align: 'left',
2039					v_align: 'center',
2040					h_offset: 30,
2041					v_offset: 0
2042				},
2043				right: {
2044					h_align: 'right',
2045					v_align: 'center',
2046					h_offset: 30,
2047					v_offset: 0
2048				}
2049			}
2050		},
2051
2052		/* ADDONS */
2053	    addOnTypewriter: {
2054			enable: false
2055		},
2056		addOnWhiteboard: {
2057			enable: false,
2058
2059		},
2060	    whiteboard: {
2061	        movehand: {
2062	            src: '../vendor/rs-plugin/revolution-addons/whiteboard/assets/images/hand_point_right.png',
2063	            width: 400,
2064	            height: 1000,
2065	            handtype: 'right',
2066	            transform: {
2067	                transformX: 50,
2068	                transformY: 50
2069	            },
2070	            jittering: {
2071	                distance: '80',
2072	                distance_horizontal: '100',
2073	                repeat: '5',
2074	                offset: '10',
2075	                offset_horizontal: '0'
2076	            },
2077	            rotation: {
2078	                angle: '10',
2079	                repeat: '3'
2080	            }
2081	        },
2082	        writehand: {
2083	            src: '../vendor/rs-plugin/revolution-addons/whiteboard/assets/images/write_right_angle.png',
2084	            width: 572,
2085	            height: 691,
2086	            handtype: 'right',
2087	            transform: {
2088	                transformX: 50,
2089	                transformY: 50
2090	            },
2091	            jittering: {
2092	                distance: '80',
2093	                distance_horizontal: '100',
2094	                repeat: '5',
2095	                offset: '10',
2096	                offset_horizontal: '0'
2097	            },
2098	            rotation:{
2099	                angle: '10',
2100	                repeat: '3'
2101	            }
2102	        }
2103	    },
2104	    addOnParticles: {
2105	    	enable: false
2106	    },
2107	    particles: {
2108			startSlide: "first", 
2109			endSlide: "last", 
2110			zIndex: "1",
2111			particles: {
2112				number: {value: 80}, color: {value: "#ffffff"},
2113				shape: {
2114					type: "circle", stroke: {width: 0, color: "#ffffff", opacity: 1},
2115					image: {src: ""}
2116				},
2117				opacity: {value: 0.5, random: true, min: 0.25, anim: {enable: false, speed: 3, opacity_min: 0, sync: false}},
2118				size: {value: 2, random: false, min: 30, anim: {enable: false, speed: 40, size_min: 1, sync: false}},
2119				line_linked: {enable: true, distance: 150, color: "#ffffff", opacity: 0.4, width: 1},

2120				move: {enable: true, speed: 6, direction: "none", random: true, min_speed: 6, straight: false, out_mode: "out"}
2121			},
2122			interactivity: {
2123				events: {onhover: {enable: false, mode: "repulse"}, onclick: {enable: false, mode: "repulse"}},
2124				modes: {grab: {distance: 400, line_linked: {opacity: 0.5}}, bubble: {distance: 400, size: 40, opacity: 0.4}, repulse: {distance: 200}}
2125			}
2126		},
2127		addOnCountdown: {
2128			enable: false,
2129			targetdate: new Date().getTime() + 864000000, // http://www.freeformatter.com/epoch-timestamp-to-date-converter.html
2130			slidechanges: [{days: 0, hours: 0, minutes: 0, seconds: 0, slide: 2}]
2131		},
2132		addOnSlicey: {
2133			enable: false
2134		},
2135		addOnFilmstrip: {
2136			enable: false
2137		},
2138		addOnBeforeAfter : {
2139			enable: false,
2140			options: {
2141				cursor: "move",
2142			    carousel: false,
2143			    arrowStyles: {
2144			        leftIcon: "fa-icon-caret-left",
2145			        rightIcon: "fa-icon-caret-right",
2146			        topIcon: "fa-icon-caret-up",
2147			        bottomIcon: "fa-icon-caret-down",
2148			        size: "35",
2149			        color: "#ffffff",
2150			        spacing: "10",
2151			        bgColor: "transparent",
2152			        padding: "0",
2153			        borderRadius: "0"
2154			    },
2155			    dividerStyles: {
2156			        width: "1",
2157			        color: "rgba(255, 255, 255, 0.5)"
2158			    }
2159			}
2160		},
2161		addOnPanorama: {
2162			enable: false
2163		},
2164		addOnRevealer: {
2165			enable: false,
2166		},
2167		revealer: {
2168			direction: "open_horizontal",
2169			color: "#ffffff",
2170			duration: "1500",
2171			delay: "0",
2172			easing: "Power2.easeInOut",
2173			overlay_enabled: true,
2174			overlay_color: "#000000",
2175			overlay_duration: "1500",
2176			overlay_delay: "0",
2177			overlay_easing: "Power2.easeInOut",
2178			spinner: "1",
2179			spinnerColor: "#006dd2",
2180			spinnerHtml: "<div class='rsaddon-revealer-spinner rsaddon-revealer-spinner-1'><div class='rsaddon-revealer-1'><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><span style='background: {{color}}'><\/span><\/div><\/div \/>"
2181		},
2182		addOnDuotone: {
2183			enable: false
2184		},
2185		addOnBubblemorph: {
2186			enable: false
2187		},
2188		addOnDistortion: {
2189			enable: false
2190		}
2191		
2192	};
2193
2194	PluginRevolutionSlider.prototype = {
2195		initialize: function($el, opts) {
2196			if ($el.data(instanceName)) {
2197				return this;
2198			}
2199
2200			this.$el = $el;
2201
2202			this
2203				.setData()
2204				.setOptions(opts)
2205				.build()
2206				.events();
2207
2208			return this;
2209		},
2210
2211		setData: function() {
2212			this.$el.data(instanceName, this);
2213
2214			return this;
2215		},
2216
2217		setOptions: function(opts) {
2218			this.options = $.extend(true, {}, PluginRevolutionSlider.defaults, opts, {
2219				wrapper: this.$el
2220			});
2221
2222			return this;
2223		},
2224
2225		build: function() {
2226			if (!($.isFunction($.fn.revolution))) {
2227				return this;
2228			}
2229
2230			// Single Slider Class
2231			if(this.options.wrapper.find('> ul > li').length == 1) {
2232				this.options.wrapper.addClass('slider-single-slide');
2233
2234				// Remove Bullets
2235				// this.options.navigation.bullets.enable = false;
2236				$.extend(this.options.navigation, {
2237					bullets: {
2238						enable: false
2239					}
2240				});
2241
2242			}
2243
2244			// Full Screen Class
2245			if(this.options.sliderLayout == 'fullscreen') {
2246				this.options.wrapper.closest('.slider-container').addClass('fullscreen-slider');
2247			}
2248			
2249			// Initialize Revolution Slider
2250			this.options.wrapper.revolution(this.options);
2251
2252			// Addon Init - Typewriter
2253			if(this.options.addOnTypewriter.enable) {
2254				RsTypewriterAddOn($, this.options.wrapper);
2255			}
2256
2257			// Addon Init - Whiteboard
2258			if(this.options.addOnWhiteboard.enable) {
2259				this.options.wrapper.rsWhiteBoard();
2260			}
2261
2262			// Addon Init - Particles
2263			if(this.options.addOnParticles.enable) {
2264				RsParticlesAddOn(this.options.wrapper);
2265			}
2266
2267			// Addon Init - Countdown
2268			if(this.options.addOnCountdown.enable) {
2269				tp_countdown(this.options.wrapper, this.options.addOnCountdown.targetdate, this.options.addOnCountdown.slidechanges);
2270			}
2271
2272			// Addon Init - Slicey
2273			if(this.options.addOnSlicey.enable) {
2274				this.options.wrapper.revSliderSlicey();
2275			}
2276
2277			// Addon Init - Filmstrip
2278			if(this.options.addOnFilmstrip.enable) {
2279				RsFilmstripAddOn($, this.options.wrapper, '../vendor/rs-plugin/revolution-addons/filmstrip/', false);
2280			}
2281
2282			// Addon Init - Before After

2283			if(this.options.addOnBeforeAfter.enable) {
2284				RevSliderBeforeAfter($, this.options.wrapper, this.options.addOnBeforeAfter.options);
2285			}
2286
2287			// Addon Init - Panorama
2288			if(this.options.addOnPanorama.enable) {
2289				RsAddonPanorama($, this.options.wrapper);
2290			}
2291
2292			// Addon Init - Revealer
2293			if(this.options.addOnRevealer.enable) {
2294				RsRevealerAddOn($, this.options.wrapper, this.options.revealer.spinnerHtml);
2295			}
2296
2297			// Addon Init - Duotone
2298			if(this.options.addOnDuotone.enable) {
2299				RsAddonDuotone($, this.options.wrapper, true, "cubic-bezier(0.645, 0.045, 0.355, 1.000)", "1000");
2300			}
2301
2302			// Addon Init - Bubblemorph
2303			if(this.options.addOnBubblemorph.enable) {
2304				BubbleMorphAddOn($, this.options.wrapper, false);
2305			}
2306
2307			// Addon Init - Distortion
2308			if(this.options.addOnDistortion.enable) {
2309				RsLiquideffectAddOn($, this.options.wrapper);
2310			}
2311
2312			return this;
2313		},
2314
2315		events: function() {
2316
2317			return this;
2318		}
2319	};
2320
2321	// expose to scope
2322	$.extend(theme, {
2323		PluginRevolutionSlider: PluginRevolutionSlider
2324	});
2325
2326	// jquery plugin
2327	$.fn.themePluginRevolutionSlider = function(opts) {
2328		return this.map(function() {
2329			var $this = $(this);
2330
2331			if ($this.data(instanceName)) {
2332				return $this.data(instanceName);
2333			} else {
2334				return new PluginRevolutionSlider($this, opts);
2335			}
2336
2337		});
2338	}
2339
2340}).apply(this, [window.theme, jQuery]);
2341
2342// Scroll to Top
2343(function(theme, $) {
2344
2345	theme = theme || {};
2346
2347	$.extend(theme, {
2348
2349		PluginScrollToTop: {
2350
2351			defaults: {
2352				wrapper: $('body'),
2353				offset: 150,
2354				buttonClass: 'scroll-to-top',
2355				iconClass: 'fas fa-chevron-up',
2356				delay: 1000,
2357				visibleMobile: false,
2358				label: false,
2359				easing: 'easeOutBack'
2360			},
2361
2362			initialize: function(opts) {
2363				initialized = true;
2364
2365				// Don't initialize if the page has Section Scroll
2366				if( $('body[data-plugin-section-scroll]').get(0) ) {
2367					return;
2368				}
2369
2370				this
2371					.setOptions(opts)
2372					.build()
2373					.events();
2374
2375				return this;
2376			},
2377
2378			setOptions: function(opts) {
2379				this.options = $.extend(true, {}, this.defaults, opts);
2380
2381				return this;
2382			},
2383
2384			build: function() {
2385				var self = this,
2386					$el;
2387
2388				// Base HTML Markup
2389				$el = $('<a />')
2390					.addClass(self.options.buttonClass)
2391					.attr({
2392						'href': '#',
2393					})
2394					.append(
2395						$('<i />')
2396						.addClass(self.options.iconClass)
2397				);
2398
2399				// Visible Mobile
2400				if (!self.options.visibleMobile) {
2401					$el.addClass('hidden-mobile');
2402				}
2403
2404				// Label
2405				if (self.options.label) {
2406					$el.append(
2407						$('<span />').html(self.options.label)
2408					);
2409				}
2410
2411				this.options.wrapper.append($el);
2412
2413				this.$el = $el;
2414
2415				return this;
2416			},
2417
2418			events: function() {
2419				var self = this,
2420					_isScrolling = false;
2421
2422				// Click Element Action
2423				self.$el.on('click', function(e) {
2424					e.preventDefault();
2425					$('body, html').animate({
2426						scrollTop: 0
2427					}, self.options.delay, self.options.easing);
2428					return false;
2429				});
2430
2431				// Show/Hide Button on Window Scroll event.
2432				$(window).scroll(function() {
2433
2434					if (!_isScrolling) {
2435
2436						_isScrolling = true;
2437
2438						if ($(window).scrollTop() > self.options.offset) {
2439
2440							self.$el.stop(true, true).addClass('visible');
2441							_isScrolling = false;
2442
2443						} else {
2444
2445							self.$el.stop(true, true).removeClass('visible');
2446							_isScrolling = false;
2447
2448						}
2449
2450					}
2451
2452				});
2453
2454				return this;
2455			}
2456
2457		}
2458
2459	});
2460
2461}).apply(this, [window.theme, jQuery]);
2462
2463// Scrollable
2464(function(theme, $) {
2465
2466	theme = theme || {};
2467
2468	var instanceName = '__scrollable';
2469
2470	var PluginScrollable = function($el, opts) {
2471		return this.initialize($el, opts);
2472	};
2473
2474	PluginScrollable.updateModals = function() {
2475		PluginScrollable.updateBootstrapModal();
2476	};
2477
2478	PluginScrollable.updateBootstrapModal = function() {
2479		var updateBoostrapModal;
2480
2481		updateBoostrapModal = typeof $.fn.modal !== 'undefined';
2482		updateBoostrapModal = updateBoostrapModal && typeof $.fn.modal.Constructor !== 'undefined';
2483		updateBoostrapModal = updateBoostrapModal && typeof $.fn.modal.Constructor.prototype !== 'undefined';
2484		updateBoostrapModal = updateBoostrapModal && typeof $.fn.modal.Constructor.prototype.enforceFocus !== 'undefined';
2485
2486		if ( !updateBoostrapModal ) {
2487			return false;

2488		}
2489
2490		var originalFocus = $.fn.modal.Constructor.prototype.enforceFocus;
2491		$.fn.modal.Constructor.prototype.enforceFocus = function() {
2492			originalFocus.apply( this );
2493
2494			var $scrollable = this.$element.find('.scrollable');
2495			if ( $scrollable ) {
2496				if ( $.isFunction($.fn['themePluginScrollable'])  ) {
2497					$scrollable.themePluginScrollable();
2498				}
2499
2500				if ( $.isFunction($.fn['nanoScroller']) ) {
2501					$scrollable.nanoScroller();
2502				}
2503			}
2504		};
2505	};
2506
2507	PluginScrollable.defaults = {
2508		contentClass: 'scrollable-content',
2509		paneClass: 'scrollable-pane',
2510		sliderClass: 'scrollable-slider',
2511		alwaysVisible: true,
2512		preventPageScrolling: true
2513	};
2514
2515	PluginScrollable.prototype = {
2516		initialize: function($el, opts) {
2517			if ( $el.data( instanceName ) ) {
2518				return this;
2519			}
2520
2521			this.$el = $el;
2522
2523			this
2524				.setData()
2525				.setOptions(opts)
2526				.build();
2527
2528			return this;
2529		},
2530
2531		setData: function() {
2532			this.$el.data(instanceName, this);
2533
2534			return this;
2535		},
2536
2537		setOptions: function(opts) {
2538			this.options = $.extend(true, {}, PluginScrollable.defaults, opts, {
2539				wrapper: this.$el
2540			});
2541
2542			return this;
2543		},
2544
2545		build: function() {
2546			this.options.wrapper.nanoScroller(this.options);
2547
2548			return this;
2549		}
2550	};
2551
2552	// expose to scope
2553	$.extend(theme, {
2554		PluginScrollable: PluginScrollable
2555	});
2556
2557	// jquery plugin
2558	$.fn.themePluginScrollable = function(opts) {
2559		return this.each(function() {
2560			var $this = $(this);
2561
2562			if ($this.data(instanceName)) {
2563				return $this.data(instanceName);
2564			} else {
2565				return new PluginScrollable($this, opts);
2566			}
2567
2568		});
2569	};
2570
2571	$(function() {
2572		PluginScrollable.updateModals();
2573	});
2574
2575}).apply(this, [window.theme, jQuery]);
2576
2577// Section Scroll
2578(function(theme, $) {
2579
2580	theme = theme || {};
2581
2582	var instanceName = '__sectionScroll';
2583
2584	var PluginSectionScroll = function($el, opts) {
2585		return this.initialize($el, opts);
2586	};
2587
2588	PluginSectionScroll.defaults = {
2589		targetClass: '.section',
2590		dotsNav: true,
2591		changeHeaderLogo: true,
2592		headerLogoDark: 'img/logo-default-slim.png',
2593		headerLogoLight: 'img/logo-default-slim-dark.png'
2594	};
2595
2596	PluginSectionScroll.prototype = {
2597		initialize: function($el, opts) {
2598			if ($el.data(instanceName)) {
2599				return this;
2600			}
2601
2602			this.$el = $el;
2603
2604			this
2605				.setData()
2606				.setOptions(opts)
2607				.build()
2608				.events();
2609
2610			return this;
2611		},
2612
2613		setData: function() {
2614			this.$el.data(instanceName, this);
2615
2616			return this;
2617		},
2618
2619		setOptions: function(opts) {
2620			this.options = $.extend(true, {}, PluginSectionScroll.defaults, opts, {
2621				wrapper: this.$el
2622			});
2623
2624			return this;
2625		},
2626
2627		build: function() {
2628			var self = this,
2629				$el = this.options.wrapper;
2630
2631			// Check type of header and change the target for header (by change header color purpose)
2632			if( $('html').hasClass('side-header-overlay-full-screen') ) {
2633				self.$header = $('.sticky-wrapper');
2634			} else {
2635				self.$header = $('#header');
2636			}
2637
2638			// Turn the section full height or not depeding on the content size
2639			self.updateSectionsHeight();
2640
2641			// Wrap all sections in a section wrapper
2642			$( this.options.targetClass ).wrap('<div class="section-wrapper"></div>');
2643
2644			// Set the section wrapper height
2645	  		$('.section-wrapper').each(function(){
2646	  			$(this).height( $(this).find('.section-scroll').outerHeight() );
2647	  		});
2648
2649	  		// Add active class to the first section on page load
2650	  		$('.section-wrapper').first().addClass('active');
2651			
2652	        var	flag = false,
2653	            scrollableFlag = false,
2654	        	touchDirection = '',
2655	        	touchstartY = 0,
2656	        	touchendY = 0;
2657
2658	        $(window).on('touchstart', function(event) {
2659			    touchstartY = event.changedTouches[0].screenY;
2660			});
2661
2662	        var wheelEvent = 'onwheel' in document ? 'wheel' : document.onmousewheel !== undefined ? 'mousewheel' : 'DOMMouseScroll';
2663	        if( $(window).width() < 992 && $('html').hasClass('touch') ) {
2664	        	wheelEvent = 'onwheel' in document ? 'wheel touchend' : document.onmousewheel !== undefined ? 'mousewheel touchend' : 'DOMMouseScroll touchend';
2665	        }
2666
2667	        $(window).on(wheelEvent, function(e){
2668	        	if( $(window).width() < 992 && $('html').hasClass('touch') ) {
2669		        	if( $(e.target).closest('.section-scroll-dots-navigation').get(0) || $(e.target).closest('.header-body').get(0) || $(e.target).closest('.owl-carousel').get(0) ) {
2670		        		return;
2671		        	}
2672		        }
2673
2674		        // Side Header Overlay Full Screen
2675		        if( $('html.side-header-overlay-full-screen.side-header-hide').get(0) ) {
2676		        	return;
2677		        }
2678
2679	        	var wheelDirection = e.originalEvent.wheelDelta == undefined ? e.originalEvent.deltaY > 0 : e.originalEvent.wheelDelta < 0;
2680	        	if( $(window).width() < 992 && $('html').hasClass('touch') ) {
2681		        	touchendY = event.changedTouches[0].screenY;
2682	        		
2683				    if( touchendY <= touchstartY ) {
2684				    	touchDirection = 'up';
2685				    }
2686
2687				    if( touchendY >= touchstartY ) {
2688				    	touchDirection = 'down';
2689				    }
2690
2691				    if( touchendY == touchstartY ) {
2692				    	return;
2693				    }
2694	        	}
2695
2696	        	var $currentSection = $('.section-wrapper').eq( self.getCurrentIndex() ).find('.section-scroll'),
2697            		$nextSection = self.getNextSection(wheelDirection, touchDirection),
2698            		nextSectionOffsetTop;
2699
2700            	// If is the last section, then change the offsetTop value