https://kplt.in.ua/wp-content/themes/universe_theme/core/js/plugins.js?ver=5.2.21

557' + slider.vars.prevText + '</a></li><li><a class="' + namespace + 'next" href="#">' + slider.vars.nextText + '</a></li></ul>');
558
559          // CONTROLSCONTAINER:
560          if (slider.controlsContainer) {
561            $(slider.controlsContainer).append(directionNavScaffold);
562            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider.controlsContainer);
563          } else {
564            slider.append(directionNavScaffold);
565            slider.directionNav = $('.' + namespace + 'direction-nav li a', slider);
566          }
567
568          methods.directionNav.update();
569
570          slider.directionNav.bind(eventType, function(event) {
571            event.preventDefault();
572            var target;
573
574            if (watchedEvent === "" || watchedEvent === event.type) {
575              target = ($(this).hasClass(namespace + 'next')) ? slider.getTarget('next') : slider.getTarget('prev');
576              slider.flexAnimate(target, slider.vars.pauseOnAction);
577            }
578
579            // setup flags to prevent event duplication
580            if (watchedEvent === "") {
581              watchedEvent = event.type;
582            }
583            methods.setToClearWatchedEvent();
584          });
585        },
586        update: function() {
587          var disabledClass = namespace + 'disabled';
588          if (slider.pagingCount === 1) {
589            slider.directionNav.addClass(disabledClass).attr('tabindex', '-1');
590          } else if (!slider.vars.animationLoop) {
591            if (slider.animatingTo === 0) {
592              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "prev").addClass(disabledClass).attr('tabindex', '-1');
593            } else if (slider.animatingTo === slider.last) {
594              slider.directionNav.removeClass(disabledClass).filter('.' + namespace + "next").addClass(disabledClass).attr('tabindex', '-1');
595            } else {
596              slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
597            }
598          } else {
599            slider.directionNav.removeClass(disabledClass).removeAttr('tabindex');
600          }
601        }
602      },
603      pausePlay: {
604        setup: function() {
605          var pausePlayScaffold = $('<div class="' + namespace + 'pauseplay"><a></a></div>');
606
607          // CONTROLSCONTAINER:
608          if (slider.controlsContainer) {
609            slider.controlsContainer.append(pausePlayScaffold);
610            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider.controlsContainer);
611          } else {
612            slider.append(pausePlayScaffold);
613            slider.pausePlay = $('.' + namespace + 'pauseplay a', slider);
614          }
615
616          methods.pausePlay.update((slider.vars.slideshow) ? namespace + 'pause' : namespace + 'play');
617
618          slider.pausePlay.bind(eventType, function(event) {
619            event.preventDefault();
620
621            if (watchedEvent === "" || watchedEvent === event.type) {
622              if ($(this).hasClass(namespace + 'pause')) {
623                slider.manualPause = true;
624                slider.manualPlay = false;
625                slider.pause();
626              } else {
627                slider.manualPause = false;
628                slider.manualPlay = true;
629                slider.play();
630              }
631            }
632
633            // setup flags to prevent event duplication
634            if (watchedEvent === "") {
635              watchedEvent = event.type;
636            }
637            methods.setToClearWatchedEvent();
638          });
639        },
640        update: function(state) {
641          (state === "play") ? slider.pausePlay.removeClass(namespace + 'pause').addClass(namespace + 'play').html(slider.vars.playText) : slider.pausePlay.removeClass(namespace + 'play').addClass(namespace + 'pause').html(slider.vars.pauseText);
642        }
643      },
644      touch: function() {
645        var startX,
646          startY,
647          offset,
648          cwidth,
649          dx,
650          startT,
651          scrolling = false,
652          localX = 0,
653          localY = 0,
654          accDx = 0;
655
656        if(!msGesture){
657            el.addEventListener('touchstart', onTouchStart, false);
658
659            function onTouchStart(e) {
660              if (slider.animating) {
661                e.preventDefault();
662              } else if ( ( window.navigator.msPointerEnabled ) || e.touches.length === 1 ) {
663                slider.pause();
664                // CAROUSEL:
665                cwidth = (vertical) ? slider.h : slider. w;
666                startT = Number(new Date());
667                // CAROUSEL:
668
669                // Local vars for X and Y points.
670                localX = e.touches[0].pageX;
671                localY = e.touches[0].pageY;
672
673                offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
674                         (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
675                         (carousel && slider.currentSlide === slider.last) ? slider.limit :
676                         (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
677                         (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
678                startX = (vertical) ? localY : localX;
679                startY = (vertical) ? localX : localY;
680
681                el.addEventListener('touchmove', onTouchMove, false);
682                el.addEventListener('touchend', onTouchEnd, false);
683              }
684            }
685
686            function onTouchMove(e) {
687              // Local vars for X and Y points.
688
689              localX = e.touches[0].pageX;
690              localY = e.touches[0].pageY;
691
692              dx = (vertical) ? startX - localY : startX - localX;
693              scrolling = (vertical) ? (Math.abs(dx) < Math.abs(localX - startY)) : (Math.abs(dx) < Math.abs(localY - startY));
694
695              var fxms = 500;
696
697              if ( ! scrolling || Number( new Date() ) - startT > fxms ) {
698                e.preventDefault();
699                if (!fade && slider.transitions) {
700                  if (!slider.vars.animationLoop) {
701                    dx = dx/((slider.currentSlide === 0 && dx < 0 || slider.currentSlide === slider.last && dx > 0) ? (Math.abs(dx)/cwidth+2) : 1);
702                  }
703                  slider.setProps(offset + dx, "setTouch");
704                }
705              }
706            }
707
708            function onTouchEnd(e) {
709              // finish the touch by undoing the touch session
710              el.removeEventListener('touchmove', onTouchMove, false);
711
712              if (slider.animatingTo === slider.currentSlide && !scrolling && !(dx === null)) {
713                var updateDx = (reverse) ? -dx : dx,
714                    target = (updateDx > 0) ? slider.getTarget('next') : slider.getTarget('prev');
715
716                if (slider.canAdvance(target) && (Number(new Date()) - startT < 550 && Math.abs(updateDx) > 50 || Math.abs(updateDx) > cwidth/2)) {
717                  slider.flexAnimate(target, slider.vars.pauseOnAction);
718                } else {
719                  if (!fade) slider.flexAnimate(slider.currentSlide, slider.vars.pauseOnAction, true);
720                }
721              }
722              el.removeEventListener('touchend', onTouchEnd, false);
723
724              startX = null;
725              startY = null;
726              dx = null;
727              offset = null;
728            }
729        }else{
730            el.style.msTouchAction = "none";
731            el._gesture = new MSGesture();
732            el._gesture.target = el;
733            el.addEventListener("MSPointerDown", onMSPointerDown, false);
734            el._slider = slider;
735            el.addEventListener("MSGestureChange", onMSGestureChange, false);
736            el.addEventListener("MSGestureEnd", onMSGestureEnd, false);
737
738            function onMSPointerDown(e){
739                e.stopPropagation();
740                if (slider.animating) {
741                    e.preventDefault();
742                }else{
743                    slider.pause();
744                    el._gesture.addPointer(e.pointerId);
745                    accDx = 0;
746                    cwidth = (vertical) ? slider.h : slider. w;
747                    startT = Number(new Date());
748                    // CAROUSEL:
749
750                    offset = (carousel && reverse && slider.animatingTo === slider.last) ? 0 :
751                        (carousel && reverse) ? slider.limit - (((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.animatingTo) :
752                            (carousel && slider.currentSlide === slider.last) ? slider.limit :
753                                (carousel) ? ((slider.itemW + slider.vars.itemMargin) * slider.move) * slider.currentSlide :
754                                    (reverse) ? (slider.last - slider.currentSlide + slider.cloneOffset) * cwidth : (slider.currentSlide + slider.cloneOffset) * cwidth;
755                }
756            }
757
758            function onMSGestureChange(e) {
759                e.stopPropagation();
760                var slider = e.target._slider;

1173      slider.w = (slider.viewport===undefined) ? slider.width() : slider.viewport.width();
1174      slider.h = slide.height();
1175      slider.boxPadding = slide.outerWidth() - slide.width();
1176
1177      // CAROUSEL:
1178      if (carousel) {
1179        slider.itemT = slider.vars.itemWidth + slideMargin;
1180        slider.minW = (minItems) ? minItems * slider.itemT : slider.w;
1181        slider.maxW = (maxItems) ? (maxItems * slider.itemT) - slideMargin : slider.w;
1182        slider.itemW = (slider.minW > slider.w) ? (slider.w - (slideMargin * (minItems - 1)))/minItems :
1183                       (slider.maxW < slider.w) ? (slider.w - (slideMargin * (maxItems - 1)))/maxItems :
1184                       (slider.vars.itemWidth > slider.w) ? slider.w : slider.vars.itemWidth;
1185
1186        slider.visible = Math.floor(slider.w/(slider.itemW));
1187        slider.move = (slider.vars.move > 0 && slider.vars.move < slider.visible ) ? slider.vars.move : slider.visible;
1188        slider.pagingCount = Math.ceil(((slider.count - slider.visible)/slider.move) + 1);
1189        slider.last =  slider.pagingCount - 1;
1190        slider.limit = (slider.pagingCount === 1) ? 0 :
1191                       (slider.vars.itemWidth > slider.w) ? (slider.itemW * (slider.count - 1)) + (slideMargin * (slider.count - 1)) : ((slider.itemW + slideMargin) * slider.count) - slider.w - slideMargin;
1192      } else {
1193        slider.itemW = slider.w;
1194        slider.pagingCount = slider.count;
1195        slider.last = slider.count - 1;
1196      }
1197      slider.computedW = slider.itemW - slider.boxPadding;
1198    }
1199
1200
1201    slider.update = function(pos, action) {
1202      slider.doMath();
1203
1204      // update currentSlide and slider.animatingTo if necessary
1205      if (!carousel) {
1206        if (pos < slider.currentSlide) {
1207          slider.currentSlide += 1;
1208        } else if (pos <= slider.currentSlide && pos !== 0) {
1209          slider.currentSlide -= 1;
1210        }
1211        slider.animatingTo = slider.currentSlide;
1212      }
1213
1214      // update controlNav
1215      if (slider.vars.controlNav && !slider.manualControls) {
1216        if ((action === "add" && !carousel) || slider.pagingCount > slider.controlNav.length) {
1217          methods.controlNav.update("add");
1218        } else if ((action === "remove" && !carousel) || slider.pagingCount < slider.controlNav.length) {
1219          if (carousel && slider.currentSlide > slider.last) {
1220            slider.currentSlide -= 1;
1221            slider.animatingTo -= 1;
1222          }
1223          methods.controlNav.update("remove", slider.last);
1224        }
1225      }
1226      // update directionNav
1227      if (slider.vars.directionNav) methods.directionNav.update();
1228
1229    }
1230
1231    slider.addSlide = function(obj, pos) {
1232      var $obj = $(obj);
1233
1234      slider.count += 1;
1235      slider.last = slider.count - 1;
1236
1237      // append new slide
1238      if (vertical && reverse) {
1239        (pos !== undefined) ? slider.slides.eq(slider.count - pos).after($obj) : slider.container.prepend($obj);
1240      } else {
1241        (pos !== undefined) ? slider.slides.eq(pos).before($obj) : slider.container.append($obj);
1242      }
1243
1244      // update currentSlide, animatingTo, controlNav, and directionNav
1245      slider.update(pos, "add");
1246
1247      // update slider.slides
1248      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1249      // re-setup the slider to accomdate new slide
1250      slider.setup();
1251
1252      //FlexSlider: added() Callback
1253      slider.vars.added(slider);
1254    }
1255    slider.removeSlide = function(obj) {
1256      var pos = (isNaN(obj)) ? slider.slides.index($(obj)) : obj;
1257
1258      // update count
1259      slider.count -= 1;
1260      slider.last = slider.count - 1;
1261
1262      // remove slide
1263      if (isNaN(obj)) {
1264        $(obj, slider.slides).remove();
1265      } else {
1266        (vertical && reverse) ? slider.slides.eq(slider.last).remove() : slider.slides.eq(obj).remove();
1267      }
1268
1269      // update currentSlide, animatingTo, controlNav, and directionNav
1270      slider.doMath();
1271      slider.update(pos, "remove");
1272
1273      // update slider.slides
1274      slider.slides = $(slider.vars.selector + ':not(.clone)', slider);
1275      // re-setup the slider to accomdate new slide
1276      slider.setup();
1277
1278      // FlexSlider: removed() Callback
1279      slider.vars.removed(slider);
1280    }
1281
1282    //FlexSlider: Initialize
1283    methods.init();
1284  }
1285
1286  // Ensure the slider isn't focussed if the window loses focus.
1287  $( window ).blur( function ( e ) {
1288    focused = false;
1289  }).focus( function ( e ) {
1290    focused = true;
1291  });
1292
1293  //FlexSlider: Default Settings
1294  $.flexslider.defaults = {
1295    namespace: "flex-",             //{NEW} String: Prefix string attached to the class of every element generated by the plugin
1296    selector: ".slides > li",       //{NEW} Selector: Must match a simple pattern. '{container} > {slide}' -- Ignore pattern at your own peril
1297    animation: "fade",              //String: Select your animation type, "fade" or "slide"
1298    easing: "swing",                //{NEW} String: Determines the easing method used in jQuery transitions. jQuery easing plugin is supported!
1299    direction: "horizontal",        //String: Select the sliding direction, "horizontal" or "vertical"
1300    reverse: false,                 //{NEW} Boolean: Reverse the animation direction
1301    animationLoop: true,            //Boolean: Should the animation loop? If false, directionNav will received "disable" classes at either end
1302    smoothHeight: false,            //{NEW} Boolean: Allow height of the slider to animate smoothly in horizontal mode
1303    startAt: 0,                     //Integer: The slide that the slider should start on. Array notation (0 = first slide)
1304    slideshow: true,                //Boolean: Animate slider automatically
1305    slideshowSpeed: 7000,           //Integer: Set the speed of the slideshow cycling, in milliseconds
1306    animationSpeed: 600,            //Integer: Set the speed of animations, in milliseconds
1307    initDelay: 0,                   //{NEW} Integer: Set an initialization delay, in milliseconds
1308    randomize: false,               //Boolean: Randomize slide order
1309    thumbCaptions: false,           //Boolean: Whether or not to put captions on thumbnails when using the "thumbnails" controlNav.
1310
1311    // Usability features
1312    pauseOnAction: true,            //Boolean: Pause the slideshow when interacting with control elements, highly recommended.
1313    pauseOnHover: false,            //Boolean: Pause the slideshow when hovering over slider, then resume when no longer hovering
1314    pauseInvisible: true,   		//{NEW} Boolean: Pause the slideshow when tab is invisible, resume when visible. Provides better UX, lower CPU usage.
1315    useCSS: true,                   //{NEW} Boolean: Slider will use CSS3 transitions if available
1316    touch: true,                    //{NEW} Boolean: Allow touch swipe navigation of the slider on touch-enabled devices
1317    video: false,                   //{NEW} Boolean: If using video in the slider, will prevent CSS3 3D Transforms to avoid graphical glitches
1318
1319    // Primary Controls
1320    controlNav: true,               //Boolean: Create navigation for paging control of each clide? Note: Leave true for manualControls usage
1321    directionNav: true,             //Boolean: Create navigation for previous/next navigation? (true/false)
1322    prevText: "Previous",           //String: Set the text for the "previous" directionNav item
1323    nextText: "Next",               //String: Set the text for the "next" directionNav item
1324
1325    // Secondary Navigation
1326    keyboard: true,                 //Boolean: Allow slider navigating via keyboard left/right keys
1327    multipleKeyboard: false,        //{NEW} Boolean: Allow keyboard navigation to affect multiple sliders. Default behavior cuts out keyboard navigation with more than one slider present.
1328    mousewheel: false,              //{UPDATED} Boolean: Requires jquery.mousewheel.js (https://github.com/brandonaaron/jquery-mousewheel) - Allows slider navigating via mousewheel

1721		},
1722		isScrollable = function(el) {
1723			return (el && !(el.style.overflow && el.style.overflow === 'hidden') && ((el.clientWidth && el.scrollWidth > el.clientWidth) || (el.clientHeight && el.scrollHeight > el.clientHeight)));
1724		},
1725		getScalar = function(orig, dim) {
1726			var value = parseInt(orig, 10) || 0;
1727
1728			if (dim && isPercentage(orig)) {
1729				value = F.getViewport()[ dim ] / 100 * value;
1730			}
1731
1732			return Math.ceil(value);
1733		},
1734		getValue = function(value, dim) {
1735			return getScalar(value, dim) + 'px';
1736		};
1737
1738	$.extend(F, {
1739		// The current version of fancyBox
1740		version: '2.1.5',
1741
1742		defaults: {
1743			padding : 15,
1744			margin  : 20,
1745
1746			width     : 800,
1747			height    : 600,
1748			minWidth  : 100,
1749			minHeight : 100,
1750			maxWidth  : 9999,
1751			maxHeight : 9999,
1752			pixelRatio: 1, // Set to 2 for retina display support
1753
1754			autoSize   : true,
1755			autoHeight : false,
1756			autoWidth  : false,
1757
1758			autoResize  : true,
1759			autoCenter  : !isTouch,
1760			fitToView   : true,
1761			aspectRatio : false,
1762			topRatio    : 0.5,
1763			leftRatio   : 0.5,
1764
1765			scrolling : 'auto', // 'auto', 'yes' or 'no'
1766			wrapCSS   : '',
1767
1768			arrows     : true,
1769			closeBtn   : true,
1770			closeClick : false,
1771			nextClick  : false,
1772			mouseWheel : true,
1773			autoPlay   : false,
1774			playSpeed  : 3000,
1775			preload    : 3,
1776			modal      : false,
1777			loop       : true,
1778
1779			ajax  : {
1780				dataType : 'html',
1781				headers  : { 'X-fancyBox': true }
1782			},
1783			iframe : {
1784				scrolling : 'auto',
1785				preload   : true
1786			},
1787			swf : {
1788				wmode: 'transparent',
1789				allowfullscreen   : 'true',
1790				allowscriptaccess : 'always'
1791			},
1792
1793			keys  : {
1794				next : {
1795					13 : 'left', // enter
1796					34 : 'up',   // page down
1797					39 : 'left', // right arrow
1798					40 : 'up'    // down arrow
1799				},
1800				prev : {
1801					8  : 'right',  // backspace
1802					33 : 'down',   // page up
1803					37 : 'right',  // left arrow
1804					38 : 'down'    // up arrow
1805				},
1806				close  : [27], // escape key
1807				play   : [32], // space - start/stop slideshow
1808				toggle : [70]  // letter "f" - toggle fullscreen
1809			},
1810
1811			direction : {
1812				next : 'left',
1813				prev : 'right'
1814			},
1815
1816			scrollOutside  : true,
1817
1818			// Override some properties
1819			index   : 0,
1820			type    : null,
1821			href    : null,
1822			content : null,
1823			title   : null,
1824
1825			// HTML templates
1826			tpl: {
1827				wrap     : '<div class="fancybox-wrap" tabIndex="-1"><div class="fancybox-skin"><div class="fancybox-outer"><div class="fancybox-inner"></div></div></div></div>',
1828				image    : '<img class="fancybox-image" src="{href}" alt="" />',
1829				iframe   : '<iframe id="fancybox-frame{rnd}" name="fancybox-frame{rnd}" class="fancybox-iframe" frameborder="0" vspace="0" hspace="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen' + (IE ? ' allowtransparency="true"' : '') + '></iframe>',
1830				error    : '<p class="fancybox-error">The requested content cannot be loaded.<br/>Please try again later.</p>',
1831				closeBtn : '<a title="Close" class="fancybox-item fancybox-close" href="javascript:;"></a>',
1832				next     : '<a title="Next" class="fancybox-nav fancybox-next" href="javascript:;"><span></span></a>',
1833				prev     : '<a title="Previous" class="fancybox-nav fancybox-prev" href="javascript:;"><span></span></a>'
1834			},
1835
1836			// Properties for each animation type
1837			// Opening fancyBox
1838			openEffect  : 'fade', // 'elastic', 'fade' or 'none'
1839			openSpeed   : 250,
1840			openEasing  : 'swing',
1841			openOpacity : true,
1842			openMethod  : 'zoomIn',
1843
1844			// Closing fancyBox
1845			closeEffect  : 'fade', // 'elastic', 'fade' or 'none'
1846			closeSpeed   : 250,
1847			closeEasing  : 'swing',
1848			closeOpacity : true,
1849			closeMethod  : 'zoomOut',
1850
1851			// Changing next gallery item
1852			nextEffect : 'elastic', // 'elastic', 'fade' or 'none'
1853			nextSpeed  : 250,
1854			nextEasing : 'swing',
1855			nextMethod : 'changeIn',
1856
1857			// Changing previous gallery item
1858			prevEffect : 'elastic', // 'elastic', 'fade' or 'none'
1859			prevSpeed  : 250,
1860			prevEasing : 'swing',
1861			prevMethod : 'changeOut',
1862
1863			// Enable default helpers
1864			helpers : {
1865				overlay : true,
1866				title   : true
1867			},
1868
1869			// Callbacks
1870			onCancel     : $.noop, // If canceling
1871			beforeLoad   : $.noop, // Before loading
1872			afterLoad    : $.noop, // After loading
1873			beforeShow   : $.noop, // Before changing in current item
1874			afterShow    : $.noop, // After opening
1875			beforeChange : $.noop, // Before changing gallery item
1876			beforeClose  : $.noop, // Before closing
1877			afterClose   : $.noop  // After closing
1878		},
1879
1880		//Current state
1881		group    : {}, // Selected group
1882		opts     : {}, // Group options
1883		previous : null,  // Previous element
1884		coming   : null,  // Element being loaded
1885		current  : null,  // Currently loaded element
1886		isActive : false, // Is activated
1887		isOpen   : false, // Is currently open
1888		isOpened : false, // Have been fully opened at least once
1889
1890		wrap  : null,
1891		skin  : null,
1892		outer : null,
1893		inner : null,
1894
1895		player : {
1896			timer    : null,
1897			isActive : false
1898		},
1899
1900		// Loaders
1901		ajaxLoad   : null,
1902		imgPreload : null,
1903
1904		// Some collections
1905		transitions : {},
1906		helpers     : {},
1907
1908		/*
1909		 *	Static methods
1910		 */
1911
1912		open: function (group, opts) {
1913			if (!group) {
1914				return;
1915			}
1916
1917			if (!$.isPlainObject(opts)) {
1918				opts = {};
1919			}
1920
1921			// Close if already active
1922			if (false === F.close(true)) {
1923				return;
1924			}
1925
1926			// Normalize group
1927			if (!$.isArray(group)) {
1928				group = isQuery(group) ? $(group).get() : [group];
1929			}
1930
1931			// Recheck if the type of each element is `object` and set content type (image, ajax, etc)
1932			$.each(group, function(i, element) {
1933				var obj = {},
1934					href,
1935					title,
1936					content,
1937					type,
1938					rez,
1939					hrefParts,
1940					selector;
1941
1942				if ($.type(element) === "object") {
1943					// Check if is DOM element
1944					if (element.nodeType) {
1945						element = $(element);
1946					}
1947
1948					if (isQuery(element)) {
1949						obj = {
1950							href    : element.data('fancybox-href') || element.attr('href'),
1951							title   : element.data('fancybox-title') || element.attr('title'),
1952							isDom   : true,
1953							element : element
1954						};
1955
1956						if ($.metadata) {
1957							$.extend(true, obj, element.metadata());
1958						}
1959
1960					} else {
1961						obj = element;
1962					}
1963				}
1964
1965				href  = opts.href  || obj.href || (isString(element) ? element : null);
1966				title = opts.title !== undefined ? opts.title : obj.title || '';
1967
1968				content = opts.content || obj.content;
1969				type    = content ? 'html' : (opts.type  || obj.type);
1970
1971				if (!type && obj.isDom) {
1972					type = element.data('fancybox-type');
1973
1974					if (!type) {
1975						rez  = element.prop('class').match(/fancybox\.(\w+)/);
1976						type = rez ? rez[1] : null;
1977					}
1978				}
1979
1980				if (isString(href)) {
1981					// Try to guess the content type
1982					if (!type) {
1983						if (F.isImage(href)) {
1984							type = 'image';
1985
1986						} else if (F.isSWF(href)) {
1987							type = 'swf';
1988
1989						} else if (href.charAt(0) === '#') {
1990							type = 'inline';
1991
1992						} else if (isString(element)) {
1993							type    = 'html';
1994							content = element;
1995						}
1996					}
1997
1998					// Split url into two pieces with source url and content selector, e.g,
1999					// "/mypage.html #my_id" will load "/mypage.html" and display element having id "my_id"
2000					if (type === 'ajax') {
2001						hrefParts = href.split(/\s+/, 2);
2002						href      = hrefParts.shift();
2003						selector  = hrefParts.shift();
2004					}
2005				}
2006
2007				if (!content) {
2008					if (type === 'inline') {
2009						if (href) {
2010							content = $( isString(href) ? href.replace(/.*(?=#[^\s]+$)/, '') : href ); //strip for ie7
2011
2012						} else if (obj.isDom) {
2013							content = element;
2014						}
2015
2016					} else if (type === 'html') {
2017						content = href;
2018
2019					} else if (!type && !href && obj.isDom) {
2020						type    = 'inline';
2021						content = element;
2022					}
2023				}
2024
2025				$.extend(obj, {
2026					href     : href,
2027					type     : type,
2028					content  : content,
2029					title    : title,
2030					selector : selector
2031				});
2032
2033				group[ i ] = obj;
2034			});
2035
2036			// Extend the defaults
2037			F.opts = $.extend(true, {}, F.defaults, opts);
2038
2039			// All options are merged recursive except keys
2040			if (opts.keys !== undefined) {
2041				F.opts.keys = opts.keys ? $.extend({}, F.defaults.keys, opts.keys) : false;
2042			}
2043
2044			F.group = group;
2045
2046			return F._start(F.opts.index);
2047		},
2048
2049		// Cancel image loading or abort ajax request
2050		cancel: function () {
2051			var coming = F.coming;
2052
2053			if (!coming || false === F.trigger('onCancel')) {
2054				return;
2055			}
2056
2057			F.hideLoading();
2058
2059			if (F.ajaxLoad) {
2060				F.ajaxLoad.abort();
2061			}
2062
2063			F.ajaxLoad = null;
2064
2065			if (F.imgPreload) {
2066				F.imgPreload.onload = F.imgPreload.onerror = null;
2067			}
2068
2069			if (coming.wrap) {
2070				coming.wrap.stop(true, true).trigger('onReset').remove();
2071			}
2072
2073			F.coming = null;
2074
2075			// If the first item has been canceled, then clear everything
2076			if (!F.current) {
2077				F._afterZoomOut( coming );
2078			}
2079		},
2080
2081		// Start closing animation if is open; remove immediately if opening/closing
2082		close: function (event) {
2083			F.cancel();
2084
2085			if (false === F.trigger('beforeClose')) {
2086				return;
2087			}
2088
2089			F.unbindEvents();
2090
2091			if (!F.isActive) {
2092				return;
2093			}
2094
2095			if (!F.isOpen || event === true) {
2096				$('.fancybox-wrap').stop(true).trigger('onReset').remove();
2097
2098				F._afterZoomOut();
2099
2100			} else {
2101				F.isOpen = F.isOpened = false;
2102				F.isClosing = true;
2103
2104				$('.fancybox-item, .fancybox-nav').remove();
2105
2106				F.wrap.stop(true, true).removeClass('fancybox-opened');
2107
2108				F.transitions[ F.current.closeMethod ]();
2109			}
2110		},
2111
2112		// Manage slideshow:
2113		//   $.fancybox.play(); - toggle slideshow
2114		//   $.fancybox.play( true ); - start
2115		//   $.fancybox.play( false ); - stop
2116		play: function ( action ) {
2117			var clear = function () {
2118					clearTimeout(F.player.timer);
2119				},
2120				set = function () {
2121					clear();
2122
2123					if (F.current && F.player.isActive) {
2124						F.player.timer = setTimeout(F.next, F.current.playSpeed);
2125					}
2126				},
2127				stop = function () {
2128					clear();
2129
2130					D.unbind('.player');
2131
2132					F.player.isActive = false;
2133
2134					F.trigger('onPlayEnd');
2135				},
2136				start = function () {
2137					if (F.current && (F.current.loop || F.current.index < F.group.length - 1)) {
2138						F.player.isActive = true;
2139
2140						D.bind({
2141							'onCancel.player beforeClose.player' : stop,
2142							'onUpdate.player'   : set,
2143							'beforeLoad.player' : clear
2144						});
2145
2146						set();
2147
2148						F.trigger('onPlayStart');
2149					}
2150				};
2151
2152			if (action === true || (!F.player.isActive && action !== false)) {
2153				start();
2154			} else {
2155				stop();
2156			}
2157		},
2158
2159		// Navigate to next gallery item
2160		next: function ( direction ) {
2161			var current = F.current;
2162
2163			if (current) {
2164				if (!isString(direction)) {
2165					direction = current.direction.next;
2166				}
2167
2168				F.jumpto(current.index + 1, direction, 'next');
2169			}
2170		},
2171
2172		// Navigate to previous gallery item
2173		prev: function ( direction ) {
2174			var current = F.current;
2175
2176			if (current) {
2177				if (!isString(direction)) {
2178					direction = current.direction.prev;
2179				}
2180
2181				F.jumpto(current.index - 1, direction, 'prev');
2182			}
2183		},
2184
2185		// Navigate to gallery item by index
2186		jumpto: function ( index, direction, router ) {
2187			var current = F.current;
2188
2189			if (!current) {
2190				return;
2191			}
2192
2193			index = getScalar(index);
2194
2195			F.direction = direction || current.direction[ (index >= current.index ? 'next' : 'prev') ];
2196			F.router    = router || 'jumpto';
2197
2198			if (current.loop) {
2199				if (index < 0) {
2200					index = current.group.length + (index % current.group.length);
2201				}
2202
2203				index = index % current.group.length;
2204			}
2205
2206			if (current.group[ index ] !== undefined) {
2207				F.cancel();
2208
2209				F._start(index);
2210			}
2211		},
2212
2213		// Center inside viewport and toggle position type to fixed or absolute if needed
2214		reposition: function (e, onlyAbsolute) {
2215			var current = F.current,
2216				wrap    = current ? current.wrap : null,
2217				pos;
2218
2219			if (wrap) {
2220				pos = F._getPosition(onlyAbsolute);
2221
2222				if (e && e.type === 'scroll') {
2223					delete pos.position;
2224
2225					wrap.stop(true, true).animate(pos, 200);
2226
2227				} else {
2228					wrap.css(pos);
2229
2230					current.pos = $.extend({}, current.dim, pos);
2231				}
2232			}
2233		},
2234
2235		update: function (e) {
2236			var type = (e && e.type),
2237				anyway = !type || type === 'orientationchange';
2238
2239			if (anyway) {
2240				clearTimeout(didUpdate);
2241
2242				didUpdate = null;
2243			}
2244
2245			if (!F.isOpen || didUpdate) {
2246				return;
2247			}
2248
2249			didUpdate = setTimeout(function() {
2250				var current = F.current;
2251
2252				if (!current || F.isClosing) {
2253					return;
2254				}
2255
2256				F.wrap.removeClass('fancybox-tmp');
2257
2258				if (anyway || type === 'load' || (type === 'resize' && current.autoResize)) {
2259					F._setDimension();
2260				}
2261
2262				if (!(type === 'scroll' && current.canShrink)) {
2263					F.reposition(e);
2264				}
2265
2266				F.trigger('onUpdate');
2267
2268				didUpdate = null;
2269
2270			}, (anyway && !isTouch ? 0 : 300));
2271		},
2272
2273		// Shrink content to fit inside viewport or restore if resized
2274		toggle: function ( action ) {
2275			if (F.isOpen) {
2276				F.current.fitToView = $.type(action) === "boolean" ? action : !F.current.fitToView;
2277
2278				// Help browser to restore document dimensions
2279				if (isTouch) {
2280					F.wrap.removeAttr('style').addClass('fancybox-tmp');
2281
2282					F.trigger('onUpdate');
2283				}
2284
2285				F.update();
2286			}
2287		},
2288
2289		hideLoading: function () {
2290			D.unbind('.loading');
2291
2292			$('#fancybox-loading').remove();
2293		},
2294
2295		showLoading: function () {
2296			var el, viewport;
2297
2298			F.hideLoading();
2299
2300			el = $('<div id="fancybox-loading"><div></div></div>').click(F.cancel).appendTo('body');
2301
2302			// If user will press the escape-button, the request will be canceled
2303			D.bind('keydown.loading', function(e) {
2304				if ((e.which || e.keyCode) === 27) {
2305					e.preventDefault();
2306
2307					F.cancel();
2308				}
2309			});
2310
2311			if (!F.defaults.fixed) {
2312				viewport = F.getViewport();
2313
2314				el.css({
2315					position : 'absolute',
2316					top  : (viewport.h * 0.5) + viewport.y,
2317					left : (viewport.w * 0.5) + viewport.x
2318				});
2319			}
2320		},
2321
2322		getViewport: function () {
2323			var locked = (F.current && F.current.locked) || false,
2324				rez    = {
2325					x: W.scrollLeft(),
2326					y: W.scrollTop()
2327				};
2328
2329			if (locked) {
2330				rez.w = locked[0].clientWidth;
2331				rez.h = locked[0].clientHeight;
2332
2333			} else {
2334				// See http://bugs.jquery.com/ticket/6724
2335				rez.w = isTouch && window.innerWidth  ? window.innerWidth  : W.width();
2336				rez.h = isTouch && window.innerHeight ? window.innerHeight : W.height();
2337			}
2338
2339			return rez;
2340		},
2341
2342		// Unbind the keyboard / clicking actions
2343		unbindEvents: function () {
2344			if (F.wrap && isQuery(F.wrap)) {
2345				F.wrap.unbind('.fb');
2346			}
2347
2348			D.unbind('.fb');
2349			W.unbind('.fb');
2350		},
2351
2352		bindEvents: function () {
2353			var current = F.current,
2354				keys;
2355
2356			if (!current) {
2357				return;
2358			}
2359
2360			// Changing document height on iOS devices triggers a 'resize' event,
2361			// that can change document height... repeating infinitely
2362			W.bind('orientationchange.fb' + (isTouch ? '' : ' resize.fb') + (current.autoCenter && !current.locked ? ' scroll.fb' : ''), F.update);
2363
2364			keys = current.keys;
2365
2366			if (keys) {
2367				D.bind('keydown.fb', function (e) {
2368					var code   = e.which || e.keyCode,
2369						target = e.target || e.srcElement;
2370
2371					// Skip esc key if loading, because showLoading will cancel preloading
2372					if (code === 27 && F.coming) {
2373						return false;
2374					}
2375
2376					// Ignore key combinations and key events within form elements
2377					if (!e.ctrlKey && !e.altKey && !e.shiftKey && !e.metaKey && !(target && (target.type || $(target).is('[contenteditable]')))) {
2378						$.each(keys, function(i, val) {
2379							if (current.group.length > 1 && val[ code ] !== undefined) {
2380								F[ i ]( val[ code ] );
2381
2382								e.preventDefault();
2383								return false;
2384							}
2385
2386							if ($.inArray(code, val) > -1) {
2387								F[ i ] ();
2388
2389								e.preventDefault();
2390								return false;
2391							}
2392						});
2393					}
2394				});
2395			}
2396
2397			if ($.fn.mousewheel && current.mouseWheel) {
2398				F.wrap.bind('mousewheel.fb', function (e, delta, deltaX, deltaY) {
2399					var target = e.target || null,
2400						parent = $(target),
2401						canScroll = false;
2402
2403					while (parent.length) {
2404						if (canScroll || parent.is('.fancybox-skin') || parent.is('.fancybox-wrap')) {
2405							break;
2406						}
2407
2408						canScroll = isScrollable( parent[0] );
2409						parent    = $(parent).parent();
2410					}
2411
2412					if (delta !== 0 && !canScroll) {
2413						if (F.group.length > 1 && !current.canShrink) {
2414							if (deltaY > 0 || deltaX > 0) {
2415								F.prev( deltaY > 0 ? 'down' : 'left' );
2416
2417							} else if (deltaY < 0 || deltaX < 0) {
2418								F.next( deltaY < 0 ? 'up' : 'right' );
2419							}
2420
2421							e.preventDefault();
2422						}
2423					}
2424				});
2425			}
2426		},
2427
2428		trigger: function (event, o) {
2429			var ret, obj = o || F.coming || F.current;
2430
2431			if (!obj) {
2432				return;
2433			}
2434
2435			if ($.isFunction( obj[event] )) {
2436				ret = obj[event].apply(obj, Array.prototype.slice.call(arguments, 1));
2437			}
2438
2439			if (ret === false) {
2440				return false;
2441			}
2442
2443			if (obj.helpers) {
2444				$.each(obj.helpers, function (helper, opts) {
2445					if (opts && F.helpers[helper] && $.isFunction(F.helpers[helper][event])) {
2446						F.helpers[helper][event]($.extend(true, {}, F.helpers[helper].defaults, opts), obj);
2447					}
2448				});
2449			}
2450
2451			D.trigger(event);
2452		},
2453
2454		isImage: function (str) {
2455			return isString(str) && str.match(/(^data:image\/.*,)|(\.(jp(e|g|eg)|gif|png|bmp|webp|svg)((\?|#).*)?$)/i);
2456		},
2457
2458		isSWF: function (str) {
2459			return isString(str) && str.match(/\.(swf)((\?|#).*)?$/i);
2460		},
2461
2462		_start: function (index) {
2463			var coming = {},
2464				obj,
2465				href,
2466				type,
2467				margin,
2468				padding;
2469
2470			index = getScalar( index );
2471			obj   = F.group[ index ] || null;
2472
2473			if (!obj) {
2474				return false;
2475			}
2476
2477			coming = $.extend(true, {}, F.opts, obj);
2478
2479			// Convert margin and padding properties to array - top, right, bottom, left
2480			margin  = coming.margin;
2481			padding = coming.padding;
2482
2483			if ($.type(margin) === 'number') {
2484				coming.margin = [margin, margin, margin, margin];
2485			}
2486
2487			if ($.type(padding) === 'number') {
2488				coming.padding = [padding, padding, padding, padding];
2489			}
2490
2491			// 'modal' propery is just a shortcut
2492			if (coming.modal) {
2493				$.extend(true, coming, {
2494					closeBtn   : false,
2495					closeClick : false,
2496					nextClick  : false,
2497					arrows     : false,
2498					mouseWheel : false,
2499					keys       : null,
2500					helpers: {
2501						overlay : {
2502							closeClick : false
2503						}
2504					}
2505				});
2506			}
2507
2508			// 'autoSize' property is a shortcut, too
2509			if (coming.autoSize) {
2510				coming.autoWidth = coming.autoHeight = true;
2511			}
2512
2513			if (coming.width === 'auto') {
2514				coming.autoWidth = true;
2515			}
2516
2517			if (coming.height === 'auto') {
2518				coming.autoHeight = true;
2519			}
2520
2521			/*
2522			 * Add reference to the group, so it`s possible to access from callbacks, example:
2523			 * afterLoad : function() {
2524			 *     this.title = 'Image ' + (this.index + 1) + ' of ' + this.group.length + (this.title ? ' - ' + this.title : '');
2525			 * }
2526			 */
2527
2528			coming.group  = F.group;
2529			coming.index  = index;
2530
2531			// Give a chance for callback or helpers to update coming item (type, title, etc)
2532			F.coming = coming;
2533
2534			if (false === F.trigger('beforeLoad')) {
2535				F.coming = null;
2536
2537				return;
2538			}
2539
2540			type = coming.type;
2541			href = coming.href;
2542
2543			if (!type) {
2544				F.coming = null;
2545
2546				//If we can not determine content type then drop silently or display next/prev item if looping through gallery
2547				if (F.current && F.router && F.router !== 'jumpto') {
2548					F.current.index = index;
2549
2550					return F[ F.router ]( F.direction );
2551				}
2552
2553				return false;
2554			}
2555
2556			F.isActive = true;
2557
2558			if (type === 'image' || type === 'swf') {
2559				coming.autoHeight = coming.autoWidth = false;
2560				coming.scrolling  = 'visible';
2561			}
2562
2563			if (type === 'image') {
2564				coming.aspectRatio = true;
2565			}
2566
2567			if (type === 'iframe' && isTouch) {
2568				coming.scrolling = 'scroll';
2569			}
2570
2571			// Build the neccessary markup
2572			coming.wrap = $(coming.tpl.wrap).addClass('fancybox-' + (isTouch ? 'mobile' : 'desktop') + ' fancybox-type-' + type + ' fancybox-tmp ' + coming.wrapCSS).appendTo( coming.parent || 'body' );
2573
2574			$.extend(coming, {
2575				skin  : $('.fancybox-skin',  coming.wrap),
2576				outer : $('.fancybox-outer', coming.wrap),
2577				inner : $('.fancybox-inner', coming.wrap)
2578			});
2579
2580			$.each(["Top", "Right", "Bottom", "Left"], function(i, v) {
2581				coming.skin.css('padding' + v, getValue(coming.padding[ i ]));
2582			});
2583
2584			F.trigger('onReady');
2585
2586			// Check before try to load; 'inline' and 'html' types need content, others - href
2587			if (type === 'inline' || type === 'html') {
2588				if (!coming.content || !coming.content.length) {
2589					return F._error( 'content' );
2590				}
2591
2592			} else if (!href) {
2593				return F._error( 'href' );
2594			}
2595
2596			if (type === 'image') {
2597				F._loadImage();
2598
2599			} else if (type === 'ajax') {
2600				F._loadAjax();
2601
2602			} else if (type === 'iframe') {
2603				F._loadIframe();
2604
2605			} else {
2606				F._afterLoad();
2607			}
2608		},
2609
2610		_error: function ( type ) {
2611			$.extend(F.coming, {
2612				type       : 'html',
2613				autoWidth  : true,
2614				autoHeight : true,
2615				minWidth   : 0,
2616				minHeight  : 0,
2617				scrolling  : 'no',
2618				hasError   : type,
2619				content    : F.coming.tpl.error
2620			});
2621
2622			F._afterLoad();
2623		},
2624
2625		_loadImage: function () {
2626			// Reset preload image so it is later possible to check "complete" property
2627			var img = F.imgPreload = new Image();
2628
2629			img.onload = function () {
2630				this.onload = this.onerror = null;
2631
2632				F.coming.width  = this.width / F.opts.pixelRatio;
2633				F.coming.height = this.height / F.opts.pixelRatio;
2634
2635				F._afterLoad();
2636			};
2637
2638			img.onerror = function () {
2639				this.onload = this.onerror = null;
2640
2641				F._error( 'image' );
2642			};
2643
2644			img.src = F.coming.href;
2645
2646			if (img.complete !== true) {
2647				F.showLoading();
2648			}
2649		},
2650
2651		_loadAjax: function () {
2652			var coming = F.coming;
2653
2654			F.showLoading();
2655
2656			F.ajaxLoad = $.ajax($.extend({}, coming.ajax, {
2657				url: coming.href,
2658				error: function (jqXHR, textStatus) {
2659					if (F.coming && textStatus !== 'abort') {
2660						F._error( 'ajax', jqXHR );
2661
2662					} else {
2663						F.hideLoading();
2664					}
2665				},
2666				success: function (data, textStatus) {
2667					if (textStatus === 'success') {
2668						coming.content = data;
2669
2670						F._afterLoad();
2671					}
2672				}
2673			}));
2674		},
2675
2676		_loadIframe: function() {
2677			var coming = F.coming,
2678				iframe = $(coming.tpl.iframe.replace(/\{rnd\}/g, new Date().getTime()))
2679					.attr('scrolling', isTouch ? 'auto' : coming.iframe.scrolling)
2680					.attr('src', coming.href);
2681
2682			// This helps IE
2683			$(coming.wrap).bind('onReset', function () {
2684				try {
2685					$(this).find('iframe').hide().attr('src', '//about:blank').end().empty();
2686				} catch (e) {}
2687			});
2688
2689			if (coming.iframe.preload) {
2690				F.showLoading();
2691
2692				iframe.one('load', function() {
2693					$(this).data('ready', 1);
2694
2695					// iOS will lose scrolling if we resize
2696					if (!isTouch) {
2697						$(this).bind('load.fb', F.update);
2698					}
2699
2700					// Without this trick:
2701					//   - iframe won't scroll on iOS devices
2702					//   - IE7 sometimes displays empty iframe
2703					$(this).parents('.fancybox-wrap').width('100%').removeClass('fancybox-tmp').show();
2704
2705					F._afterLoad();
2706				});
2707			}
2708
2709			coming.content = iframe.appendTo( coming.inner );
2710
2711			if (!coming.iframe.preload) {
2712				F._afterLoad();
2713			}
2714		},
2715
2716		_preloadImages: function() {
2717			var group   = F.group,
2718				current = F.current,
2719				len     = group.length,
2720				cnt     = current.preload ? Math.min(current.preload, len - 1) : 0,
2721				item,
2722				i;
2723
2724			for (i = 1; i <= cnt; i += 1) {
2725				item = group[ (current.index + i ) % len ];
2726
2727				if (item.type === 'image' && item.href) {
2728					new Image().src = item.href;
2729				}
2730			}
2731		},
2732
2733		_afterLoad: function () {
2734			var coming   = F.coming,
2735				previous = F.current,
2736				placeholder = 'fancybox-placeholder',
2737				current,
2738				content,
2739				type,
2740				scrolling,
2741				href,
2742				embed;
2743
2744			F.hideLoading();
2745
2746			if (!coming || F.isActive === false) {
2747				return;
2748			}
2749
2750			if (false === F.trigger('afterLoad', coming, previous)) {
2751				coming.wrap.stop(true).trigger('onReset').remove();
2752
2753				F.coming = null;
2754
2755				return;
2756			}
2757
2758			if (previous) {
2759				F.trigger('beforeChange', previous);
2760
2761				previous.wrap.stop(true).removeClass('fancybox-opened')
2762					.find('.fancybox-item, .fancybox-nav')
2763					.remove();
2764			}
2765
2766			F.unbindEvents();
2767
2768			current   = coming;
2769			content   = coming.content;
2770			type      = coming.type;
2771			scrolling = coming.scrolling;
2772
2773			$.extend(F, {
2774				wrap  : current.wrap,
2775				skin  : current.skin,
2776				outer : current.outer,
2777				inner : current.inner,
2778				current  : current,
2779				previous : previous
2780			});
2781
2782			href = current.href;
2783
2784			switch (type) {
2785				case 'inline':
2786				case 'ajax':
2787				case 'html':
2788					if (current.selector) {
2789						content = $('<div>').html(content).find(current.selector);
2790
2791					} else if (isQuery(content)) {
2792						if (!content.data(placeholder)) {
2793							content.data(placeholder, $('<div class="' + placeholder + '"></div>').insertAfter( content ).hide() );
2794						}
2795
2796						content = content.show().detach();
2797
2798						current.wrap.bind('onReset', function () {
2799							if ($(this).find(content).length) {
2800								content.hide().replaceAll( content.data(placeholder) ).data(placeholder, false);
2801							}
2802						});
2803					}
2804				break;
2805
2806				case 'image':
2807					content = current.tpl.image.replace('{href}', href);
2808				break;
2809
2810				case 'swf':
2811					content = '<object id="fancybox-swf" classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" width="100%" height="100%"><param name="movie" value="' + href + '"></param>';
2812					embed   = '';
2813
2814					$.each(current.swf, function(name, val) {
2815						content += '<param name="' + name + '" value="' + val + '"></param>';
2816						embed   += ' ' + name + '="' + val + '"';
2817					});
2818
2819					content += '<embed src="' + href + '" type="application/x-shockwave-flash" width="100%" height="100%"' + embed + '></embed></object>';
2820				break;
2821			}
2822
2823			if (!(isQuery(content) && content.parent().is(current.inner))) {
2824				current.inner.append( content );
2825			}
2826
2827			// Give a chance for helpers or callbacks to update elements
2828			F.trigger('beforeShow');
2829
2830			// Set scrolling before calculating dimensions
2831			current.inner.css('overflow', scrolling === 'yes' ? 'scroll' : (scrolling === 'no' ? 'hidden' : scrolling));
2832
2833			// Set initial dimensions and start position
2834			F._setDimension();
2835
2836			F.reposition();
2837
2838			F.isOpen = false;
2839			F.coming = null;
2840
2841			F.bindEvents();
2842
2843			if (!F.isOpened) {
2844				$('.fancybox-wrap').not( current.wrap ).stop(true).trigger('onReset').remove();
2845
2846			} else if (previous.prevMethod) {
2847				F.transitions[ previous.prevMethod ]();
2848			}
2849
2850			F.transitions[ F.isOpened ? current.nextMethod : current.openMethod ]();
2851
2852			F._preloadImages();
2853		},
2854
2855		_setDimension: function () {
2856			var viewport   = F.getViewport(),
2857				steps      = 0,
2858				canShrink  = false,
2859				canExpand  = false,
2860				wrap       = F.wrap,
2861				skin       = F.skin,
2862				inner      = F.inner,
2863				current    = F.current,
2864				width      = current.width,
2865				height     = current.height,
2866				minWidth   = current.minWidth,
2867				minHeight  = current.minHeight,
2868				maxWidth   = current.maxWidth,
2869				maxHeight  = current.maxHeight,
2870				scrolling  = current.scrolling,
2871				scrollOut  = current.scrollOutside ? current.scrollbarWidth : 0,
2872				margin     = current.margin,
2873				wMargin    = getScalar(margin[1] + margin[3]),
2874				hMargin    = getScalar(margin[0] + margin[2]),
2875				wPadding,
2876				hPadding,
2877				wSpace,
2878				hSpace,
2879				origWidth,
2880				origHeight,
2881				origMaxWidth,
2882				origMaxHeight,
2883				ratio,
2884				width_,
2885				height_,
2886				maxWidth_,
2887				maxHeight_,
2888				iframe,
2889				body;
2890
2891			// Reset dimensions so we could re-check actual size
2892			wrap.add(skin).add(inner).width('auto').height('auto').removeClass('fancybox-tmp');
2893
2894			wPadding = getScalar(skin.outerWidth(true)  - skin.width());
2895			hPadding = getScalar(skin.outerHeight(true) - skin.height());
2896
2897			// Any space between content and viewport (margin, padding, border, title)
2898			wSpace = wMargin + wPadding;
2899			hSpace = hMargin + hPadding;
2900
2901			origWidth  = isPercentage(width)  ? (viewport.w - wSpace) * getScalar(width)  / 100 : width;
2902			origHeight = isPercentage(height) ? (viewport.h - hSpace) * getScalar(height) / 100 : height;
2903
2904			if (current.type === 'iframe') {
2905				iframe = current.content;
2906
2907				if (current.autoHeight && iframe.data('ready') === 1) {
2908					try {
2909						if (iframe[0].contentWindow.document.location) {
2910							inner.width( origWidth ).height(9999);
2911
2912							body = iframe.contents().find('body');
2913
2914							if (scrollOut) {
2915								body.css('overflow-x', 'hidden');
2916							}
2917
2918							origHeight = body.outerHeight(true);
2919						}
2920
2921					} catch (e) {}
2922				}
2923
2924			} else if (current.autoWidth || current.autoHeight) {
2925				inner.addClass( 'fancybox-tmp' );
2926
2927				// Set width or height in case we need to calculate only one dimension
2928				if (!current.autoWidth) {
2929					inner.width( origWidth );
2930				}
2931
2932				if (!current.autoHeight) {
2933					inner.height( origHeight );
2934				}
2935
2936				if (current.autoWidth) {
2937					origWidth = inner.width();
2938				}
2939
2940				if (current.autoHeight) {
2941					origHeight = inner.height();
2942				}
2943
2944				inner.removeClass( 'fancybox-tmp' );
2945			}
2946
2947			width  = getScalar( origWidth );
2948			height = getScalar( origHeight );
2949
2950			ratio  = origWidth / origHeight;
2951
2952			// Calculations for the content
2953			minWidth  = getScalar(isPercentage(minWidth) ? getScalar(minWidth, 'w') - wSpace : minWidth);
2954			maxWidth  = getScalar(isPercentage(maxWidth) ? getScalar(maxWidth, 'w') - wSpace : maxWidth);
2955
2956			minHeight = getScalar(isPercentage(minHeight) ? getScalar(minHeight, 'h') - hSpace : minHeight);
2957			maxHeight = getScalar(isPercentage(maxHeight) ? getScalar(maxHeight, 'h') - hSpace : maxHeight);
2958
2959			// These will be used to determine if wrap can fit in the viewport
2960			origMaxWidth  = maxWidth;
2961			origMaxHeight = maxHeight;
2962
2963			if (current.fitToView) {
2964				maxWidth  = Math.min(viewport.w - wSpace, maxWidth);
2965				maxHeight = Math.min(viewport.h - hSpace, maxHeight);
2966			}
2967
2968			maxWidth_  = viewport.w - wMargin;
2969			maxHeight_ = viewport.h - hMargin;
2970
2971			if (current.aspectRatio) {
2972				if (width > maxWidth) {
2973					width  = maxWidth;
2974					height = getScalar(width / ratio);
2975				}
2976
2977				if (height > maxHeight) {
2978					height = maxHeight;
2979					width  = getScalar(height * ratio);
2980				}
2981
2982				if (width < minWidth) {
2983					width  = minWidth;
2984					height = getScalar(width / ratio);
2985				}
2986
2987				if (height < minHeight) {
2988					height = minHeight;
2989					width  = getScalar(height * ratio);
2990				}
2991
2992			} else {
2993				width = Math.max(minWidth, Math.min(width, maxWidth));
2994
2995				if (current.autoHeight && current.type !== 'iframe') {
2996					inner.width( width );
2997
2998					height = inner.height();
2999				}
3000
3001				height = Math.max(minHeight, Math.min(height, maxHeight));
3002			}
3003
3004			// Try to fit inside viewport (including the title)
3005			if (current.fitToView) {
3006				inner.width( width ).height( height );
3007
3008				wrap.width( width + wPadding );
3009
3010				// Real wrap dimensions
3011				width_  = wrap.width();
3012				height_ = wrap.height();
3013
3014				if (current.aspectRatio) {
3015					while ((width_ > maxWidth_ || height_ > maxHeight_) && width > minWidth && height > minHeight) {
3016						if (steps++ > 19) {
3017							break;
3018						}
3019
3020						height = Math.max(minHeight, Math.min(maxHeight, height - 10));
3021						width  = getScalar(height * ratio);
3022
3023						if (width < minWidth) {
3024							width  = minWidth;
3025							height = getScalar(width / ratio);
3026						}
3027
3028						if (width > maxWidth) {
3029							width  = maxWidth;
3030							height = getScalar(width / ratio);
3031						}
3032
3033						inner.width( width ).height( height );
3034
3035						wrap.width( width + wPadding );
3036
3037						width_  = wrap.width();
3038						height_ = wrap.height();
3039					}
3040
3041				} else {
3042					width  = Math.max(minWidth,  Math.min(width,  width  - (width_  - maxWidth_)));
3043					height = Math.max(minHeight, Math.min(height, height - (height_ - maxHeight_)));
3044				}
3045			}
3046
3047			if (scrollOut && scrolling === 'auto' && height < origHeight && (width + wPadding + scrollOut) < maxWidth_) {
3048				width += scrollOut;
3049			}
3050
3051			inner.width( width ).height( height );
3052
3053			wrap.width( width + wPadding );
3054
3055			width_  = wrap.width();
3056			height_ = wrap.height();
3057
3058			canShrink = (width_ > maxWidth_ || height_ > maxHeight_) && width > minWidth && height > minHeight;
3059			canExpand = current.aspectRatio ? (width < origMaxWidth && height < origMaxHeight && width < origWidth && height < origHeight) : ((width < origMaxWidth || height < origMaxHeight) && (width < origWidth || height < origHeight));
3060
3061			$.extend(current, {
3062				dim : {
3063					width	: getValue( width_ ),
3064					height	: getValue( height_ )
3065				},
3066				origWidth  : origWidth,
3067				origHeight : origHeight,
3068				canShrink  : canShrink,
3069				canExpand  : canExpand,
3070				wPadding   : wPadding,
3071				hPadding   : hPadding,
3072				wrapSpace  : height_ - skin.outerHeight(true),
3073				skinSpace  : skin.height() - height
3074			});
3075
3076			if (!iframe && current.autoHeight && height > minHeight && height < maxHeight && !canExpand) {
3077				inner.height('auto');
3078			}
3079		},
3080
3081		_getPosition: function (onlyAbsolute) {
3082			var current  = F.current,
3083				viewport = F.getViewport(),
3084				margin   = current.margin,
3085				width    = F.wrap.width()  + margin[1] + margin[3],
3086				height   = F.wrap.height() + margin[0] + margin[2],
3087				rez      = {
3088					position: 'absolute',
3089					top  : margin[0],
3090					left : margin[3]
3091				};
3092
3093			if (current.autoCenter && current.fixed && !onlyAbsolute && height <= viewport.h && width <= viewport.w) {
3094				rez.position = 'fixed';
3095
3096			} else if (!current.locked) {
3097				rez.top  += viewport.y;
3098				rez.left += viewport.x;
3099			}
3100
3101			rez.top  = getValue(Math.max(rez.top,  rez.top  + ((viewport.h - height) * current.topRatio)));
3102			rez.left = getValue(Math.max(rez.left, rez.left + ((viewport.w - width)  * current.leftRatio)));
3103
3104			return rez;
3105		},
3106
3107		_afterZoomIn: function () {
3108			var current = F.current;
3109
3110			if (!current) {
3111				return;
3112			}
3113
3114			F.isOpen = F.isOpened = true;
3115
3116			F.wrap.css('overflow', 'visible').addClass('fancybox-opened');
3117
3118			F.update();
3119
3120			// Assign a click event
3121			if ( current.closeClick || (current.nextClick && F.group.length > 1) ) {
3122				F.inner.css('cursor', 'pointer').bind('click.fb', function(e) {
3123					if (!$(e.target).is('a') && !$(e.target).parent().is('a')) {
3124						e.preventDefault();
3125
3126						F[ current.closeClick ? 'close' : 'next' ]();
3127					}
3128				});
3129			}
3130
3131			// Create a close button
3132			if (current.closeBtn) {
3133				$(current.tpl.closeBtn).appendTo(F.skin).bind('click.fb', function(e) {
3134					e.preventDefault();
3135
3136					F.close();
3137				});
3138			}
3139
3140			// Create navigation arrows
3141			if (current.arrows && F.group.length > 1) {
3142				if (current.loop || current.index > 0) {
3143					$(current.tpl.prev).appendTo(F.outer).bind('click.fb', F.prev);
3144				}
3145
3146				if (current.loop || current.index < F.group.length - 1) {
3147					$(current.tpl.next).appendTo(F.outer).bind('click.fb', F.next);
3148				}
3149			}
3150
3151			F.trigger('afterShow');
3152
3153			// Stop the slideshow if this is the last item
3154			if (!current.loop && current.index === current.group.length - 1) {
3155				F.play( false );
3156
3157			} else if (F.opts.autoPlay && !F.player.isActive) {
3158				F.opts.autoPlay = false;
3159
3160				F.play();
3161			}
3162		},
3163
3164		_afterZoomOut: function ( obj ) {
3165			obj = obj || F.current;
3166
3167			$('.fancybox-wrap').trigger('onReset').remove();
3168
3169			$.extend(F, {
3170				group  : {},
3171				opts   : {},
3172				router : false,
3173				current   : null,
3174				isActive  : false,
3175				isOpened  : false,
3176				isOpen    : false,
3177				isClosing : false,
3178				wrap   : null,
3179				skin   : null,
3180				outer  : null,
3181				inner  : null
3182			});
3183
3184			F.trigger('afterClose', obj);
3185		}
3186	});
3187
3188	/*
3189	 *	Default transitions
3190	 */
3191
3192	F.transitions = {
3193		getOrigPosition: function () {
3194			var current  = F.current,
3195				element  = current.element,
3196				orig     = current.orig,
3197				pos      = {},
3198				width    = 50,
3199				height   = 50,
3200				hPadding = current.hPadding,
3201				wPadding = current.wPadding,
3202				viewport = F.getViewport();
3203
3204			if (!orig && current.isDom && element.is(':visible')) {
3205				orig = element.find('img:first');
3206
3207				if (!orig.length) {
3208					orig = element;
3209				}
3210			}
3211
3212			if (isQuery(orig)) {
3213				pos = orig.offset();
3214
3215				if (orig.is('img')) {
3216					width  = orig.outerWidth();
3217					height = orig.outerHeight();
3218				}
3219
3220			} else {
3221				pos.top  = viewport.y + (viewport.h - height) * current.topRatio;
3222				pos.left = viewport.x + (viewport.w - width)  * current.leftRatio;
3223			}
3224
3225			if (F.wrap.css('position') === 'fixed' || current.locked) {
3226				pos.top  -= viewport.y;
3227				pos.left -= viewport.x;
3228			}
3229
3230			pos = {
3231				top     : getValue(pos.top  - hPadding * current.topRatio),
3232				left    : getValue(pos.left - wPadding * current.leftRatio),
3233				width   : getValue(width  + wPadding),
3234				height  : getValue(height + hPadding)
3235			};
3236
3237			return pos;
3238		},
3239
3240		step: function (now, fx) {
3241			var ratio,
3242				padding,
3243				value,
3244				prop       = fx.prop,
3245				current    = F.current,
3246				wrapSpace  = current.wrapSpace,
3247				skinSpace  = current.skinSpace;
3248
3249			if (prop === 'width' || prop === 'height') {
3250				ratio = fx.end === fx.start ? 1 : (now - fx.start) / (fx.end - fx.start);
3251
3252				if (F.isClosing) {
3253					ratio = 1 - ratio;
3254				}
3255
3256				padding = prop === 'width' ? current.wPadding : current.hPadding;
3257				value   = now - padding;
3258
3259				F.skin[ prop ](  getScalar( prop === 'width' ?  value : value - (wrapSpace * ratio) ) );
3260				F.inner[ prop ]( getScalar( prop === 'width' ?  value : value - (wrapSpace * ratio) - (skinSpace * ratio) ) );
3261			}
3262		},
3263
3264		zoomIn: function () {
3265			var current  = F.current,
3266				startPos = current.pos,
3267				effect   = current.openEffect,
3268				elastic  = effect === 'elastic',
3269				endPos   = $.extend({opacity : 1}, startPos);
3270
3271			// Remove "position" property that breaks older IE
3272			delete endPos.position;
3273
3274			if (elastic) {
3275				startPos = this.getOrigPosition();
3276
3277				if (current.openOpacity) {
3278					startPos.opacity = 0.1;
3279				}
3280
3281			} else if (effect === 'fade') {
3282				startPos.opacity = 0.1;
3283			}
3284
3285			F.wrap.css(startPos).animate(endPos, {
3286				duration : effect === 'none' ? 0 : current.openSpeed,
3287				easing   : current.openEasing,
3288				step     : elastic ? this.step : null,
3289				complete : F._afterZoomIn
3290			});
3291		},
3292
3293		zoomOut: function () {
3294			var current  = F.current,
3295				effect   = current.closeEffect,
3296				elastic  = effect === 'elastic',
3297				endPos   = {opacity : 0.1};
3298
3299			if (elastic) {
3300				endPos = this.getOrigPosition();
3301
3302				if (current.closeOpacity) {
3303					endPos.opacity = 0.1;
3304				}
3305			}
3306
3307			F.wrap.animate(endPos, {
3308				duration : effect === 'none' ? 0 : current.closeSpeed,
3309				easing   : current.closeEasing,
3310				step     : elastic ? this.step : null,
3311				complete : F._afterZoomOut
3312			});
3313		},
3314
3315		changeIn: function () {
3316			var current   = F.current,
3317				effect    = current.nextEffect,
3318				startPos  = current.pos,
3319				endPos    = { opacity : 1 },
3320				direction = F.direction,
3321				distance  = 200,
3322				field;
3323
3324			startPos.opacity = 0.1;
3325
3326			if (effect === 'elastic') {
3327				field = direction === 'down' || direction === 'up' ? 'top' : 'left';
3328
3329				if (direction === 'down' || direction === 'right') {
3330					startPos[ field ] = getValue(getScalar(startPos[ field ]) - distance);
3331					endPos[ field ]   = '+=' + distance + 'px';
3332
3333				} else {
3334					startPos[ field ] = getValue(getScalar(startPos[ field ]) + distance);
3335					endPos[ field ]   = '-=' + distance + 'px';
3336				}
3337			}
3338
3339			// Workaround for http://bugs.jquery.com/ticket/12273
3340			if (effect === 'none') {
3341				F._afterZoomIn();
3342
3343			} else {
3344				F.wrap.css(startPos).animate(endPos, {
3345					duration : current.nextSpeed,
3346					easing   : current.nextEasing,
3347					complete : F._afterZoomIn
3348				});
3349			}
3350		},
3351
3352		changeOut: function () {
3353			var previous  = F.previous,
3354				effect    = previous.prevEffect,
3355				endPos    = { opacity : 0.1 },
3356				direction = F.direction,
3357				distance  = 200;
3358
3359			if (effect === 'elastic') {
3360				endPos[ direction === 'down' || direction === 'up' ? 'top' : 'left' ] = ( direction === 'up' || direction === 'left' ? '-' : '+' ) + '=' + distance + 'px';
3361			}
3362
3363			previous.wrap.animate(endPos, {
3364				duration : effect === 'none' ? 0 : previous.prevSpeed,
3365				easing   : previous.prevEasing,
3366				complete : function () {
3367					$(this).trigger('onReset').remove();
3368				}
3369			});
3370		}
3371	};
3372
3373	/*
3374	 *	Overlay helper
3375	 */
3376