text: /*! PhotoSwipe - v4.1.1 - 2015-12-24
  * http://photoswipe.com
  * Copyright (c) 2015 Dmitry Semenov; */
  (function (root, factory) { 
  	if (typeof define === 'function' && define.amd) {
  		define(factory);
  	} else if (typeof exports === 'object') {
  		module.exports = factory();
  	} else {
  		root.PhotoSwipe = factory();
  	}
  })(this, function () {
  
  	'use strict';
  	var PhotoSwipe = function(template, UiClass, items, options){
  
  /*>>framework-bridge*/
  /**
   *
   * Set of generic functions used by gallery.
   * 
   * You're free to modify anything here as long as functionality is kept.
   * 
   */
  var framework = {
  	features: null,
  	bind: function(target, type, listener, unbind) {
  		var methodName = (unbind ? 'remove' : 'add') + 'EventListener';
  		type = type.split(' ');
  		for(var i = 0; i < type.length; i++) {
  			if(type[i]) {
  				target[methodName]( type[i], listener, false);
  			}
  		}
  	},
  	isArray: function(obj) {
  		return (obj instanceof Array);
  	},
  	createEl: function(classes, tag) {
  		var el = document.createElement(tag || 'div');
  		if(classes) {
  			el.className = classes;
  		}
  		return el;
  	},
  	getScrollY: function() {
  		var yOffset = window.pageYOffset;
  		return yOffset !== undefined ? yOffset : document.documentElement.scrollTop;
  	},
  	unbind: function(target, type, listener) {
  		framework.bind(target,type,listener,true);
  	},
  	removeClass: function(el, className) {
  		var reg = new RegExp('(\\s|^)' + className + '(\\s|$)');
  		el.className = el.className.replace(reg, ' ').replace(/^\s\s*/, '').replace(/\s\s*$/, ''); 
  	},
  	addClass: function(el, className) {
  		if( !framework.hasClass(el,className) ) {
  			el.className += (el.className ? ' ' : '') + className;
  		}
  	},
  	hasClass: function(el, className) {
  		return el.className && new RegExp('(^|\\s)' + className + '(\\s|$)').test(el.className);
  	},
  	getChildByClass: function(parentEl, childClassName) {
  		var node = parentEl.firstChild;
  		while(node) {
  			if( framework.hasClass(node, childClassName) ) {
  				return node;
  			}
  			node = node.nextSibling;
  		}
  	},
  	arraySearch: function(array, value, key) {
  		var i = array.length;
  		while(i--) {
  			if(array[i][key] === value) {
  				return i;
  			} 
  		}
  		return -1;
  	},
  	extend: function(o1, o2, preventOverwrite) {
  		for (var prop in o2) {
  			if (o2.hasOwnProperty(prop)) {
  				if(preventOverwrite && o1.hasOwnProperty(prop)) {
  					continue;
  				}
  				o1[prop] = o2[prop];
  			}
  		}
  	},
  	easing: {
  		sine: {
  			out: function(k) {
  				return Math.sin(k * (Math.PI / 2));
  			},
  			inOut: function(k) {
  				return - (Math.cos(Math.PI * k) - 1) / 2;
  			}
  		},
  		cubic: {
  			out: function(k) {
  				return --k * k * k + 1;
  			}
  		}
  		/*
  			elastic: {
  				out: function ( k ) {
  
  					var s, a = 0.1, p = 0.4;
  					if ( k === 0 ) return 0;
  					if ( k === 1 ) return 1;
  					if ( !a || a < 1 ) { a = 1; s = p / 4; }
  					else s = p * Math.asin( 1 / a ) / ( 2 * Math.PI );
  					return ( a * Math.pow( 2, - 10 * k) * Math.sin( ( k - s ) * ( 2 * Math.PI ) / p ) + 1 );
  
  				},
  			},
  			back: {
  				out: function ( k ) {
  					var s = 1.70158;
  					return --k * k * ( ( s + 1 ) * k + s ) + 1;
  				}
  			}
  		*/
  	},
  
  	/**
  	 * 
  	 * @return {object}
  	 * 
  	 * {
  	 *  raf : request animation frame function
  	 *  caf : cancel animation frame function
  	 *  transfrom : transform property key (with vendor), or null if not supported
  	 *  oldIE : IE8 or below
  	 * }
  	 * 
  	 */
  	detectFeatures: function() {
  		if(framework.features) {
  			return framework.features;
  		}
  		var helperEl = framework.createEl(),
  			helperStyle = helperEl.style,
  			vendor = '',
  			features = {};
  
  		// IE8 and below
  		features.oldIE = document.all && !document.addEventListener;
  
  		features.touch = 'ontouchstart' in window;
  
  		if(window.requestAnimationFrame) {
  			features.raf = window.requestAnimationFrame;
  			features.caf = window.cancelAnimationFrame;
  		}
  
  		features.pointerEvent = navigator.pointerEnabled || navigator.msPointerEnabled;
  
  		// fix false-positive detection of old Android in new IE
  		// (IE11 ua string contains "Android 4.0")
  		
  		if(!features.pointerEvent) { 
  
  			var ua = navigator.userAgent;
  
  			// Detect if device is iPhone or iPod and if it's older than iOS 8
  			// http://stackoverflow.com/a/14223920
  			// 
  			// This detection is made because of buggy top/bottom toolbars
  			// that don't trigger window.resize event.
  			// For more info refer to _isFixedPosition variable in core.js
  
  			if (/iP(hone|od)/.test(navigator.platform)) {
  				var v = (navigator.appVersion).match(/OS (\d+)_(\d+)_?(\d+)?/);
  				if(v && v.length > 0) {
  					v = parseInt(v[1], 10);
  					if(v >= 1 && v < 8 ) {
  						features.isOldIOSPhone = true;
  					}
  				}
  			}
  
  			// Detect old Android (before KitKat)
  			// due to bugs related to position:fixed
  			// http://stackoverflow.com/questions/7184573/pick-up-the-android-version-in-the-browser-by-javascript
  			
  			var match = ua.match(/Android\s([0-9\.]*)/);
  			var androidversion =  match ? match[1] : 0;
  			androidversion = parseFloat(androidversion);
  			if(androidversion >= 1 ) {
  				if(androidversion < 4.4) {
  					features.isOldAndroid = true; // for fixed position bug & performance
  				}
  				features.androidVersion = androidversion; // for touchend bug
  			}	
  			features.isMobileOpera = /opera mini|opera mobi/i.test(ua);
  
  			// p.s. yes, yes, UA sniffing is bad, propose your solution for above bugs.
  		}
  		
  		var styleChecks = ['transform', 'perspective', 'animationName'],
  			vendors = ['', 'webkit','Moz','ms','O'],
  			styleCheckItem,
  			styleName;
  
  		for(var i = 0; i < 4; i++) {
  			vendor = vendors[i];
  
  			for(var a = 0; a < 3; a++) {
  				styleCheckItem = styleChecks[a];
  
  				// uppercase first letter of property name, if vendor is present
  				styleName = vendor + (vendor ? 
  										styleCheckItem.charAt(0).toUpperCase() + styleCheckItem.slice(1) : 
  										styleCheckItem);
  			
  				if(!features[styleCheckItem] && styleName in helperStyle ) {
  					features[styleCheckItem] = styleName;
  				}
  			}
  
  			if(vendor && !features.raf) {
  				vendor = vendor.toLowerCase();
  				features.raf = window[vendor+'RequestAnimationFrame'];
  				if(features.raf) {
  					features.caf = window[vendor+'CancelAnimationFrame'] || 
  									window[vendor+'CancelRequestAnimationFrame'];
  				}
  			}
  		}
  			
  		if(!features.raf) {
  			var lastTime = 0;
  			features.raf = function(fn) {
  				var currTime = new Date().getTime();
  				var timeToCall = Math.max(0, 16 - (currTime - lastTime));
  				var id = window.setTimeout(function() { fn(currTime + timeToCall); }, timeToCall);
  				lastTime = currTime + timeToCall;
  				return id;
  			};
  			features.caf = function(id) { clearTimeout(id); };
  		}
  
  		// Detect SVG support
  		features.svg = !!document.createElementNS && 
  						!!document.createElementNS('http://www.w3.org/2000/svg', 'svg').createSVGRect;
  
  		framework.features = features;
  
  		return features;
  	}
  };
  
  framework.detectFeatures();
  
  // Override addEventListener for old versions of IE
  if(framework.features.oldIE) {
  
  	framework.bind = function(target, type, listener, unbind) {
  		
  		type = type.split(' ');
  
  		var methodName = (unbind ? 'detach' : 'attach') + 'Event',
  			evName,
  			_handleEv = function() {
  				listener.handleEvent.call(listener);
  			};
  
  		for(var i = 0; i < type.length; i++) {
  			evName = type[i];
  			if(evName) {
  
  				if(typeof listener === 'object' && listener.handleEvent) {
  					if(!unbind) {
  						listener['oldIE' + evName] = _handleEv;
  					} else {
  						if(!listener['oldIE' + evName]) {
  							return false;
  						}
  					}
  
  					target[methodName]( 'on' + evName, listener['oldIE' + evName]);
  				} else {
  					target[methodName]( 'on' + evName, listener);
  				}
  
  			}
  		}
  	};
  	
  }
  
  /*>>framework-bridge*/
  
  /*>>core*/
  //function(template, UiClass, items, options)
  
  var self = this;
  
  /**
   * Static vars, don't change unless you know what you're doing.
   */
  var DOUBLE_TAP_RADIUS = 25, 
  	NUM_HOLDERS = 3;
  
  /**
   * Options
   */
  var _options = {
  	allowPanToNext:true,
  	spacing: 0.12,
  	bgOpacity: 1,
  	mouseUsed: false,
  	loop: true,
  	pinchToClose: true,
  	closeOnScroll: true,
  	closeOnVerticalDrag: true,
  	verticalDragRange: 0.75,
  	hideAnimationDuration: 333,
  	showAnimationDuration: 333,
  	showHideOpacity: false,
  	focus: true,
  	escKey: true,
  	arrowKeys: true,
  	mainScrollEndFriction: 0.35,
  	panEndFriction: 0.35,
  	isClickableElement: function(el) {
          return el.tagName === 'A';
      },
      getDoubleTapZoom: function(isMouseClick, item) {
      	if(isMouseClick) {
      		return 1;
      	} else {
      		return item.initialZoomLevel < 0.7 ? 1 : 1.33;
      	}
      },
      maxSpreadZoom: 1.33,
  	modal: true,
  
  	// not fully implemented yet
  	scaleMode: 'fit' // TODO
  };
  framework.extend(_options, options);
  
  
  /**
   * Private helper variables & functions
   */
  
  var _getEmptyPoint = function() { 
  		return {x:0,y:0}; 
  	};
  
  var _isOpen,
  	_isDestroying,
  	_closedByScroll,
  	_currentItemIndex,
  	_containerStyle,
  	_containerShiftIndex,
  	_currPanDist = _getEmptyPoint(),
  	_startPanOffset = _getEmptyPoint(),
  	_panOffset = _getEmptyPoint(),
  	_upMoveEvents, // drag move, drag end & drag cancel events array
  	_downEvents, // drag start events array
  	_globalEventHandlers,
  	_viewportSize = {},
  	_currZoomLevel,
  	_startZoomLevel,
  	_translatePrefix,
  	_translateSufix,
  	_updateSizeInterval,
  	_itemsNeedUpdate,
  	_currPositionIndex = 0,
  	_offset = {},
  	_slideSize = _getEmptyPoint(), // size of slide area, including spacing
  	_itemHolders,
  	_prevItemIndex,
  	_indexDiff = 0, // difference of indexes since last content update
  	_dragStartEvent,
  	_dragMoveEvent,
  	_dragEndEvent,
  	_dragCancelEvent,
  	_transformKey,
  	_pointerEventEnabled,
  	_isFixedPosition = true,
  	_likelyTouchDevice,
  	_modules = [],
  	_requestAF,
  	_cancelAF,
  	_initalClassName,
  	_initalWindowScrollY,
  	_oldIE,
  	_currentWindowScrollY,
  	_features,
  	_windowVisibleSize = {},
  	_renderMaxResolution = false,
  
  	// Registers PhotoSWipe module (History, Controller ...)
  	_registerModule = function(name, module) {
  		framework.extend(self, module.publicMethods);
  		_modules.push(name);
  	},
  
  	_getLoopedId = function(index) {
  		var numSlides = _getNumItems();
  		if(index > numSlides - 1) {
  			return index - numSlides;
  		} else  if(index < 0) {
  			return numSlides + index;
  		}
  		return index;
  	},
  	
  	// Micro bind/trigger
  	_listeners = {},
  	_listen = function(name, fn) {
  		if(!_listeners[name]) {
  			_listeners[name] = [];
  		}
  		return _listeners[name].push(fn);
  	},
  	_shout = function(name) {
  		var listeners = _listeners[name];
  
  		if(listeners) {
  			var args = Array.prototype.slice.call(arguments);
  			args.shift();
  
  			for(var i = 0; i < listeners.length; i++) {
  				listeners[i].apply(self, args);
  			}
  		}
  	},
  
  	_getCurrentTime = function() {
  		return new Date().getTime();
  	},
  	_applyBgOpacity = function(opacity) {
  		_bgOpacity = opacity;
  		self.bg.style.opacity = opacity * _options.bgOpacity;
  	},
  
  	_applyZoomTransform = function(styleObj,x,y,zoom,item) {
  		if(!_renderMaxResolution || (item && item !== self.currItem) ) {
  			zoom = zoom / (item ? item.fitRatio : self.currItem.fitRatio);	
  		}
  			
  		styleObj[_transformKey] = _translatePrefix + x + 'px, ' + y + 'px' + _translateSufix + ' scale(' + zoom + ')';
  	},
  	_applyCurrentZoomPan = function( allowRenderResolution ) {
  		if(_currZoomElementStyle) {
  
  			if(allowRenderResolution) {
  				if(_currZoomLevel > self.currItem.fitRatio) {
  					if(!_renderMaxResolution) {
  						_setImageSize(self.currItem, false, true);
  						_renderMaxResolution = true;
  					}
  				} else {
  					if(_renderMaxResolution) {
  						_setImageSize(self.currItem);
  						_renderMaxResolution = false;
  					}
  				}
  			}
  			
  
  			_applyZoomTransform(_currZoomElementStyle, _panOffset.x, _panOffset.y, _currZoomLevel);
  		}
  	},
  	_applyZoomPanToItem = function(item) {
  		if(item.container) {
  
  			_applyZoomTransform(item.container.style, 
  								item.initialPosition.x, 
  								item.initialPosition.y, 
  								item.initialZoomLevel,
  								item);
  		}
  	},
  	_setTranslateX = function(x, elStyle) {
  		elStyle[_transformKey] = _translatePrefix + x + 'px, 0px' + _translateSufix;
  	},
  	_moveMainScroll = function(x, dragging) {
  
  		if(!_options.loop && dragging) {
  			var newSlideIndexOffset = _currentItemIndex + (_slideSize.x * _currPositionIndex - x) / _slideSize.x,
  				delta = Math.round(x - _mainScrollPos.x);
  
  			if( (newSlideIndexOffset < 0 && delta > 0) || 
  				(newSlideIndexOffset >= _getNumItems() - 1 && delta < 0) ) {
  				x = _mainScrollPos.x + delta * _options.mainScrollEndFriction;
  			} 
  		}
  		
  		_mainScrollPos.x = x;
  		_setTranslateX(x, _containerStyle);
  	},
  	_calculatePanOffset = function(axis, zoomLevel) {
  		var m = _midZoomPoint[axis] - _offset[axis];
  		return _startPanOffset[axis] + _currPanDist[axis] + m - m * ( zoomLevel / _startZoomLevel );
  	},
  	
  	_equalizePoints = function(p1, p2) {
  		p1.x = p2.x;
  		p1.y = p2.y;
  		if(p2.id) {
  			p1.id = p2.id;
  		}
  	},
  	_roundPoint = function(p) {
  		p.x = Math.round(p.x);
  		p.y = Math.round(p.y);
  	},
  
  	_mouseMoveTimeout = null,
  	_onFirstMouseMove = function() {
  		// Wait until mouse move event is fired at least twice during 100ms
  		// We do this, because some mobile browsers trigger it on touchstart
  		if(_mouseMoveTimeout ) { 
  			framework.unbind(document, 'mousemove', _onFirstMouseMove);
  			framework.addClass(template, 'pswp--has_mouse');
  			_options.mouseUsed = true;
  			_shout('mouseUsed');
  		}
  		_mouseMoveTimeout = setTimeout(function() {
  			_mouseMoveTimeout = null;
  		}, 100);
  	},
  
  	_bindEvents = function() {
  		framework.bind(document, 'keydown', self);
  
  		if(_features.transform) {
  			// don't bind click event in browsers that don't support transform (mostly IE8)
  			framework.bind(self.scrollWrap, 'click', self);
  		}
  		
  
  		if(!_options.mouseUsed) {
  			framework.bind(document, 'mousemove', _onFirstMouseMove);
  		}
  
  		framework.bind(window, 'resize scroll', self);
  
  		_shout('bindEvents');
  	},
  
  	_unbindEvents = function() {
  		framework.unbind(window, 'resize', self);
  		framework.unbind(window, 'scroll', _globalEventHandlers.scroll);
  		framework.unbind(document, 'keydown', self);
  		framework.unbind(document, 'mousemove', _onFirstMouseMove);
  
  		if(_features.transform) {
  			framework.unbind(self.scrollWrap, 'click', self);
  		}
  
  		if(_isDragging) {
  			framework.unbind(window, _upMoveEvents, self);
  		}
  
  		_shout('unbindEvents');
  	},
  	
  	_calculatePanBounds = function(zoomLevel, update) {
  		var bounds = _calculateItemSize( self.currItem, _viewportSize, zoomLevel );
  		if(update) {
  			_currPanBounds = bounds;
  		}
  		return bounds;
  	},
  	
  	_getMinZoomLevel = function(item) {
  		if(!item) {
  			item = self.currItem;
  		}
  		return item.initialZoomLevel;
  	},
  	_getMaxZoomLevel = function(item) {
  		if(!item) {
  			item = self.currItem;
  		}
  		return item.w > 0 ? _options.maxSpreadZoom : 1;
  	},
  
  	// Return true if offset is out of the bounds
  	_modifyDestPanOffset = function(axis, destPanBounds, destPanOffset, destZoomLevel) {
  		if(destZoomLevel === self.currItem.initialZoomLevel) {
  			destPanOffset[axis] = self.currItem.initialPosition[axis];
  			return true;
  		} else {
  			destPanOffset[axis] = _calculatePanOffset(axis, destZoomLevel); 
  
  			if(destPanOffset[axis] > destPanBounds.min[axis]) {
  				destPanOffset[axis] = destPanBounds.min[axis];
  				return true;
  			} else if(destPanOffset[axis] < destPanBounds.max[axis] ) {
  				destPanOffset[axis] = destPanBounds.max[axis];
  				return true;
  			}
  		}
  		return false;
  	},
  
  	_setupTransforms = function() {
  
  		if(_transformKey) {
  			// setup 3d transforms
  			var allow3dTransform = _features.perspective && !_likelyTouchDevice;
  			_translatePrefix = 'translate' + (allow3dTransform ? '3d(' : '(');
  			_translateSufix = _features.perspective ? ', 0px)' : ')';	
  			return;
  		}
  
  		// Override zoom/pan/move functions in case old browser is used (most likely IE)
  		// (so they use left/top/width/height, instead of CSS transform)
  	
  		_transformKey = 'left';
  		framework.addClass(template, 'pswp--ie');
  
  		_setTranslateX = function(x, elStyle) {
  			elStyle.left = x + 'px';
  		};
  		_applyZoomPanToItem = function(item) {
  
  			var zoomRatio = item.fitRatio > 1 ? 1 : item.fitRatio,
  				s = item.container.style,
  				w = zoomRatio * item.w,
  				h = zoomRatio * item.h;
  
  			s.width = w + 'px';
  			s.height = h + 'px';
  			s.left = item.initialPosition.x + 'px';
  			s.top = item.initialPosition.y + 'px';
  
  		};
  		_applyCurrentZoomPan = function() {
  			if(_currZoomElementStyle) {
  
  				var s = _currZoomElementStyle,
  					item = self.currItem,
  					zoomRatio = item.fitRatio > 1 ? 1 : item.fitRatio,
  					w = zoomRatio * item.w,
  					h = zoomRatio * item.h;
  
  				s.width = w + 'px';
  				s.height = h + 'px';
  
  
  				s.left = _panOffset.x + 'px';
  				s.top = _panOffset.y + 'px';
  			}
  			
  		};
  	},
  
  	_onKeyDown = function(e) {
  		var keydownAction = '';
  		if(_options.escKey && e.keyCode === 27) { 
  			keydownAction = 'close';
  		} else if(_options.arrowKeys) {
  			if(e.keyCode === 37) {
  				keydownAction = 'prev';
  			} else if(e.keyCode === 39) { 
  				keydownAction = 'next';
  			}
  		}
  
  		if(keydownAction) {
  			// don't do anything if special key pressed to prevent from overriding default browser actions
  			// e.g. in Chrome on Mac cmd+arrow-left returns to previous page
  			if( !e.ctrlKey && !e.altKey && !e.shiftKey && !e.metaKey ) {
  				if(e.preventDefault) {
  					e.preventDefault();
  				} else {
  					e.returnValue = false;
  				} 
  				self[keydownAction]();
  			}
  		}
  	},
  
  	_onGlobalClick = function(e) {
  		if(!e) {
  			return;
  		}
  
  		// don't allow click event to pass through when triggering after drag or some other gesture
  		if(_moved || _zoomStarted || _mainScrollAnimating || _verticalDragInitiated) {
  			e.preventDefault();
  			e.stopPropagation();
  		}
  	},
  
  	_updatePageScrollOffset = function() {
  		self.setScrollOffset(0, framework.getScrollY());		
  	};
  	
  
  
  	
  
  
  
  // Micro animation engine
  var _animations = {},
  	_numAnimations = 0,
  	_stopAnimation = function(name) {
  		if(_animations[name]) {
  			if(_animations[name].raf) {
  				_cancelAF( _animations[name].raf );
  			}
  			_numAnimations--;
  			delete _animations[name];
  		}
  	},
  	_registerStartAnimation = function(name) {
  		if(_animations[name]) {
  			_stopAnimation(name);
  		}
  		if(!_animations[name]) {
  			_numAnimations++;
  			_animations[name] = {};
  		}
  	},
  	_stopAllAnimations = function() {
  		for (var prop in _animations) {
  
  			if( _animations.hasOwnProperty( prop ) ) {
  				_stopAnimation(prop);
  			} 
  			
  		}
  	},
  	_animateProp = function(name, b, endProp, d, easingFn, onUpdate, onComplete) {
  		var startAnimTime = _getCurrentTime(), t;
  		_registerStartAnimation(name);
  
  		var animloop = function(){
  			if ( _animations[name] ) {
  				
  				t = _getCurrentTime() - startAnimTime; // time diff
  				//b - beginning (start prop)
  				//d - anim duration
  
  				if ( t >= d ) {
  					_stopAnimation(name);
  					onUpdate(endProp);
  					if(onComplete) {
  						onComplete();
  					}
  					return;
  				}
  				onUpdate( (endProp - b) * easingFn(t/d) + b );
  
  				_animations[name].raf = _requestAF(animloop);
  			}
  		};
  		animloop();
  	};
  	
  
  
  var publicMethods = {
  
  	// make a few local variables and functions public
  	shout: _shout,
  	listen: _listen,
  	viewportSize: _viewportSize,
  	options: _options,
  
  	isMainScrollAnimating: function() {
  		return _mainScrollAnimating;
  	},
  	getZoomLevel: function() {
  		return _currZoomLevel;
  	},
  	getCurrentIndex: function() {
  		return _currentItemIndex;
  	},
  	isDragging: function() {
  		return _isDragging;
  	},	
  	isZooming: function() {
  		return _isZooming;
  	},
  	setScrollOffset: function(x,y) {
  		_offset.x = x;
  		_currentWindowScrollY = _offset.y = y;
  		_shout('updateScrollOffset', _offset);
  	},
  	applyZoomPan: function(zoomLevel,panX,panY,allowRenderResolution) {
  		_panOffset.x = panX;
  		_panOffset.y = panY;
  		_currZoomLevel = zoomLevel;
  		_applyCurrentZoomPan( allowRenderResolution );
  	},
  
  	init: function() {
  
  		if(_isOpen || _isDestroying) {
  			return;
  		}
  
  		var i;
  
  		self.framework = framework; // basic functionality
  		self.template = template; // root DOM element of PhotoSwipe
  		self.bg = framework.getChildByClass(template, 'pswp__bg');
  
  		_initalClassName = template.className;
  		_isOpen = true;
  				
  		_features = framework.detectFeatures();
  		_requestAF = _features.raf;
  		_cancelAF = _features.caf;
  		_transformKey = _features.transform;
  		_oldIE = _features.oldIE;
  		
  		self.scrollWrap = framework.getChildByClass(template, 'pswp__scroll-wrap');
  		self.container = framework.getChildByClass(self.scrollWrap, 'pswp__container');
  
  		_containerStyle = self.container.style; // for fast access
  
  		// Objects that hold slides (there are only 3 in DOM)
  		self.itemHolders = _itemHolders = [
  			{el:self.container.children[0] , wrap:0, index: -1},
  			{el:self.container.children[1] , wrap:0, index: -1},
  			{el:self.container.children[2] , wrap:0, index: -1}
  		];
  
  		// hide nearby item holders until initial zoom animation finishes (to avoid extra Paints)
  		_itemHolders[0].el.style.display = _itemHolders[2].el.style.display = 'none';
  
  		_setupTransforms();
  
  		// Setup global events
  		_globalEventHandlers = {
  			resize: self.updateSize,
  			scroll: _updatePageScrollOffset,
  			keydown: _onKeyDown,
  			click: _onGlobalClick
  		};
  
  		// disable show/hide effects on old browsers that don't support CSS animations or transforms, 
  		// old IOS, Android and Opera mobile. Blackberry seems to work fine, even older models.
  		var oldPhone = _features.isOldIOSPhone || _features.isOldAndroid || _features.isMobileOpera;
  		if(!_features.animationName || !_features.transform || oldPhone) {
  			_options.showAnimationDuration = _options.hideAnimationDuration = 0;
  		}
  
  		// init modules
  		for(i = 0; i < _modules.length; i++) {
  			self['init' + _modules[i]]();
  		}
  		
  		// init
  		if(UiClass) {
  			var ui = self.ui = new UiClass(self, framework);
  			ui.init();
  		}
  
  		_shout('firstUpdate');
  		_currentItemIndex = _currentItemIndex || _options.index || 0;
  		// validate index
  		if( isNaN(_currentItemIndex) || _currentItemIndex < 0 || _currentItemIndex >= _getNumItems() ) {
  			_currentItemIndex = 0;
  		}
  		self.currItem = _getItemAt( _currentItemIndex );
  
  		
  		if(_features.isOldIOSPhone || _features.isOldAndroid) {
  			_isFixedPosition = false;
  		}
  		
  		template.setAttribute('aria-hidden', 'false');
  		if(_options.modal) {
  			if(!_isFixedPosition) {
  				template.style.position = 'absolute';
  				template.style.top = framework.getScrollY() + 'px';
  			} else {
  				template.style.position = 'fixed';
  			}
  		}
  
  		if(_currentWindowScrollY === undefined) {
  			_shout('initialLayout');
  			_currentWindowScrollY = _initalWindowScrollY = framework.getScrollY();
  		}
  		
  		// add classes to root element of PhotoSwipe
  		var rootClasses = 'pswp--open ';
  		if(_options.mainClass) {
  			rootClasses += _options.mainClass + ' ';
  		}
  		if(_options.showHideOpacity) {
  			rootClasses += 'pswp--animate_opacity ';
  		}
  		rootClasses += _likelyTouchDevice ? 'pswp--touch' : 'pswp--notouch';
  		rootClasses += _features.animationName ? ' pswp--css_animation' : '';
  		rootClasses += _features.svg ? ' pswp--svg' : '';
  		framework.addClass(template, rootClasses);
  
  		self.updateSize();
  
  		// initial update
  		_containerShiftIndex = -1;
  		_indexDiff = null;
  		for(i = 0; i < NUM_HOLDERS; i++) {
  			_setTranslateX( (i+_containerShiftIndex) * _slideSize.x, _itemHolders[i].el.style);
  		}
  
  		if(!_oldIE) {
  			framework.bind(self.scrollWrap, _downEvents, self); // no dragging for old IE
  		}	
  
  		_listen('initialZoomInEnd', function() {
  			self.setContent(_itemHolders[0], _currentItemIndex-1);
  			self.setContent(_itemHolders[2], _currentItemIndex+1);
  
  			_itemHolders[0].el.style.display = _itemHolders[2].el.style.display = 'block';
  
  			if(_options.focus) {
  				// focus causes layout, 
  				// which causes lag during the animation, 
  				// that's why we delay it untill the initial zoom transition ends
  				template.focus();
  			}
  			 
  
  			_bindEvents();
  		});
  
  		// set content for center slide (first time)
  		self.setContent(_itemHolders[1], _currentItemIndex);
  		
  		self.updateCurrItem();
  
  		_shout('afterInit');
  
  		if(!_isFixedPosition) {
  
  			// On all versions of iOS lower than 8.0, we check size of viewport every second.
  			// 
  			// This is done to detect when Safari top & bottom bars appear, 
  			// as this action doesn't trigger any events (like resize). 
  			// 
  			// On iOS8 they fixed this.
  			// 
  			// 10 Nov 2014: iOS 7 usage ~40%. iOS 8 usage 56%.
  			
  			_updateSizeInterval = setInterval(function() {
  				if(!_numAnimations && !_isDragging && !_isZooming && (_currZoomLevel === self.currItem.initialZoomLevel)  ) {
  					self.updateSize();
  				}
  			}, 1000);
  		}
  
  		framework.addClass(template, 'pswp--visible');
  	},
  
  	// Close the gallery, then destroy it
  	close: function() {
  		if(!_isOpen) {
  			return;
  		}
  
  		_isOpen = false;
  		_isDestroying = true;
  		_shout('close');
  		_unbindEvents();
  
  		_showOrHide(self.currItem, null, true, self.destroy);
  	},
  
  	// destroys the gallery (unbinds events, cleans up intervals and timeouts to avoid memory leaks)
  	destroy: function() {
  		_shout('destroy');
  
  		if(_showOrHideTimeout) {
  			clearTimeout(_showOrHideTimeout);
  		}
  		
  		template.setAttribute('aria-hidden', 'true');
  		template.className = _initalClassName;
  
  		if(_updateSizeInterval) {
  			clearInterval(_updateSizeInterval);
  		}
  
  		framework.unbind(self.scrollWrap, _downEvents, self);
  
  		// we unbind scroll event at the end, as closing animation may depend on it
  		framework.unbind(window, 'scroll', self);
  
  		_stopDragUpdateLoop();
  
  		_stopAllAnimations();
  
  		_listeners = null;
  	},
  
  	/**
  	 * Pan image to position
  	 * @param {Number} x     
  	 * @param {Number} y     
  	 * @param {Boolean} force Will ignore bounds if set to true.
  	 */
  	panTo: function(x,y,force) {
  		if(!force) {
  			if(x > _currPanBounds.min.x) {
  				x = _currPanBounds.min.x;
  			} else if(x < _currPanBounds.max.x) {
  				x = _currPanBounds.max.x;
  			}
  
  			if(y > _currPanBounds.min.y) {
  				y = _currPanBounds.min.y;
  			} else if(y < _currPanBounds.max.y) {
  				y = _currPanBounds.max.y;
  			}
  		}
  		
  		_panOffset.x = x;
  		_panOffset.y = y;
  		_applyCurrentZoomPan();
  	},
  	
  	handleEvent: function (e) {
  		e = e || window.event;
  		if(_globalEventHandlers[e.type]) {
  			_globalEventHandlers[e.type](e);
  		}
  	},
  
  
  	goTo: function(index) {
  
  		index = _getLoopedId(index);
  
  		var diff = index - _currentItemIndex;
  		_indexDiff = diff;
  
  		_currentItemIndex = index;
  		self.currItem = _getItemAt( _currentItemIndex );
  		_currPositionIndex -= diff;
  		
  		_moveMainScroll(_slideSize.x * _currPositionIndex);
  		
  
  		_stopAllAnimations();
  		_mainScrollAnimating = false;
  
  		self.updateCurrItem();
  	},
  	next: function() {
  		self.goTo( _currentItemIndex + 1);
  	},
  	prev: function() {
  		self.goTo( _currentItemIndex - 1);
  	},
  
  	// update current zoom/pan objects
  	updateCurrZoomItem: function(emulateSetContent) {
  		if(emulateSetContent) {
  			_shout('beforeChange', 0);
  		}
  
  		// itemHolder[1] is middle (current) item
  		if(_itemHolders[1].el.children.length) {
  			var zoomElement = _itemHolders[1].el.children[0];
  			if( framework.hasClass(zoomElement, 'pswp__zoom-wrap') ) {
  				_currZoomElementStyle = zoomElement.style;
  			} else {
  				_currZoomElementStyle = null;
  			}
  		} else {
  			_currZoomElementStyle = null;
  		}
  		
  		_currPanBounds = self.currItem.bounds;	
  		_startZoomLevel = _currZoomLevel = self.currItem.initialZoomLevel;
  
  		_panOffset.x = _currPanBounds.center.x;
  		_panOffset.y = _currPanBounds.center.y;
  
  		if(emulateSetContent) {
  			_shout('afterChange');
  		}
  	},
  
  
  	invalidateCurrItems: function() {
  		_itemsNeedUpdate = true;
  		for(var i = 0; i < NUM_HOLDERS; i++) {
  			if( _itemHolders[i].item ) {
  				_itemHolders[i].item.needsUpdate = true;
  			}
  		}
  	},
  
  	updateCurrItem: function(beforeAnimation) {
  
  		if(_indexDiff === 0) {
  			return;
  		}
  
  		var diffAbs = Math.abs(_indexDiff),
  			tempHolder;
  
  		if(beforeAnimation && diffAbs < 2) {
  			return;
  		}
  
  
  		self.currItem = _getItemAt( _currentItemIndex );
  		_renderMaxResolution = false;
  		
  		_shout('beforeChange', _indexDiff);
  
  		if(diffAbs >= NUM_HOLDERS) {
  			_containerShiftIndex += _indexDiff + (_indexDiff > 0 ? -NUM_HOLDERS : NUM_HOLDERS);
  			diffAbs = NUM_HOLDERS;
  		}
  		for(var i = 0; i < diffAbs; i++) {
  			if(_indexDiff > 0) {
  				tempHolder = _itemHolders.shift();
  				_itemHolders[NUM_HOLDERS-1] = tempHolder; // move first to last
  
  				_containerShiftIndex++;
  				_setTranslateX( (_containerShiftIndex+2) * _slideSize.x, tempHolder.el.style);
  				self.setContent(tempHolder, _currentItemIndex - diffAbs + i + 1 + 1);
  			} else {
  				tempHolder = _itemHolders.pop();
  				_itemHolders.unshift( tempHolder ); // move last to first
  
  				_containerShiftIndex--;
  				_setTranslateX( _containerShiftIndex * _slideSize.x, tempHolder.el.style);
  				self.setContent(tempHolder, _currentItemIndex + diffAbs - i - 1 - 1);
  			}
  			
  		}
  
  		// reset zoom/pan on previous item
  		if(_currZoomElementStyle && Math.abs(_indexDiff) === 1) {
  
  			var prevItem = _getItemAt(_prevItemIndex);
  			if(prevItem.initialZoomLevel !== _currZoomLevel) {
  				_calculateItemSize(prevItem , _viewportSize );
  				_setImageSize(prevItem);
  				_applyZoomPanToItem( prevItem ); 				
  			}
  
  		}
  
  		// reset diff after update
  		_indexDiff = 0;
  
  		self.updateCurrZoomItem();
  
  		_prevItemIndex = _currentItemIndex;
  
  		_shout('afterChange');
  		
  	},
  
  
  
  	updateSize: function(force) {
  		
  		if(!_isFixedPosition && _options.modal) {
  			var windowScrollY = framework.getScrollY();
  			if(_currentWindowScrollY !== windowScrollY) {
  				template.style.top = windowScrollY + 'px';
  				_currentWindowScrollY = windowScrollY;
  			}
  			if(!force && _windowVisibleSize.x === window.innerWidth && _windowVisibleSize.y === window.innerHeight) {
  				return;
  			}
  			_windowVisibleSize.x = window.innerWidth;
  			_windowVisibleSize.y = window.innerHeight;
  
  			//template.style.width = _windowVisibleSize.x + 'px';
  			template.style.height = _windowVisibleSize.y + 'px';
  		}
  
  
  
  		_viewportSize.x = self.scrollWrap.clientWidth;
  		_viewportSize.y = self.scrollWrap.clientHeight;
  
  		_updatePageScrollOffset();
  
  		_slideSize.x = _viewportSize.x + Math.round(_viewportSize.x * _options.spacing);
  		_slideSize.y = _viewportSize.y;
  
  		_moveMainScroll(_slideSize.x * _currPositionIndex);
  
  		_shout('beforeResize'); // even may be used for example to switch image sources
  
  
  		// don't re-calculate size on inital size update
  		if(_containerShiftIndex !== undefined) {
  
  			var holder,
  				item,
  				hIndex;
  
  			for(var i = 0; i < NUM_HOLDERS; i++) {
  				holder = _itemHolders[i];
  				_setTranslateX( (i+_containerShiftIndex) * _slideSize.x, holder.el.style);
  
  				hIndex = _currentItemIndex+i-1;
  
  				if(_options.loop && _getNumItems() > 2) {
  					hIndex = _getLoopedId(hIndex);
  				}
  
  				// update zoom level on items and refresh source (if needsUpdate)
  				item = _getItemAt( hIndex );
  
  				// re-render gallery item if `needsUpdate`,
  				// or doesn't have `bounds` (entirely new slide object)
  				if( item && (_itemsNeedUpdate || item.needsUpdate || !item.bounds) ) {
  
  					self.cleanSlide( item );
  					
  					self.setContent( holder, hIndex );
  
  					// if "center" slide
  					if(i === 1) {
  						self.currItem = item;
  						self.updateCurrZoomItem(true);
  					}
  
  					item.needsUpdate = false;
  
  				} else if(holder.index === -1 && hIndex >= 0) {
  					// add content first time
  					self.setContent( holder, hIndex );
  				}
  				if(item && item.container) {
  					_calculateItemSize(item, _viewportSize);
  					_setImageSize(item);
  					_applyZoomPanToItem( item );
  				}
  				
  			}
  			_itemsNeedUpdate = false;
  		}	
  
  		_startZoomLevel = _currZoomLevel = self.currItem.initialZoomLevel;
  		_currPanBounds = self.currItem.bounds;
  
  		if(_currPanBounds) {
  			_panOffset.x = _currPanBounds.center.x;
  			_panOffset.y = _currPanBounds.center.y;
  			_applyCurrentZoomPan( true );
  		}
  		
  		_shout('resize');
  	},
  	
  	// Zoom current item to
  	zoomTo: function(destZoomLevel, centerPoint, speed, easingFn, updateFn) {
  		/*
  			if(destZoomLevel === 'fit') {
  				destZoomLevel = self.currItem.fitRatio;
  			} else if(destZoomLevel === 'fill') {
  				destZoomLevel = self.currItem.fillRatio;
  			}
  		*/
  
  		if(centerPoint) {
  			_startZoomLevel = _currZoomLevel;
  			_midZoomPoint.x = Math.abs(centerPoint.x) - _panOffset.x ;
  			_midZoomPoint.y = Math.abs(centerPoint.y) - _panOffset.y ;
  			_equalizePoints(_startPanOffset, _panOffset);
  		}
  
  		var destPanBounds = _calculatePanBounds(destZoomLevel, false),
  			destPanOffset = {};
  
  		_modifyDestPanOffset('x', destPanBounds, destPanOffset, destZoomLevel);
  		_modifyDestPanOffset('y', destPanBounds, destPanOffset, destZoomLevel);
  
  		var initialZoomLevel = _currZoomLevel;
  		var initialPanOffset = {
  			x: _panOffset.x,
  			y: _panOffset.y
  		};
  
  		_roundPoint(destPanOffset);
  
  		var onUpdate = function(now) {
  			if(now === 1) {
  				_currZoomLevel = destZoomLevel;
  				_panOffset.x = destPanOffset.x;
  				_panOffset.y = destPanOffset.y;
  			} else {
  				_currZoomLevel = (destZoomLevel - initialZoomLevel) * now + initialZoomLevel;
  				_panOffset.x = (destPanOffset.x - initialPanOffset.x) * now + initialPanOffset.x;
  				_panOffset.y = (destPanOffset.y - initialPanOffset.y) * now + initialPanOffset.y;
  			}
  
  			if(updateFn) {
  				updateFn(now);
  			}
  
  			_applyCurrentZoomPan( now === 1 );
  		};
  
  		if(speed) {
  			_animateProp('customZoomTo', 0, 1, speed, easingFn || framework.easing.sine.inOut, onUpdate);
  		} else {
  			onUpdate(1);
  		}
  	}
  
  
  };
  
  
  /*>>core*/
  
  /*>>gestures*/
  /**
   * Mouse/touch/pointer event handlers.
   * 
   * separated from @core.js for readability
   */
  
  var MIN_SWIPE_DISTANCE = 30,
  	DIRECTION_CHECK_OFFSET = 10; // amount of pixels to drag to determine direction of swipe
  
  var _gestureStartTime,
  	_gestureCheckSpeedTime,
  
  	// pool of objects that are used during dragging of zooming
  	p = {}, // first point
  	p2 = {}, // second point (for zoom gesture)
  	delta = {},
  	_currPoint = {},
  	_startPoint = {},
  	_currPointers = [],
  	_startMainScrollPos = {},
  	_releaseAnimData,
  	_posPoints = [], // array of points during dragging, used to determine type of gesture
  	_tempPoint = {},
  
  	_isZoomingIn,
  	_verticalDragInitiated,
  	_oldAndroidTouchEndTimeout,
  	_currZoomedItemIndex = 0,
  	_centerPoint = _getEmptyPoint(),
  	_lastReleaseTime = 0,
  	_isDragging, // at least one pointer is down
  	_isMultitouch, // at least two _pointers are down
  	_zoomStarted, // zoom level changed during zoom gesture
  	_moved,
  	_dragAnimFrame,
  	_mainScrollShifted,
  	_currentPoints, // array of current touch points
  	_isZooming,
  	_currPointsDistance,
  	_startPointsDistance,
  	_currPanBounds,
  	_mainScrollPos = _getEmptyPoint(),
  	_currZoomElementStyle,
  	_mainScrollAnimating, // true, if animation after swipe gesture is running
  	_midZoomPoint = _getEmptyPoint(),
  	_currCenterPoint = _getEmptyPoint(),
  	_direction,
  	_isFirstMove,
  	_opacityChanged,
  	_bgOpacity,
  	_wasOverInitialZoom,
  
  	_isEqualPoints = function(p1, p2) {
  		return p1.x === p2.x && p1.y === p2.y;
  	},
  	_isNearbyPoints = function(touch0, touch1) {
  		return Math.abs(touch0.x - touch1.x) < DOUBLE_TAP_RADIUS && Math.abs(touch0.y - touch1.y) < DOUBLE_TAP_RADIUS;
  	},
  	_calculatePointsDistance = function(p1, p2) {
  		_tempPoint.x = Math.abs( p1.x - p2.x );
  		_tempPoint.y = Math.abs( p1.y - p2.y );
  		return Math.sqrt(_tempPoint.x * _tempPoint.x + _tempPoint.y * _tempPoint.y);
  	},
  	_stopDragUpdateLoop = function() {
  		if(_dragAnimFrame) {
  			_cancelAF(_dragAnimFrame);
  			_dragAnimFrame = null;
  		}
  	},
  	_dragUpdateLoop = function() {
  		if(_isDragging) {
  			_dragAnimFrame = _requestAF(_dragUpdateLoop);
  			_renderMovement();
  		}
  	},
  	_canPan = function() {
  		return !(_options.scaleMode === 'fit' && _currZoomLevel ===  self.currItem.initialZoomLevel);
  	},
  	
  	// find the closest parent DOM element
  	_closestElement = function(el, fn) {
  	  	if(!el || el === document) {
  	  		return false;
  	  	}
  
  	  	// don't search elements above pswp__scroll-wrap
  	  	if(el.getAttribute('class') && el.getAttribute('class').indexOf('pswp__scroll-wrap') > -1 ) {
  	  		return false;
  	  	}
  
  	  	if( fn(el) ) {
  	  		return el;
  	  	}
  
  	  	return _closestElement(el.parentNode, fn);
  	},
  
  	_preventObj = {},
  	_preventDefaultEventBehaviour = function(e, isDown) {
  	    _preventObj.prevent = !_closestElement(e.target, _options.isClickableElement);
  
  		_shout('preventDragEvent', e, isDown, _preventObj);
  		return _preventObj.prevent;
  
  	},
  	_convertTouchToPoint = function(touch, p) {
  		p.x = touch.pageX;
  		p.y = touch.pageY;
  		p.id = touch.identifier;
  		return p;
  	},
  	_findCenterOfPoints = function(p1, p2, pCenter) {
  		pCenter.x = (p1.x + p2.x) * 0.5;
  		pCenter.y = (p1.y + p2.y) * 0.5;
  	},
  	_pushPosPoint = function(time, x, y) {
  		if(time - _gestureCheckSpeedTime > 50) {
  			var o = _posPoints.length > 2 ? _posPoints.shift() : {};
  			o.x = x;
  			o.y = y; 
  			_posPoints.push(o);
  			_gestureCheckSpeedTime = time;
  		}
  	},
  
  	_calculateVerticalDragOpacityRatio = function() {
  		var yOffset = _panOffset.y - self.currItem.initialPosition.y; // difference between initial and current position
  		return 1 -  Math.abs( yOffset / (_viewportSize.y / 2)  );
  	},
  
  	
  	// points pool, reused during touch events
  	_ePoint1 = {},
  	_ePoint2 = {},
  	_tempPointsArr = [],
  	_tempCounter,
  	_getTouchPoints = function(e) {
  		// clean up previous points, without recreating array
  		while(_tempPointsArr.length > 0) {
  			_tempPointsArr.pop();
  		}
  
  		if(!_pointerEventEnabled) {
  			if(e.type.indexOf('touch') > -1) {
  
  				if(e.touches && e.touches.length > 0) {
  					_tempPointsArr[0] = _convertTouchToPoint(e.touches[0], _ePoint1);
  					if(e.touches.length > 1) {
  						_tempPointsArr[1] = _convertTouchToPoint(e.touches[1], _ePoint2);
  					}
  				}
  				
  			} else {
  				_ePoint1.x = e.pageX;
  				_ePoint1.y = e.pageY;
  				_ePoint1.id = '';
  				_tempPointsArr[0] = _ePoint1;//_ePoint1;
  			}
  		} else {
  			_tempCounter = 0;
  			// we can use forEach, as pointer events are supported only in modern browsers
  			_currPointers.forEach(function(p) {
  				if(_tempCounter === 0) {
  					_tempPointsArr[0] = p;
  				} else if(_tempCounter === 1) {
  					_tempPointsArr[1] = p;
  				}
  				_tempCounter++;
  
  			});
  		}
  		return _tempPointsArr;
  	},
  
  	_panOrMoveMainScroll = function(axis, delta) {
  
  		var panFriction,
  			overDiff = 0,
  			newOffset = _panOffset[axis] + delta[axis],
  			startOverDiff,
  			dir = delta[axis] > 0,
  			newMainScrollPosition = _mainScrollPos.x + delta.x,
  			mainScrollDiff = _mainScrollPos.x - _startMainScrollPos.x,
  			newPanPos,
  			newMainScrollPos;
  
  		// calculate fdistance over the bounds and friction
  		if(newOffset > _currPanBounds.min[axis] || newOffset < _currPanBounds.max[axis]) {
  			panFriction = _options.panEndFriction;
  			// Linear increasing of friction, so at 1/4 of viewport it's at max value. 
  			// Looks not as nice as was expected. Left for history.
  			// panFriction = (1 - (_panOffset[axis] + delta[axis] + panBounds.min[axis]) / (_viewportSize[axis] / 4) );
  		} else {
  			panFriction = 1;
  		}
  		
  		newOffset = _panOffset[axis] + delta[axis] * panFriction;
  
  		// move main scroll or start panning
  		if(_options.allowPanToNext || _currZoomLevel === self.currItem.initialZoomLevel) {
  
  
  			if(!_currZoomElementStyle) {
  				
  				newMainScrollPos = newMainScrollPosition;
  
  			} else if(_direction === 'h' && axis === 'x' && !_zoomStarted ) {
  				
  				if(dir) {
  					if(newOffset > _currPanBounds.min[axis]) {
  						panFriction = _options.panEndFriction;
  						overDiff = _currPanBounds.min[axis] - newOffset;
  						startOverDiff = _currPanBounds.min[axis] - _startPanOffset[axis];
  					}
  					
  					// drag right
  					if( (startOverDiff <= 0 || mainScrollDiff < 0) && _getNumItems() > 1 ) {
  						newMainScrollPos = newMainScrollPosition;
  						if(mainScrollDiff < 0 && newMainScrollPosition > _startMainScrollPos.x) {
  							newMainScrollPos = _startMainScrollPos.x;
  						}
  					} else {
  						if(_currPanBounds.min.x !== _currPanBounds.max.x) {
  							newPanPos = newOffset;
  						}
  						
  					}
  
  				} else {
  
  					if(newOffset < _currPanBounds.max[axis] ) {
  						panFriction =_options.panEndFriction;
  						overDiff = newOffset - _currPanBounds.max[axis];
  						startOverDiff = _startPanOffset[axis] - _currPanBounds.max[axis];
  					}
  
  					if( (startOverDiff <= 0 || mainScrollDiff > 0) && _getNumItems() > 1 ) {
  						newMainScrollPos = newMainScrollPosition;
  
  						if(mainScrollDiff > 0 && newMainScrollPosition < _startMainScrollPos.x) {
  							newMainScrollPos = _startMainScrollPos.x;
  						}
  
  					} else {
  						if(_currPanBounds.min.x !== _currPanBounds.max.x) {
  							newPanPos = newOffset;
  						}
  					}
  
  				}
  
  
  				//
  			}
  
  			if(axis === 'x') {
  
  				if(newMainScrollPos !== undefined) {
  					_moveMainScroll(newMainScrollPos, true);
  					if(newMainScrollPos === _startMainScrollPos.x) {
  						_mainScrollShifted = false;
  					} else {
  						_mainScrollShifted = true;
  					}
  				}
  
  				if(_currPanBounds.min.x !== _currPanBounds.max.x) {
  					if(newPanPos !== undefined) {
  						_panOffset.x = newPanPos;
  					} else if(!_mainScrollShifted) {
  						_panOffset.x += delta.x * panFriction;
  					}
  				}
  
  				return newMainScrollPos !== undefined;
  			}
  
  		}
  
  		if(!_mainScrollAnimating) {
  			
  			if(!_mainScrollShifted) {
  				if(_currZoomLevel > self.currItem.fitRatio) {
  					_panOffset[axis] += delta[axis] * panFriction;
  				
  				}
  			}
  
  			
  		}
  		
  	},
  
  	// Pointerdown/touchstart/mousedown handler
  	_onDragStart = function(e) {
  
  		// Allow dragging only via left mouse button.
  		// As this handler is not added in IE8 - we ignore e.which
  		// 
  		// http://www.quirksmode.org/js/events_properties.html
  		// https://developer.mozilla.org/en-US/docs/Web/API/event.button
  		if(e.type === 'mousedown' && e.button > 0  ) {
  			return;
  		}
  
  		if(_initialZoomRunning) {
  			e.preventDefault();
  			return;
  		}
  
  		if(_oldAndroidTouchEndTimeout && e.type === 'mousedown') {
  			return;
  		}
  
  		if(_preventDefaultEventBehaviour(e, true)) {
  			e.preventDefault();
  		}
  
  
  
  		_shout('pointerDown');
  
  		if(_pointerEventEnabled) {
  			var pointerIndex = framework.arraySearch(_currPointers, e.pointerId, 'id');
  			if(pointerIndex < 0) {
  				pointerIndex = _currPointers.length;
  			}
  			_currPointers[pointerIndex] = {x:e.pageX, y:e.pageY, id: e.pointerId};
  		}
  		
  
  
  		var startPointsList = _getTouchPoints(e),
  			numPoints = startPointsList.length;
  
  		_currentPoints = null;
  
  		_stopAllAnimations();
  
  		// init drag
  		if(!_isDragging || numPoints === 1) {
  
  			
  
  			_isDragging = _isFirstMove = true;
  			framework.bind(window, _upMoveEvents, self);
  
  			_isZoomingIn = 
  				_wasOverInitialZoom = 
  				_opacityChanged = 
  				_verticalDragInitiated = 
  				_mainScrollShifted = 
  				_moved = 
  				_isMultitouch = 
  				_zoomStarted = false;
  
  			_direction = null;
  
  			_shout('firstTouchStart', startPointsList);
  
  			_equalizePoints(_startPanOffset, _panOffset);
  
  			_currPanDist.x = _currPanDist.y = 0;
  			_equalizePoints(_currPoint, startPointsList[0]);
  			_equalizePoints(_startPoint, _currPoint);
  
  			//_equalizePoints(_startMainScrollPos, _mainScrollPos);
  			_startMainScrollPos.x = _slideSize.x * _currPositionIndex;
  
  			_posPoints = [{
  				x: _currPoint.x,
  				y: _currPoint.y
  			}];
  
  			_gestureCheckSpeedTime = _gestureStartTime = _getCurrentTime();
  
  			//_mainScrollAnimationEnd(true);
  			_calculatePanBounds( _currZoomLevel, true );
  			
  			// Start rendering
  			_stopDragUpdateLoop();
  			_dragUpdateLoop();
  			
  		}
  
  		// init zoom
  		if(!_isZooming && numPoints > 1 && !_mainScrollAnimating && !_mainScrollShifted) {
  			_startZoomLevel = _currZoomLevel;
  			_zoomStarted = false; // true if zoom changed at least once
  
  			_isZooming = _isMultitouch = true;
  			_currPanDist.y = _currPanDist.x = 0;
  
  			_equalizePoints(_startPanOffset, _panOffset);
  
  			_equalizePoints(p, startPointsList[0]);
  			_equalizePoints(p2, startPointsList[1]);
  
  			_findCenterOfPoints(p, p2, _currCenterPoint);
  
  			_midZoomPoint.x = Math.abs(_currCenterPoint.x) - _panOffset.x;
  			_midZoomPoint.y = Math.abs(_currCenterPoint.y) - _panOffset.y;
  			_currPointsDistance = _startPointsDistance = _calculatePointsDistance(p, p2);
  		}
  
  
  	},
  
  	// Pointermove/touchmove/mousemove handler
  	_onDragMove = function(e) {
  
  		e.preventDefault();
  
  		if(_pointerEventEnabled) {
  			var pointerIndex = framework.arraySearch(_currPointers, e.pointerId, 'id');
  			if(pointerIndex > -1) {
  				var p = _currPointers[pointerIndex];
  				p.x = e.pageX;
  				p.y = e.pageY; 
  			}
  		}
  
  		if(_isDragging) {
  			var touchesList = _getTouchPoints(e);
  			if(!_direction && !_moved && !_isZooming) {
  
  				if(_mainScrollPos.x !== _slideSize.x * _currPositionIndex) {
  					// if main scroll position is shifted – direction is always horizontal
  					_direction = 'h';
  				} else {
  					var diff = Math.abs(touchesList[0].x - _currPoint.x) - Math.abs(touchesList[0].y - _currPoint.y);
  					// check the direction of movement
  					if(Math.abs(diff) >= DIRECTION_CHECK_OFFSET) {
  						_direction = diff > 0 ? 'h' : 'v';
  						_currentPoints = touchesList;
  					}
  				}
  				
  			} else {
  				_currentPoints = touchesList;
  			}
  		}	
  	},
  	// 
  	_renderMovement =  function() {
  
  		if(!_currentPoints) {
  			return;
  		}
  
  		var numPoints = _currentPoints.length;
  
  		if(numPoints === 0) {
  			return;
  		}
  
  		_equalizePoints(p, _currentPoints[0]);
  
  		delta.x = p.x - _currPoint.x;
  		delta.y = p.y - _currPoint.y;
  
  		if(_isZooming && numPoints > 1) {
  			// Handle behaviour for more than 1 point
  
  			_currPoint.x = p.x;
  			_currPoint.y = p.y;
  		
  			// check if one of two points changed
  			if( !delta.x && !delta.y && _isEqualPoints(_currentPoints[1], p2) ) {
  				return;
  			}
  
  			_equalizePoints(p2, _currentPoints[1]);
  
  
  			if(!_zoomStarted) {
  				_zoomStarted = true;
  				_shout('zoomGestureStarted');
  			}
  			
  			// Distance between two points
  			var pointsDistance = _calculatePointsDistance(p,p2);
  
  			var zoomLevel = _calculateZoomLevel(pointsDistance);
  
  			// slightly over the of initial zoom level
  			if(zoomLevel > self.currItem.initialZoomLevel + self.currItem.initialZoomLevel / 15) {
  				_wasOverInitialZoom = true;
  			}
  
  			// Apply the friction if zoom level is out of the bounds
  			var zoomFriction = 1,
  				minZoomLevel = _getMinZoomLevel(),
  				maxZoomLevel = _getMaxZoomLevel();
  
  			if ( zoomLevel < minZoomLevel ) {
  				
  				if(_options.pinchToClose && !_wasOverInitialZoom && _startZoomLevel <= self.currItem.initialZoomLevel) {
  					// fade out background if zooming out
  					var minusDiff = minZoomLevel - zoomLevel;
  					var percent = 1 - minusDiff / (minZoomLevel / 1.2);
  
  					_applyBgOpacity(percent);
  					_shout('onPinchClose', percent);
  					_opacityChanged = true;
  				} else {
  					zoomFriction = (minZoomLevel - zoomLevel) / minZoomLevel;
  					if(zoomFriction > 1) {
  						zoomFriction = 1;
  					}
  					zoomLevel = minZoomLevel - zoomFriction * (minZoomLevel / 3);
  				}
  				
  			} else if ( zoomLevel > maxZoomLevel ) {
  				// 1.5 - extra zoom level above the max. E.g. if max is x6, real max 6 + 1.5 = 7.5
  				zoomFriction = (zoomLevel - maxZoomLevel) / ( minZoomLevel * 6 );
  				if(zoomFriction > 1) {
  					zoomFriction = 1;
  				}
  				zoomLevel = maxZoomLevel + zoomFriction * minZoomLevel;
  			}
  
  			if(zoomFriction < 0) {
  				zoomFriction = 0;
  			}
  
  			// distance between touch points after friction is applied
  			_currPointsDistance = pointsDistance;
  
  			// _centerPoint - The point in the middle of two pointers
  			_findCenterOfPoints(p, p2, _centerPoint);
  		
  			// paning with two pointers pressed
  			_currPanDist.x += _centerPoint.x - _currCenterPoint.x;
  			_currPanDist.y += _centerPoint.y - _currCenterPoint.y;
  			_equalizePoints(_currCenterPoint, _centerPoint);
  
  			_panOffset.x = _calculatePanOffset('x', zoomLevel);
  			_panOffset.y = _calculatePanOffset('y', zoomLevel);
  
  			_isZoomingIn = zoomLevel > _currZoomLevel;
  			_currZoomLevel = zoomLevel;
  			_applyCurrentZoomPan();
  
  		} else {
  
  			// handle behaviour for one point (dragging or panning)
  
  			if(!_direction) {
  				return;
  			}
  
  			if(_isFirstMove) {
  				_isFirstMove = false;
  
  				// subtract drag distance that was used during the detection direction  
  
  				if( Math.abs(delta.x) >= DIRECTION_CHECK_OFFSET) {
  					delta.x -= _currentPoints[0].x - _startPoint.x;
  				}
  				
  				if( Math.abs(delta.y) >= DIRECTION_CHECK_OFFSET) {
  					delta.y -= _currentPoints[0].y - _startPoint.y;
  				}
  			}
  
  			_currPoint.x = p.x;
  			_currPoint.y = p.y;
  
  			// do nothing if pointers position hasn't changed
  			if(delta.x === 0 && delta.y === 0) {
  				return;
  			}
  
  			if(_direction === 'v' && _options.closeOnVerticalDrag) {
  				if(!_canPan()) {
  					_currPanDist.y += delta.y;
  					_panOffset.y += delta.y;
  
  					var opacityRatio = _calculateVerticalDragOpacityRatio();
  
  					_verticalDragInitiated = true;
  					_shout('onVerticalDrag', opacityRatio);
  
  					_applyBgOpacity(opacityRatio);
  					_applyCurrentZoomPan();
  					return ;
  				}
  			}
  
  			_pushPosPoint(_getCurrentTime(), p.x, p.y);
  
  			_moved = true;
  			_currPanBounds = self.currItem.bounds;
  			
  			var mainScrollChanged = _panOrMoveMainScroll('x', delta);
  			if(!mainScrollChanged) {
  				_panOrMoveMainScroll('y', delta);
  
  				_roundPoint(_panOffset);
  				_applyCurrentZoomPan();
  			}
  
  		}
  
  	},
  	
  	// Pointerup/pointercancel/touchend/touchcancel/mouseup event handler
  	_onDragRelease = function(e) {
  
  		if(_features.isOldAndroid ) {
  
  			if(_oldAndroidTouchEndTimeout && e.type === 'mouseup') {
  				return;
  			}
  
  			// on Android (v4.1, 4.2, 4.3 & possibly older) 
  			// ghost mousedown/up event isn't preventable via e.preventDefault,
  			// which causes fake mousedown event
  			// so we block mousedown/up for 600ms
  			if( e.type.indexOf('touch') > -1 ) {
  				clearTimeout(_oldAndroidTouchEndTimeout);
  				_oldAndroidTouchEndTimeout = setTimeout(function() {
  					_oldAndroidTouchEndTimeout = 0;
  				}, 600);
  			}
  			
  		}
  
  		_shout('pointerUp');
  
  		if(_preventDefaultEventBehaviour(e, false)) {
  			e.preventDefault();
  		}
  
  		var releasePoint;
  
  		if(_pointerEventEnabled) {
  			var pointerIndex = framework.arraySearch(_currPointers, e.pointerId, 'id');
  			
  			if(pointerIndex > -1) {
  				releasePoint = _currPointers.splice(pointerIndex, 1)[0];
  
  				if(navigator.pointerEnabled) {
  					releasePoint.type = e.pointerType || 'mouse';
  				} else {
  					var MSPOINTER_TYPES = {
  						4: 'mouse', // event.MSPOINTER_TYPE_MOUSE
  						2: 'touch', // event.MSPOINTER_TYPE_TOUCH 
  						3: 'pen' // event.MSPOINTER_TYPE_PEN
  					};
  					releasePoint.type = MSPOINTER_TYPES[e.pointerType];
  
  					if(!releasePoint.type) {
  						releasePoint.type = e.pointerType || 'mouse';
  					}
  				}
  
  			}
  		}
  
  		var touchList = _getTouchPoints(e),
  			gestureType,
  			numPoints = touchList.length;
  
  		if(e.type === 'mouseup') {
  			numPoints = 0;
  		}
  
  		// Do nothing if there were 3 touch points or more
  		if(numPoints === 2) {
  			_currentPoints = null;
  			return true;
  		}
  
  		// if second pointer released
  		if(numPoints === 1) {
  			_equalizePoints(_startPoint, touchList[0]);
  		}				
  
  
  		// pointer hasn't moved, send "tap release" point
  		if(numPoints === 0 && !_direction && !_mainScrollAnimating) {
  			if(!releasePoint) {
  				if(e.type === 'mouseup') {
  					releasePoint = {x: e.pageX, y: e.pageY, type:'mouse'};
  				} else if(e.changedTouches && e.changedTouches[0]) {
  					releasePoint = {x: e.changedTouches[0].pageX, y: e.changedTouches[0].pageY, type:'touch'};
  				}		
  			}
  
  			_shout('touchRelease', e, releasePoint);
  		}
  
  		// Difference in time between releasing of two last touch points (zoom gesture)
  		var releaseTimeDiff = -1;
  
  		// Gesture completed, no pointers left
  		if(numPoints === 0) {
  			_isDragging = false;
  			framework.unbind(window, _upMoveEvents, self);
  
  			_stopDragUpdateLoop();
  
  			if(_isZooming) {
  				// Two points released at the same time
  				releaseTimeDiff = 0;
  			} else if(_lastReleaseTime !== -1) {
  				releaseTimeDiff = _getCurrentTime() - _lastReleaseTime;
  			}
  		}
  		_lastReleaseTime = numPoints === 1 ? _getCurrentTime() : -1;
  		
  		if(releaseTimeDiff !== -1 && releaseTimeDiff < 150) {
  			gestureType = 'zoom';
  		} else {
  			gestureType = 'swipe';
  		}
  
  		if(_isZooming && numPoints < 2) {
  			_isZooming = false;
  
  			// Only second point released
  			if(numPoints === 1) {
  				gestureType = 'zoomPointerUp';
  			}
  			_shout('zoomGestureEnded');
  		}
  
  		_currentPoints = null;
  		if(!_moved && !_zoomStarted && !_mainScrollAnimating && !_verticalDragInitiated) {
  			// nothing to animate
  			return;
  		}
  	
  		_stopAllAnimations();
  
  		
  		if(!_releaseAnimData) {
  			_releaseAnimData = _initDragReleaseAnimationData();
  		}
  		
  		_releaseAnimData.calculateSwipeSpeed('x');
  
  
  		if(_verticalDragInitiated) {
  
  			var opacityRatio = _calculateVerticalDragOpacityRatio();
  
  			if(opacityRatio < _options.verticalDragRange) {
  				self.close();
  			} else {
  				var initalPanY = _panOffset.y,
  					initialBgOpacity = _bgOpacity;
  
  				_animateProp('verticalDrag', 0, 1, 300, framework.easing.cubic.out, function(now) {
  					
  					_panOffset.y = (self.currItem.initialPosition.y - initalPanY) * now + initalPanY;
  
  					_applyBgOpacity(  (1 - initialBgOpacity) * now + initialBgOpacity );
  					_applyCurrentZoomPan();
  				});
  
  				_shout('onVerticalDrag', 1);
  			}
  
  			return;
  		}
  
  
  		// main scroll 
  		if(  (_mainScrollShifted || _mainScrollAnimating) && numPoints === 0) {
  			var itemChanged = _finishSwipeMainScrollGesture(gestureType, _releaseAnimData);
  			if(itemChanged) {
  				return;
  			}
  			gestureType = 'zoomPointerUp';
  		}
  
  		// prevent zoom/pan animation when main scroll animation runs
  		if(_mainScrollAnimating) {
  			return;
  		}
  		
  		// Complete simple zoom gesture (reset zoom level if it's out of the bounds)  
  		if(gestureType !== 'swipe') {
  			_completeZoomGesture();
  			return;
  		}
  	
  		// Complete pan gesture if main scroll is not shifted, and it's possible to pan current image
  		if(!_mainScrollShifted && _currZoomLevel > self.currItem.fitRatio) {
  			_completePanGesture(_releaseAnimData);
  		}
  	},
  
  
  	// Returns object with data about gesture
  	// It's created only once and then reused
  	_initDragReleaseAnimationData  = function() {
  		// temp local vars
  		var lastFlickDuration,
  			tempReleasePos;
  
  		// s = this
  		var s = {
  			lastFlickOffset: {},
  			lastFlickDist: {},
  			lastFlickSpeed: {},
  			slowDownRatio:  {},
  			slowDownRatioReverse:  {},
  			speedDecelerationRatio:  {},
  			speedDecelerationRatioAbs:  {},
  			distanceOffset:  {},
  			backAnimDestination: {},
  			backAnimStarted: {},
  			calculateSwipeSpeed: function(axis) {
  				
  
  				if( _posPoints.length > 1) {
  					lastFlickDuration = _getCurrentTime() - _gestureCheckSpeedTime + 50;
  					tempReleasePos = _posPoints[_posPoints.length-2][axis];
  				} else {
  					lastFlickDuration = _getCurrentTime() - _gestureStartTime; // total gesture duration
  					tempReleasePos = _startPoint[axis];
  				}
  				s.lastFlickOffset[axis] = _currPoint[axis] - tempReleasePos;
  				s.lastFlickDist[axis] = Math.abs(s.lastFlickOffset[axis]);
  				if(s.lastFlickDist[axis] > 20) {
  					s.lastFlickSpeed[axis] = s.lastFlickOffset[axis] / lastFlickDuration;
  				} else {
  					s.lastFlickSpeed[axis] = 0;
  				}
  				if( Math.abs(s.lastFlickSpeed[axis]) < 0.1 ) {
  					s.lastFlickSpeed[axis] = 0;
  				}
  				
  				s.slowDownRatio[axis] = 0.95;
  				s.slowDownRatioReverse[axis] = 1 - s.slowDownRatio[axis];
  				s.speedDecelerationRatio[axis] = 1;
  			},
  
  			calculateOverBoundsAnimOffset: function(axis, speed) {
  				if(!s.backAnimStarted[axis]) {
  
  					if(_panOffset[axis] > _currPanBounds.min[axis]) {
  						s.backAnimDestination[axis] = _currPanBounds.min[axis];
  						
  					} else if(_panOffset[axis] < _currPanBounds.max[axis]) {
  						s.backAnimDestination[axis] = _currPanBounds.max[axis];
  					}
  
  					if(s.backAnimDestination[axis] !== undefined) {
  						s.slowDownRatio[axis] = 0.7;
  						s.slowDownRatioReverse[axis] = 1 - s.slowDownRatio[axis];
  						if(s.speedDecelerationRatioAbs[axis] < 0.05) {
  
  							s.lastFlickSpeed[axis] = 0;
  							s.backAnimStarted[axis] = true;
  
  							_animateProp('bounceZoomPan'+axis,_panOffset[axis], 
  								s.backAnimDestination[axis], 
  								speed || 300, 
  								framework.easing.sine.out, 
  								function(pos) {
  									_panOffset[axis] = pos;
  									_applyCurrentZoomPan();
  								}
  							);
  
  						}
  					}
  				}
  			},
  
  			// Reduces the speed by slowDownRatio (per 10ms)
  			calculateAnimOffset: function(axis) {
  				if(!s.backAnimStarted[axis]) {
  					s.speedDecelerationRatio[axis] = s.speedDecelerationRatio[axis] * (s.slowDownRatio[axis] + 
  												s.slowDownRatioReverse[axis] - 
  												s.slowDownRatioReverse[axis] * s.timeDiff / 10);
  
  					s.speedDecelerationRatioAbs[axis] = Math.abs(s.lastFlickSpeed[axis] * s.speedDecelerationRatio[axis]);
  					s.distanceOffset[axis] = s.lastFlickSpeed[axis] * s.speedDecelerationRatio[axis] * s.timeDiff;
  					_panOffset[axis] += s.distanceOffset[axis];
  
  				}
  			},
  
  			panAnimLoop: function() {
  				if ( _animations.zoomPan ) {
  					_animations.zoomPan.raf = _requestAF(s.panAnimLoop);
  
  					s.now = _getCurrentTime();
  					s.timeDiff = s.now - s.lastNow;
  					s.lastNow = s.now;
  					
  					s.calculateAnimOffset('x');
  					s.calculateAnimOffset('y');
  
  					_applyCurrentZoomPan();
  					
  					s.calculateOverBoundsAnimOffset('x');
  					s.calculateOverBoundsAnimOffset('y');
  
  
  					if (s.speedDecelerationRatioAbs.x < 0.05 && s.speedDecelerationRatioAbs.y < 0.05) {
  
  						// round pan position
  						_panOffset.x = Math.round(_panOffset.x);
  						_panOffset.y = Math.round(_panOffset.y);
  						_applyCurrentZoomPan();
  						
  						_stopAnimation('zoomPan');
  						return;
  					}
  				}
  
  			}
  		};
  		return s;
  	},
  
  	_completePanGesture = function(animData) {
  		// calculate swipe speed for Y axis (paanning)
  		animData.calculateSwipeSpeed('y');
  
  		_currPanBounds = self.currItem.bounds;
  		
  		animData.backAnimDestination = {};
  		animData.backAnimStarted = {};
  
  		// Avoid acceleration animation if speed is too low
  		if(Math.abs(animData.lastFlickSpeed.x) <= 0.05 && Math.abs(animData.lastFlickSpeed.y) <= 0.05 ) {
  			animData.speedDecelerationRatioAbs.x = animData.speedDecelerationRatioAbs.y = 0;
  
  			// Run pan drag release animation. E.g. if you drag image and release finger without momentum.
  			animData.calculateOverBoundsAnimOffset('x');
  			animData.calculateOverBoundsAnimOffset('y');
  			return true;
  		}
  
  		// Animation loop that controls the acceleration after pan gesture ends
  		_registerStartAnimation('zoomPan');
  		animData.lastNow = _getCurrentTime();
  		animData.panAnimLoop();
  	},
  
  
  	_finishSwipeMainScrollGesture = function(gestureType, _releaseAnimData) {
  		var itemChanged;
  		if(!_mainScrollAnimating) {
  			_currZoomedItemIndex = _currentItemIndex;
  		}
  
  
  		
  		var itemsDiff;
  
  		if(gestureType === 'swipe') {
  			var totalShiftDist = _currPoint.x - _startPoint.x,
  				isFastLastFlick = _releaseAnimData.lastFlickDist.x < 10;
  
  			// if container is shifted for more than MIN_SWIPE_DISTANCE, 
  			// and last flick gesture was in right direction
  			if(totalShiftDist > MIN_SWIPE_DISTANCE && 
  				(isFastLastFlick || _releaseAnimData.lastFlickOffset.x > 20) ) {
  				// go to prev item
  				itemsDiff = -1;
  			} else if(totalShiftDist < -MIN_SWIPE_DISTANCE && 
  				(isFastLastFlick || _releaseAnimData.lastFlickOffset.x < -20) ) {
  				// go to next item
  				itemsDiff = 1;
  			}
  		}
  
  		var nextCircle;
  
  		if(itemsDiff) {
  			
  			_currentItemIndex += itemsDiff;
  
  			if(_currentItemIndex < 0) {
  				_currentItemIndex = _options.loop ? _getNumItems()-1 : 0;
  				nextCircle = true;
  			} else if(_currentItemIndex >= _getNumItems()) {
  				_currentItemIndex = _options.loop ? 0 : _getNumItems()-1;
  				nextCircle = true;
  			}
  
  			if(!nextCircle || _options.loop) {
  				_indexDiff += itemsDiff;
  				_currPositionIndex -= itemsDiff;
  				itemChanged = true;
  			}
  			
  
  			
  		}
  
  		var animateToX = _slideSize.x * _currPositionIndex;
  		var animateToDist = Math.abs( animateToX - _mainScrollPos.x );
  		var finishAnimDuration;
  
  
  		if(!itemChanged && animateToX > _mainScrollPos.x !== _releaseAnimData.lastFlickSpeed.x > 0) {
  			// "return to current" duration, e.g. when dragging from slide 0 to -1
  			finishAnimDuration = 333; 
  		} else {
  			finishAnimDuration = Math.abs(_releaseAnimData.lastFlickSpeed.x) > 0 ? 
  									animateToDist / Math.abs(_releaseAnimData.lastFlickSpeed.x) : 
  									333;
  
  			finishAnimDuration = Math.min(finishAnimDuration, 400);
  			finishAnimDuration = Math.max(finishAnimDuration, 250);
  		}
  
  		if(_currZoomedItemIndex === _currentItemIndex) {
  			itemChanged = false;
  		}
  		
  		_mainScrollAnimating = true;
  		
  		_shout('mainScrollAnimStart');
  
  		_animateProp('mainScroll', _mainScrollPos.x, animateToX, finishAnimDuration, framework.easing.cubic.out, 
  			_moveMainScroll,
  			function() {
  				_stopAllAnimations();
  				_mainScrollAnimating = false;
  				_currZoomedItemIndex = -1;
  				
  				if(itemChanged || _currZoomedItemIndex !== _currentItemIndex) {
  					self.updateCurrItem();
  				}
  				
  				_shout('mainScrollAnimComplete');
  			}
  		);
  
  		if(itemChanged) {
  			self.updateCurrItem(true);
  		}
  
  		return itemChanged;
  	},
  
  	_calculateZoomLevel = function(touchesDistance) {
  		return  1 / _startPointsDistance * touchesDistance * _startZoomLevel;
  	},
  
  	// Resets zoom if it's out of bounds
  	_completeZoomGesture = function() {
  		var destZoomLevel = _currZoomLevel,
  			minZoomLevel = _getMinZoomLevel(),
  			maxZoomLevel = _getMaxZoomLevel();
  
  		if ( _currZoomLevel < minZoomLevel ) {
  			destZoomLevel = minZoomLevel;
  		} else if ( _currZoomLevel > maxZoomLevel ) {
  			destZoomLevel = maxZoomLevel;
  		}
  
  		var destOpacity = 1,
  			onUpdate,
  			initialOpacity = _bgOpacity;
  
  		if(_opacityChanged && !_isZoomingIn && !_wasOverInitialZoom && _currZoomLevel < minZoomLevel) {
  			//_closedByScroll = true;
  			self.close();
  			return true;
  		}
  
  		if(_opacityChanged) {
  			onUpdate = function(now) {
  				_applyBgOpacity(  (destOpacity - initialOpacity) * now + initialOpacity );
  			};
  		}
  
  		self.zoomTo(destZoomLevel, 0, 200,  framework.easing.cubic.out, onUpdate);
  		return true;
  	};
  
  
  _registerModule('Gestures', {
  	publicMethods: {
  
  		initGestures: function() {
  
  			// helper function that builds touch/pointer/mouse events
  			var addEventNames = function(pref, down, move, up, cancel) {
  				_dragStartEvent = pref + down;
  				_dragMoveEvent = pref + move;
  				_dragEndEvent = pref + up;
  				if(cancel) {
  					_dragCancelEvent = pref + cancel;
  				} else {
  					_dragCancelEvent = '';
  				}
  			};
  
  			_pointerEventEnabled = _features.pointerEvent;
  			if(_pointerEventEnabled && _features.touch) {
  				// we don't need touch events, if browser supports pointer events
  				_features.touch = false;
  			}
  
  			if(_pointerEventEnabled) {
  				if(navigator.pointerEnabled) {
  					addEventNames('pointer', 'down', 'move', 'up', 'cancel');
  				} else {
  					// IE10 pointer events are case-sensitive
  					addEventNames('MSPointer', 'Down', 'Move', 'Up', 'Cancel');
  				}
  			} else if(_features.touch) {
  				addEventNames('touch', 'start', 'move', 'end', 'cancel');
  				_likelyTouchDevice = true;
  			} else {
  				addEventNames('mouse', 'down', 'move', 'up');	
  			}
  
  			_upMoveEvents = _dragMoveEvent + ' ' + _dragEndEvent  + ' ' +  _dragCancelEvent;
  			_downEvents = _dragStartEvent;
  
  			if(_pointerEventEnabled && !_likelyTouchDevice) {
  				_likelyTouchDevice = (navigator.maxTouchPoints > 1) || (navigator.msMaxTouchPoints > 1);
  			}
  			// make variable public
  			self.likelyTouchDevice = _likelyTouchDevice; 
  			
  			_globalEventHandlers[_dragStartEvent] = _onDragStart;
  			_globalEventHandlers[_dragMoveEvent] = _onDragMove;
  			_globalEventHandlers[_dragEndEvent] = _onDragRelease; // the Kraken
  
  			if(_dragCancelEvent) {
  				_globalEventHandlers[_dragCancelEvent] = _globalEventHandlers[_dragEndEvent];
  			}
  
  			// Bind mouse events on device with detected hardware touch support, in case it supports multiple types of input.
  			if(_features.touch) {
  				_downEvents += ' mousedown';
  				_upMoveEvents += ' mousemove mouseup';
  				_globalEventHandlers.mousedown = _globalEventHandlers[_dragStartEvent];
  				_globalEventHandlers.mousemove = _globalEventHandlers[_dragMoveEvent];
  				_globalEventHandlers.mouseup = _globalEventHandlers[_dragEndEvent];
  			}
  
  			if(!_likelyTouchDevice) {
  				// don't allow pan to next slide from zoomed state on Desktop
  				_options.allowPanToNext = false;
  			}
  		}
  
  	}
  });
  
  
  /*>>gestures*/
  
  /*>>show-hide-transition*/
  /**
   * show-hide-transition.js:
   *
   * Manages initial opening or closing transition.
   *
   * If you're not planning to use transition for gallery at all,
   * you may set options hideAnimationDuration and showAnimationDuration to 0,
   * and just delete startAnimation function.
   * 
   */
  
  
  var _showOrHideTimeout,
  	_showOrHide = function(item, img, out, completeFn) {
  
  		if(_showOrHideTimeout) {
  			clearTimeout(_showOrHideTimeout);
  		}
  
  		_initialZoomRunning = true;
  		_initialContentSet = true;
  		
  		// dimensions of small thumbnail {x:,y:,w:}.
  		// Height is optional, as calculated based on large image.
  		var thumbBounds; 
  		if(item.initialLayout) {
  			thumbBounds = item.initialLayout;
  			item.initialLayout = null;
  		} else {
  			thumbBounds = _options.getThumbBoundsFn && _options.getThumbBoundsFn(_currentItemIndex);
  		}
  
  		var duration = out ? _options.hideAnimationDuration : _options.showAnimationDuration;
  
  		var onComplete = function() {
  			_stopAnimation('initialZoom');
  			if(!out) {
  				_applyBgOpacity(1);
  				if(img) {
  					img.style.display = 'block';
  				}
  				framework.addClass(template, 'pswp--animated-in');
  				_shout('initialZoom' + (out ? 'OutEnd' : 'InEnd'));
  			} else {
  				self.template.removeAttribute('style');
  				self.bg.removeAttribute('style');
  			}
  
  			if(completeFn) {
  				completeFn();
  			}
  			_initialZoomRunning = false;
  		};
  
  		// if bounds aren't provided, just open gallery without animation
  		if(!duration || !thumbBounds || thumbBounds.x === undefined) {
  
  			_shout('initialZoom' + (out ? 'Out' : 'In') );
  
  			_currZoomLevel = item.initialZoomLevel;
  			_equalizePoints(_panOffset,  item.initialPosition );
  			_applyCurrentZoomPan();
  
  			template.style.opacity = out ? 0 : 1;
  			_applyBgOpacity(1);
  
  			if(duration) {
  				setTimeout(function() {
  					onComplete();
  				}, duration);
  			} else {
  				onComplete();
  			}
  
  			return;
  		}
  
  		var startAnimation = function() {
  			var closeWithRaf = _closedByScroll,
  				fadeEverything = !self.currItem.src || self.currItem.loadError || _options.showHideOpacity;
  			
  			// apply hw-acceleration to image
  			if(item.miniImg) {
  				item.miniImg.style.webkitBackfaceVisibility = 'hidden';
  			}
  
  			if(!out) {
  				_currZoomLevel = thumbBounds.w / item.w;
  				_panOffset.x = thumbBounds.x;
  				_panOffset.y = thumbBounds.y - _initalWindowScrollY;
  
  				self[fadeEverything ? 'template' : 'bg'].style.opacity = 0.001;
  				_applyCurrentZoomPan();
  			}
  
  			_registerStartAnimation('initialZoom');
  			
  			if(out && !closeWithRaf) {
  				framework.removeClass(template, 'pswp--animated-in');
  			}
  
  			if(fadeEverything) {
  				if(out) {
  					framework[ (closeWithRaf ? 'remove' : 'add') + 'Class' ](template, 'pswp--animate_opacity');
  				} else {
  					setTimeout(function() {
  						framework.addClass(template, 'pswp--animate_opacity');
  					}, 30);
  				}
  			}
  
  			_showOrHideTimeout = setTimeout(function() {
  
  				_shout('initialZoom' + (out ? 'Out' : 'In') );
  				
  
  				if(!out) {
  
  					// "in" animation always uses CSS transitions (instead of rAF).
  					// CSS transition work faster here, 
  					// as developer may also want to animate other things, 
  					// like ui on top of sliding area, which can be animated just via CSS
  					
  					_currZoomLevel = item.initialZoomLevel;
  					_equalizePoints(_panOffset,  item.initialPosition );
  					_applyCurrentZoomPan();
  					_applyBgOpacity(1);
  
  					if(fadeEverything) {
  						template.style.opacity = 1;
  					} else {
  						_applyBgOpacity(1);
  					}
  
  					_showOrHideTimeout = setTimeout(onComplete, duration + 20);
  				} else {
  
  					// "out" animation uses rAF only when PhotoSwipe is closed by browser scroll, to recalculate position
  					var destZoomLevel = thumbBounds.w / item.w,
  						initialPanOffset = {
  							x: _panOffset.x,
  							y: _panOffset.y
  						},
  						initialZoomLevel = _currZoomLevel,
  						initalBgOpacity = _bgOpacity,
  						onUpdate = function(now) {
  							
  							if(now === 1) {
  								_currZoomLevel = destZoomLevel;
  								_panOffset.x = thumbBounds.x;
  								_panOffset.y = thumbBounds.y  - _currentWindowScrollY;
  							} else {
  								_currZoomLevel = (destZoomLevel - initialZoomLevel) * now + initialZoomLevel;
  								_panOffset.x = (thumbBounds.x - initialPanOffset.x) * now + initialPanOffset.x;
  								_panOffset.y = (thumbBounds.y - _currentWindowScrollY - initialPanOffset.y) * now + initialPanOffset.y;
  							}
  							
  							_applyCurrentZoomPan();
  							if(fadeEverything) {
  								template.style.opacity = 1 - now;
  							} else {
  								_applyBgOpacity( initalBgOpacity - now * initalBgOpacity );
  							}
  						};
  
  					if(closeWithRaf) {
  						_animateProp('initialZoom', 0, 1, duration, framework.easing.cubic.out, onUpdate, onComplete);
  					} else {
  						onUpdate(1);
  						_showOrHideTimeout = setTimeout(onComplete, duration + 20);
  					}
  				}
  			
  			}, out ? 25 : 90); // Main purpose of this delay is to give browser time to paint and
  					// create composite layers of PhotoSwipe UI parts (background, controls, caption, arrows).
  					// Which avoids lag at the beginning of scale transition.
  		};
  		startAnimation();
  
  		
  	};
  
  /*>>show-hide-transition*/
  
  /*>>items-controller*/
  /**
  *
  * Controller manages gallery items, their dimensions, and their content.
  * 
  */
  
  var _items,
  	_tempPanAreaSize = {},
  	_imagesToAppendPool = [],
  	_initialContentSet,
  	_initialZoomRunning,
  	_controllerDefaultOptions = {
  		index: 0,
  		errorMsg: '<div class="pswp__error-msg"><a href="%url%" target="_blank">图片</a>加载失败！</div>',
  		forceProgressiveLoading: false, // TODO
  		preload: [1,1],
  		getNumItemsFn: function() {
  			return _items.length;
  		}
  	};
  
  
  var _getItemAt,
  	_getNumItems,
  	_initialIsLoop,
  	_getZeroBounds = function() {
  		return {
  			center:{x:0,y:0}, 
  			max:{x:0,y:0}, 
  			min:{x:0,y:0}
  		};
  	},
  	_calculateSingleItemPanBounds = function(item, realPanElementW, realPanElementH ) {
  		var bounds = item.bounds;
  
  		// position of element when it's centered
  		bounds.center.x = Math.round((_tempPanAreaSize.x - realPanElementW) / 2);
  		bounds.center.y = Math.round((_tempPanAreaSize.y - realPanElementH) / 2) + item.vGap.top;
  
  		// maximum pan position
  		bounds.max.x = (realPanElementW > _tempPanAreaSize.x) ? 
  							Math.round(_tempPanAreaSize.x - realPanElementW) : 
  							bounds.center.x;
  		
  		bounds.max.y = (realPanElementH > _tempPanAreaSize.y) ? 
  							Math.round(_tempPanAreaSize.y - realPanElementH) + item.vGap.top : 
  							bounds.center.y;
  		
  		// minimum pan position
  		bounds.min.x = (realPanElementW > _tempPanAreaSize.x) ? 0 : bounds.center.x;
  		bounds.min.y = (realPanElementH > _tempPanAreaSize.y) ? item.vGap.top : bounds.center.y;
  	},
  	_calculateItemSize = function(item, viewportSize, zoomLevel) {
  
  		if (item.src && !item.loadError) {
  			var isInitial = !zoomLevel;
  			
  			if(isInitial) {
  				if(!item.vGap) {
  					item.vGap = {top:0,bottom:0};
  				}
  				// allows overriding vertical margin for individual items
  				_shout('parseVerticalMargin', item);
  			}
  
  
  			_tempPanAreaSize.x = viewportSize.x;
  			_tempPanAreaSize.y = viewportSize.y - item.vGap.top - item.vGap.bottom;
  
  			if (isInitial) {
  				var hRatio = _tempPanAreaSize.x / item.w;
  				var vRatio = _tempPanAreaSize.y / item.h;
  
  				item.fitRatio = hRatio < vRatio ? hRatio : vRatio;
  				//item.fillRatio = hRatio > vRatio ? hRatio : vRatio;
  
  				var scaleMode = _options.scaleMode;
  
  				if (scaleMode === 'orig') {
  					zoomLevel = 1;
  				} else if (scaleMode === 'fit') {
  					zoomLevel = item.fitRatio;
  				}
  
  				if (zoomLevel > 1) {
  					zoomLevel = 1;
  				}
  
  				item.initialZoomLevel = zoomLevel;
  				
  				if(!item.bounds) {
  					// reuse bounds object
  					item.bounds = _getZeroBounds(); 
  				}
  			}
  
  			if(!zoomLevel) {
  				return;
  			}
  
  			_calculateSingleItemPanBounds(item, item.w * zoomLevel, item.h * zoomLevel);
  
  			if (isInitial && zoomLevel === item.initialZoomLevel) {
  				item.initialPosition = item.bounds.center;
  			}
  
  			return item.bounds;
  		} else {
  			item.w = item.h = 0;
  			item.initialZoomLevel = item.fitRatio = 1;
  			item.bounds = _getZeroBounds();
  			item.initialPosition = item.bounds.center;
  
  			// if it's not image, we return zero bounds (content is not zoomable)
  			return item.bounds;
  		}
  		
  	},
  
  	
  
  
  	_appendImage = function(index, item, baseDiv, img, preventAnimation, keepPlaceholder) {
  		
  
  		if(item.loadError) {
  			return;
  		}
  
  		if(img) {
  
  			item.imageAppended = true;
  			_setImageSize(item, img, (item === self.currItem && _renderMaxResolution) );
  			
  			baseDiv.appendChild(img);
  
  			if(keepPlaceholder) {
  				setTimeout(function() {
  					if(item && item.loaded && item.placeholder) {
  						item.placeholder.style.display = 'none';
  						item.placeholder = null;
  					}
  				}, 500);
  			}
  		}
  	},
  	
  
  
  	_preloadImage = function(item) {
  		item.loading = true;
  		item.loaded = false;
  		var img = item.img = framework.createEl('pswp__img', 'img');
  		var onComplete = function() {
  			item.loading = false;
  			item.loaded = true;
  
  			if(item.loadComplete) {
  				item.loadComplete(item);
  			} else {
  				item.img = null; // no need to store image object
  			}
  			img.onload = img.onerror = null;
  			img = null;
  		};
  		img.onload = onComplete;
  		img.onerror = function() {
  			item.loadError = true;
  			onComplete();
  		};		
  
  		img.src = item.src;// + '?a=' + Math.random();
  
  		return img;
  	},
  	_checkForError = function(item, cleanUp) {
  		if(item.src && item.loadError && item.container) {
  
  			if(cleanUp) {
  				item.container.innerHTML = '';
  			}
  
  			item.container.innerHTML = _options.errorMsg.replace('%url%',  item.src );
  			return true;
  			
  		}
  	},
  	_setImageSize = function(item, img, maxRes) {
  		if(!item.src) {
  			return;
  		}
  
  		if(!img) {
  			img = item.container.lastChild;
  		}
  
  		var w = maxRes ? item.w : Math.round(item.w * item.fitRatio),
  			h = maxRes ? item.h : Math.round(item.h * item.fitRatio);
  		
  		if(item.placeholder && !item.loaded) {
  			item.placeholder.style.width = w + 'px';
  			item.placeholder.style.height = h + 'px';
  		}
  
  		img.style.width = w + 'px';
  		img.style.height = h + 'px';
  	},
  	_appendImagesPool = function() {
  
  		if(_imagesToAppendPool.length) {
  			var poolItem;
  
  			for(var i = 0; i < _imagesToAppendPool.length; i++) {
  				poolItem = _imagesToAppendPool[i];
  				if( poolItem.holder.index === poolItem.index ) {
  					_appendImage(poolItem.index, poolItem.item, poolItem.baseDiv, poolItem.img, false, poolItem.clearPlaceholder);
  				}
  			}
  			_imagesToAppendPool = [];
  		}
  	};
  	
  
  
  _registerModule('Controller', {
  
  	publicMethods: {
  
  		lazyLoadItem: function(index) {
  			index = _getLoopedId(index);
  			var item = _getItemAt(index);
  
  			if(!item || ((item.loaded || item.loading) && !_itemsNeedUpdate)) {
  				return;
  			}
  
  			_shout('gettingData', index, item);
  
  			if (!item.src) {
  				return;
  			}
  
  			_preloadImage(item);
  		},
  		initController: function() {
  			framework.extend(_options, _controllerDefaultOptions, true);
  			self.items = _items = items;
  			_getItemAt = self.getItemAt;
  			_getNumItems = _options.getNumItemsFn; //self.getNumItems;
  
  
  
  			_initialIsLoop = _options.loop;
  			if(_getNumItems() < 3) {
  				_options.loop = false; // disable loop if less then 3 items
  			}
  
  			_listen('beforeChange', function(diff) {
  
  				var p = _options.preload,
  					isNext = diff === null ? true : (diff >= 0),
  					preloadBefore = Math.min(p[0], _getNumItems() ),
  					preloadAfter = Math.min(p[1], _getNumItems() ),
  					i;
  
  
  				for(i = 1; i <= (isNext ? preloadAfter : preloadBefore); i++) {
  					self.lazyLoadItem(_currentItemIndex+i);
  				}
  				for(i = 1; i <= (isNext ? preloadBefore : preloadAfter); i++) {
  					self.lazyLoadItem(_currentItemIndex-i);
  				}
  			});
  
  			_listen('initialLayout', function() {
  				self.currItem.initialLayout = _options.getThumbBoundsFn && _options.getThumbBoundsFn(_currentItemIndex);
  			});
  
  			_listen('mainScrollAnimComplete', _appendImagesPool);
  			_listen('initialZoomInEnd', _appendImagesPool);
  
  
  
  			_listen('destroy', function() {
  				var item;
  				for(var i = 0; i < _items.length; i++) {
  					item = _items[i];
  					// remove reference to DOM elements, for GC
  					if(item.container) {
  						item.container = null; 
  					}
  					if(item.placeholder) {
  						item.placeholder = null;
  					}
  					if(item.img) {
  						item.img = null;
  					}
  					if(item.preloader) {
  						item.preloader = null;
  					}
  					if(item.loadError) {
  						item.loaded = item.loadError = false;
  					}
  				}
  				_imagesToAppendPool = null;
  			});
  		},
  
  
  		getItemAt: function(index) {
  			if (index >= 0) {
  				return _items[index] !== undefined ? _items[index] : false;
  			}
  			return false;
  		},
  
  		allowProgressiveImg: function() {
  			// 1. Progressive image loading isn't working on webkit/blink 
  			//    when hw-acceleration (e.g. translateZ) is applied to IMG element.
  			//    That's why in PhotoSwipe parent element gets zoom transform, not image itself.
  			//    
  			// 2. Progressive image loading sometimes blinks in webkit/blink when applying animation to parent element.
  			//    That's why it's disabled on touch devices (mainly because of swipe transition)
  			//    
  			// 3. Progressive image loading sometimes doesn't work in IE (up to 11).
  
  			// Don't allow progressive loading on non-large touch devices
  			return _options.forceProgressiveLoading || !_likelyTouchDevice || _options.mouseUsed || screen.width > 1200; 
  			// 1200 - to eliminate touch devices with large screen (like Chromebook Pixel)
  		},
  
  		setContent: function(holder, index) {
  
  			if(_options.loop) {
  				index = _getLoopedId(index);
  			}
  
  			var prevItem = self.getItemAt(holder.index);
  			if(prevItem) {
  				prevItem.container = null;
  			}
  	
  			var item = self.getItemAt(index),
  				img;
  			
  			if(!item) {
  				holder.el.innerHTML = '';
  				return;
  			}
  
  			// allow to override data
  			_shout('gettingData', index, item);
  
  			holder.index = index;
  			holder.item = item;
  
  			// base container DIV is created only once for each of 3 holders
  			var baseDiv = item.container = framework.createEl('pswp__zoom-wrap'); 
  
  			
  
  			if(!item.src && item.html) {
  				if(item.html.tagName) {
  					baseDiv.appendChild(item.html);
  				} else {
  					baseDiv.innerHTML = item.html;
  				}
  			}
  
  			_checkForError(item);
  
  			_calculateItemSize(item, _viewportSize);
  			
  			if(item.src && !item.loadError && !item.loaded) {
  
  				item.loadComplete = function(item) {
  
  					// gallery closed before image finished loading
  					if(!_isOpen) {
  						return;
  					}
  
  					// check if holder hasn't changed while image was loading
  					if(holder && holder.index === index ) {
  						if( _checkForError(item, true) ) {
  							item.loadComplete = item.img = null;
  							_calculateItemSize(item, _viewportSize);
  							_applyZoomPanToItem(item);
  
  							if(holder.index === _currentItemIndex) {
  								// recalculate dimensions
  								self.updateCurrZoomItem();
  							}
  							return;
  						}
  						if( !item.imageAppended ) {
  							if(_features.transform && (_mainScrollAnimating || _initialZoomRunning) ) {
  								_imagesToAppendPool.push({
  									item:item,
  									baseDiv:baseDiv,
  									img:item.img,
  									index:index,
  									holder:holder,
  									clearPlaceholder:true
  								});
  							} else {
  								_appendImage(index, item, baseDiv, item.img, _mainScrollAnimating || _initialZoomRunning, true);
  							}
  						} else {
  							// remove preloader & mini-img
  							if(!_initialZoomRunning && item.placeholder) {
  								item.placeholder.style.display = 'none';
  								item.placeholder = null;
  							}
  						}
  					}
  
  					item.loadComplete = null;
  					item.img = null; // no need to store image element after it's added
  
  					_shout('imageLoadComplete', index, item);
  				};
  
  				if(framework.features.transform) {
  					
  					var placeholderClassName = 'pswp__img pswp__img--placeholder'; 
  					placeholderClassName += (item.msrc ? '' : ' pswp__img--placeholder--blank');
  
  					var placeholder = framework.createEl(placeholderClassName, item.msrc ? 'img' : '');
  					if(item.msrc) {
  						placeholder.src = item.msrc;
  					}
  					
  					_setImageSize(item, placeholder);
  
  					baseDiv.appendChild(placeholder);
  					item.placeholder = placeholder;
  
  				}
  				
  
  				
  
  				if(!item.loading) {
  					_preloadImage(item);
  				}
  
  
  				if( self.allowProgressiveImg() ) {
  					// just append image
  					if(!_initialContentSet && _features.transform) {
  						_imagesToAppendPool.push({
  							item:item, 
  							baseDiv:baseDiv, 
  							img:item.img, 
  							index:index, 
  							holder:holder
  						});
  					} else {
  						_appendImage(index, item, baseDiv, item.img, true, true);
  					}
  				}
  				
  			} else if(item.src && !item.loadError) {
  				// image object is created every time, due to bugs of image loading & delay when switching images
  				img = framework.createEl('pswp__img', 'img');
  				img.style.opacity = 1;
  				img.src = item.src;
  				_setImageSize(item, img);
  				_appendImage(index, item, baseDiv, img, true);
  			}
  			
  
  			if(!_initialContentSet && index === _currentItemIndex) {
  				_currZoomElementStyle = baseDiv.style;
  				_showOrHide(item, (img ||item.img) );
  			} else {
  				_applyZoomPanToItem(item);
  			}
  
  			holder.el.innerHTML = '';
  			holder.el.appendChild(baseDiv);
  		},
  
  		cleanSlide: function( item ) {
  			if(item.img ) {
  				item.img.onload = item.img.onerror = null;
  			}
  			item.loaded = item.loading = item.img = item.imageAppended = false;
  		}
  
  	}
  });
  
  /*>>items-controller*/
  
  /*>>tap*/
  /**
   * tap.js:
   *
   * Displatches tap and double-tap events.
   * 
   */
  
  var tapTimer,
  	tapReleasePoint = {},
  	_dispatchTapEvent = function(origEvent, releasePoint, pointerType) {		
  		var e = document.createEvent( 'CustomEvent' ),
  			eDetail = {
  				origEvent:origEvent, 
  				target:origEvent.target, 
  				releasePoint: releasePoint, 
  				pointerType:pointerType || 'touch'
  			};
  
  		e.initCustomEvent( 'pswpTap', true, true, eDetail );
  		origEvent.target.dispatchEvent(e);
  	};
  
  _registerModule('Tap', {
  	publicMethods: {
  		initTap: function() {
  			_listen('firstTouchStart', self.onTapStart);
  			_listen('touchRelease', self.onTapRelease);
  			_listen('destroy', function() {
  				tapReleasePoint = {};
  				tapTimer = null;
  			});
  		},
  		onTapStart: function(touchList) {
  			if(touchList.length > 1) {
  				clearTimeout(tapTimer);
  				tapTimer = null;
  			}
  		},
  		onTapRelease: function(e, releasePoint) {
  			if(!releasePoint) {
  				return;
  			}
  
  			if(!_moved && !_isMultitouch && !_numAnimations) {
  				var p0 = releasePoint;
  				if(tapTimer) {
  					clearTimeout(tapTimer);
  					tapTimer = null;
  
  					// Check if taped on the same place
  					if ( _isNearbyPoints(p0, tapReleasePoint) ) {
  						_shout('doubleTap', p0);
  						return;
  					}
  				}
  
  				if(releasePoint.type === 'mouse') {
  					_dispatchTapEvent(e, releasePoint, 'mouse');
  					return;
  				}
  
  				var clickedTagName = e.target.tagName.toUpperCase();
  				// avoid double tap delay on buttons and elements that have class pswp__single-tap
  				if(clickedTagName === 'BUTTON' || framework.hasClass(e.target, 'pswp__single-tap') ) {
  					_dispatchTapEvent(e, releasePoint);
  					return;
  				}
  
  				_equalizePoints(tapReleasePoint, p0);
  
  				tapTimer = setTimeout(function() {
  					_dispatchTapEvent(e, releasePoint);
  					tapTimer = null;
  				}, 300);
  			}
  		}
  	}
  });
  
  /*>>tap*/
  
  /*>>desktop-zoom*/
  /**
   *
   * desktop-zoom.js:
   *
   * - Binds mousewheel event for paning zoomed image.
   * - Manages "dragging", "zoomed-in", "zoom-out" classes.
   *   (which are used for cursors and zoom icon)
   * - Adds toggleDesktopZoom function.
   * 
   */
  
  var _wheelDelta;
  	
  _registerModule('DesktopZoom', {
  
  	publicMethods: {
  
  		initDesktopZoom: function() {
  
  			if(_oldIE) {
  				// no zoom for old IE (<=8)
  				return;
  			}
  
  			if(_likelyTouchDevice) {
  				// if detected hardware touch support, we wait until mouse is used,
  				// and only then apply desktop-zoom features
  				_listen('mouseUsed', function() {
  					self.setupDesktopZoom();
  				});
  			} else {
  				self.setupDesktopZoom(true);
  			}
  
  		},
  
  		setupDesktopZoom: function(onInit) {
  
  			_wheelDelta = {};
  
  			var events = 'wheel mousewheel DOMMouseScroll';
  			
  			_listen('bindEvents', function() {
  				framework.bind(template, events,  self.handleMouseWheel);
  			});
  
  			_listen('unbindEvents', function() {
  				if(_wheelDelta) {
  					framework.unbind(template, events, self.handleMouseWheel);
  				}
  			});
  
  			self.mouseZoomedIn = false;
  
  			var hasDraggingClass,
  				updateZoomable = function() {
  					if(self.mouseZoomedIn) {
  						framework.removeClass(template, 'pswp--zoomed-in');
  						self.mouseZoomedIn = false;
  					}
  					if(_currZoomLevel < 1) {
  						framework.addClass(template, 'pswp--zoom-allowed');
  					} else {
  						framework.removeClass(template, 'pswp--zoom-allowed');
  					}
  					removeDraggingClass();
  				},
  				removeDraggingClass = function() {
  					if(hasDraggingClass) {
  						framework.removeClass(template, 'pswp--dragging');
  						hasDraggingClass = false;
  					}
  				};
  
  			_listen('resize' , updateZoomable);
  			_listen('afterChange' , updateZoomable);
  			_listen('pointerDown', function() {
  				if(self.mouseZoomedIn) {
  					hasDraggingClass = true;
  					framework.addClass(template, 'pswp--dragging');
  				}
  			});
  			_listen('pointerUp', removeDraggingClass);
  
  			if(!onInit) {
  				updateZoomable();
  			}
  			
  		},
  
  		handleMouseWheel: function(e) {
  
  			if(_currZoomLevel <= self.currItem.fitRatio) {
  				if( _options.modal ) {
  
  					if (!_options.closeOnScroll || _numAnimations || _isDragging) {
  						e.preventDefault();
  					} else if(_transformKey && Math.abs(e.deltaY) > 2) {
  						// close PhotoSwipe
  						// if browser supports transforms & scroll changed enough
  						_closedByScroll = true;
  						self.close();
  					}
  
  				}
  				return true;
  			}
  
  			// allow just one event to fire
  			e.stopPropagation();
  
  			// https://developer.mozilla.org/en-US/docs/Web/Events/wheel
  			_wheelDelta.x = 0;
  
  			if('deltaX' in e) {
  				if(e.deltaMode === 1 /* DOM_DELTA_LINE */) {
  					// 18 - average line height
  					_wheelDelta.x = e.deltaX * 18;
  					_wheelDelta.y = e.deltaY * 18;
  				} else {
  					_wheelDelta.x = e.deltaX;
  					_wheelDelta.y = e.deltaY;
  				}
  			} else if('wheelDelta' in e) {
  				if(e.wheelDeltaX) {
  					_wheelDelta.x = -0.16 * e.wheelDeltaX;
  				}
  				if(e.wheelDeltaY) {
  					_wheelDelta.y = -0.16 * e.wheelDeltaY;
  				} else {
  					_wheelDelta.y = -0.16 * e.wheelDelta;
  				}
  			} else if('detail' in e) {
  				_wheelDelta.y = e.detail;
  			} else {
  				return;
  			}
  
  			_calculatePanBounds(_currZoomLevel, true);
  
  			var newPanX = _panOffset.x - _wheelDelta.x,
  				newPanY = _panOffset.y - _wheelDelta.y;
  
  			// only prevent scrolling in nonmodal mode when not at edges
  			if (_options.modal ||
  				(
  				newPanX <= _currPanBounds.min.x && newPanX >= _currPanBounds.max.x &&
  				newPanY <= _currPanBounds.min.y && newPanY >= _currPanBounds.max.y
  				) ) {
  				e.preventDefault();
  			}
  
  			// TODO: use rAF instead of mousewheel?
  			self.panTo(newPanX, newPanY);
  		},
  
  		toggleDesktopZoom: function(centerPoint) {
  			centerPoint = centerPoint || {x:_viewportSize.x/2 + _offset.x, y:_viewportSize.y/2 + _offset.y };
  
  			var doubleTapZoomLevel = _options.getDoubleTapZoom(true, self.currItem);
  			var zoomOut = _currZoomLevel === doubleTapZoomLevel;
  			
  			self.mouseZoomedIn = !zoomOut;
  
  			self.zoomTo(zoomOut ? self.currItem.initialZoomLevel : doubleTapZoomLevel, centerPoint, 333);
  			framework[ (!zoomOut ? 'add' : 'remove') + 'Class'](template, 'pswp--zoomed-in');
  		}
  
  	}
  });
  
  
  /*>>desktop-zoom*/
  
  /*>>history*/
  /**
   *
   * history.js:
   *
   * - Back button to close gallery.
   * 
   * - Unique URL for each slide: example.com/&pid=1&gid=3
   *   (where PID is picture index, and GID and gallery index)
   *   
   * - Switch URL when slides change.
   * 
   */
  
  
  var _historyDefaultOptions = {
  	history: true,
  	galleryUID: 1
  };
  
  var _historyUpdateTimeout,
  	_hashChangeTimeout,
  	_hashAnimCheckTimeout,
  	_hashChangedByScript,
  	_hashChangedByHistory,
  	_hashReseted,
  	_initialHash,
  	_historyChanged,
  	_closedFromURL,
  	_urlChangedOnce,
  	_windowLoc,
  
  	_supportsPushState,
  
  	_getHash = function() {
  		return _windowLoc.hash.substring(1);
  	},
  	_cleanHistoryTimeouts = function() {
  
  		if(_historyUpdateTimeout) {
  			clearTimeout(_historyUpdateTimeout);
  		}
  
  		if(_hashAnimCheckTimeout) {
  			clearTimeout(_hashAnimCheckTimeout);
  		}
  	},
  
  	// pid - Picture index
  	// gid - Gallery index
  	_parseItemIndexFromURL = function() {
  		var hash = _getHash(),
  			params = {};
  
  		if(hash.length < 5) { // pid=1
  			return params;
  		}
  
  		var i, vars = hash.split('&');
  		for (i = 0; i < vars.length; i++) {
  			if(!vars[i]) {
  				continue;
  			}
  			var pair = vars[i].split('=');	
  			if(pair.length < 2) {
  				continue;
  			}
  			params[pair[0]] = pair[1];
  		}
  		if(_options.galleryPIDs) {
  			// detect custom pid in hash and search for it among the items collection
  			var searchfor = params.pid;
  			params.pid = 0; // if custom pid cannot be found, fallback to the first item
  			for(i = 0; i < _items.length; i++) {
  				if(_items[i].pid === searchfor) {
  					params.pid = i;
  					break;
  				}
  			}
  		} else {
  			params.pid = parseInt(params.pid,10)-1;
  		}
  		if( params.pid < 0 ) {
  			params.pid = 0;
  		}
  		return params;
  	},
  	_updateHash = function() {
  
  		if(_hashAnimCheckTimeout) {
  			clearTimeout(_hashAnimCheckTimeout);
  		}
  
  
  		if(_numAnimations || _isDragging) {
  			// changing browser URL forces layout/paint in some browsers, which causes noticable lag during animation
  			// that's why we update hash only when no animations running
  			_hashAnimCheckTimeout = setTimeout(_updateHash, 500);
  			return;
  		}
  		
  		if(_hashChangedByScript) {
  			clearTimeout(_hashChangeTimeout);
  		} else {
  			_hashChangedByScript = true;
  		}
  
  
  		var pid = (_currentItemIndex + 1);
  		var item = _getItemAt( _currentItemIndex );
  		if(item.hasOwnProperty('pid')) {
  			// carry forward any custom pid assigned to the item
  			pid = item.pid;
  		}
  		var newHash = _initialHash + '&'  +  'gid=' + _options.galleryUID + '&' + 'pid=' + pid;
  
  		if(!_historyChanged) {
  			if(_windowLoc.hash.indexOf(newHash) === -1) {
  				_urlChangedOnce = true;
  			}
  			// first time - add new hisory record, then just replace
  		}
  
  		var newURL = _windowLoc.href.split('#')[0] + '#' +  newHash;
  
  		if( _supportsPushState ) {
  
  			if('#' + newHash !== window.location.hash) {
  				history[_historyChanged ? 'replaceState' : 'pushState']('', document.title, newURL);
  			}
  
  		} else {
  			if(_historyChanged) {
  				_windowLoc.replace( newURL );
  			} else {
  				_windowLoc.hash = newHash;
  			}
  		}
  		
  		
  
  		_historyChanged = true;
  		_hashChangeTimeout = setTimeout(function() {
  			_hashChangedByScript = false;
  		}, 60);
  	};
  
  
  
  	
  
  _registerModule('History', {
  
  	
  
  	publicMethods: {
  		initHistory: function() {
  
  			framework.extend(_options, _historyDefaultOptions, true);
  
  			if( !_options.history ) {
  				return;
  			}
  
  
  			_windowLoc = window.location;
  			_urlChangedOnce = false;
  			_closedFromURL = false;
  			_historyChanged = false;
  			_initialHash = _getHash();
  			_supportsPushState = ('pushState' in history);
  
  
  			if(_initialHash.indexOf('gid=') > -1) {
  				_initialHash = _initialHash.split('&gid=')[0];
  				_initialHash = _initialHash.split('?gid=')[0];
  			}
  			
  
  			_listen('afterChange', self.updateURL);
  			_listen('unbindEvents', function() {
  				framework.unbind(window, 'hashchange', self.onHashChange);
  			});
  
  
  			var returnToOriginal = function() {
  				_hashReseted = true;
  				if(!_closedFromURL) {
  
  					if(_urlChangedOnce) {
  						history.back();
  					} else {
  
  						if(_initialHash) {
  							_windowLoc.hash = _initialHash;
  						} else {
  							if (_supportsPushState) {
  
  								// remove hash from url without refreshing it or scrolling to top
  								history.pushState('', document.title,  _windowLoc.pathname + _windowLoc.search );
  							} else {
  								_windowLoc.hash = '';
  							}
  						}
  					}
  					
  				}
  
  				_cleanHistoryTimeouts();
  			};
  
  
  			_listen('unbindEvents', function() {
  				if(_closedByScroll) {
  					// if PhotoSwipe is closed by scroll, we go "back" before the closing animation starts
  					// this is done to keep the scroll position
  					returnToOriginal();
  				}
  			});
  			_listen('destroy', function() {
  				if(!_hashReseted) {
  					returnToOriginal();
  				}
  			});
  			_listen('firstUpdate', function() {
  				_currentItemIndex = _parseItemIndexFromURL().pid;
  			});
  
  			
  
  			
  			var index = _initialHash.indexOf('pid=');
  			if(index > -1) {
  				_initialHash = _initialHash.substring(0, index);
  				if(_initialHash.slice(-1) === '&') {
  					_initialHash = _initialHash.slice(0, -1);
  				}
  			}
  			
  
  			setTimeout(function() {
  				if(_isOpen) { // hasn't destroyed yet
  					framework.bind(window, 'hashchange', self.onHashChange);
  				}
  			}, 40);
  			
  		},
  		onHashChange: function() {
  
  			if(_getHash() === _initialHash) {
  
  				_closedFromURL = true;
  				self.close();
  				return;
  			}
  			if(!_hashChangedByScript) {
  
  				_hashChangedByHistory = true;
  				self.goTo( _parseItemIndexFromURL().pid );
  				_hashChangedByHistory = false;
  			}
  			
  		},
  		updateURL: function() {
  
  			// Delay the update of URL, to avoid lag during transition, 
  			// and to not to trigger actions like "refresh page sound" or "blinking favicon" to often
  			
  			_cleanHistoryTimeouts();
  			
  
  			if(_hashChangedByHistory) {
  				return;
  			}
  
  			if(!_historyChanged) {
  				_updateHash(); // first time
  			} else {
  				_historyUpdateTimeout = setTimeout(_updateHash, 800);
  			}
  		}
  	
  	}
  });
  
  
  /*>>history*/
  	framework.extend(self, publicMethods); };
  	return PhotoSwipe;
  });