text: (function($) {
  
  	$.extend(mejs.MepDefaults, {
  		usePluginFullScreen: true,
  		newWindowCallback: function() { return '';},
  		fullscreenText: mejs.i18n.t('Fullscreen')
  	});
  
  	$.extend(MediaElementPlayer.prototype, {
  
  		isFullScreen: false,
  
  		isNativeFullScreen: false,
  
  		isInIframe: false,
  
  		buildfullscreen: function(player, controls, layers, media) {
  
  			if (!player.isVideo)
  				return;
  
  			player.isInIframe = (window.location != window.parent.location);
  
  			// native events
  			if (mejs.MediaFeatures.hasTrueNativeFullScreen) {
  
  				// chrome doesn't alays fire this in an iframe
  				var func = function(e) {
  					if (player.isFullScreen) {
  						if (mejs.MediaFeatures.isFullScreen()) {
  							player.isNativeFullScreen = true;
  							// reset the controls once we are fully in full screen
  							player.setControlsSize();
  						} else {
  							player.isNativeFullScreen = false;
  							// when a user presses ESC
  							// make sure to put the player back into place
  							player.exitFullScreen();
  						}
  					}
  				};
  
  				player.globalBind(mejs.MediaFeatures.fullScreenEventName, func);
  			}
  
  			var t = this,
  				fullscreenBtn =
  					$('<div class="mejs-button mejs-fullscreen-button">' +
  						'<button type="button" aria-controls="' + t.id + '" title="' + t.options.fullscreenText + '" aria-label="' + t.options.fullscreenText + '"></button>' +
  					'</div>')
  					.appendTo(controls);
  
  				if (t.media.pluginType === 'native' || (!t.options.usePluginFullScreen && !mejs.MediaFeatures.isFirefox)) {
  
  					fullscreenBtn.click(function() {
  						var isFullScreen = (mejs.MediaFeatures.hasTrueNativeFullScreen && mejs.MediaFeatures.isFullScreen()) || player.isFullScreen;
  
  						if (isFullScreen) {
  							player.exitFullScreen();
  						} else {
  							player.enterFullScreen();
  						}
  					});
  
  				} else {
  
  					var hideTimeout = null,
  						supportsPointerEvents = (function() {
  							// TAKEN FROM MODERNIZR
  							var element = document.createElement('x'),
  								documentElement = document.documentElement,
  								getComputedStyle = window.getComputedStyle,
  								supports;
  							if(!('pointerEvents' in element.style)){
  								return false;
  							}
  							element.style.pointerEvents = 'auto';
  							element.style.pointerEvents = 'x';
  							documentElement.appendChild(element);
  							supports = getComputedStyle &&
  								getComputedStyle(element, '').pointerEvents === 'auto';
  							documentElement.removeChild(element);
  							return !!supports;
  						})();
  
  					//console.log('supportsPointerEvents', supportsPointerEvents);
  
  					if (supportsPointerEvents && !mejs.MediaFeatures.isOpera) { // opera doesn't allow this :(
  
  						// allows clicking through the fullscreen button and controls down directly to Flash
  
  						/*
  						 When a user puts his mouse over the fullscreen button, the controls are disabled
  						 So we put a div over the video and another one on iether side of the fullscreen button
  						 that caputre mouse movement
  						 and restore the controls once the mouse moves outside of the fullscreen button
  						*/
  
  						var fullscreenIsDisabled = false,
  							restoreControls = function() {
  								if (fullscreenIsDisabled) {
  									// hide the hovers
  									for (var i in hoverDivs) {
  										hoverDivs[i].hide();
  									}
  
  									// restore the control bar
  									fullscreenBtn.css('pointer-events', '');
  									t.controls.css('pointer-events', '');
  
  									// prevent clicks from pausing video
  									t.media.removeEventListener('click', t.clickToPlayPauseCallback);
  
  									// store for later
  									fullscreenIsDisabled = false;
  								}
  							},
  							hoverDivs = {},
  							hoverDivNames = ['top', 'left', 'right', 'bottom'],
  							i, len,
  							positionHoverDivs = function() {
  								var fullScreenBtnOffsetLeft = fullscreenBtn.offset().left - t.container.offset().left,
  									fullScreenBtnOffsetTop = fullscreenBtn.offset().top - t.container.offset().top,
  									fullScreenBtnWidth = fullscreenBtn.outerWidth(true),
  									fullScreenBtnHeight = fullscreenBtn.outerHeight(true),
  									containerWidth = t.container.width(),
  									containerHeight = t.container.height();
  
  								for (i in hoverDivs) {
  									hoverDivs[i].css({position: 'absolute', top: 0, left: 0}); //, backgroundColor: '#f00'});
  								}
  
  								// over video, but not controls
  								hoverDivs['top']
  									.width( containerWidth )
  									.height( fullScreenBtnOffsetTop );
  
  								// over controls, but not the fullscreen button
  								hoverDivs['left']
  									.width( fullScreenBtnOffsetLeft )
  									.height( fullScreenBtnHeight )
  									.css({top: fullScreenBtnOffsetTop});
  
  								// after the fullscreen button
  								hoverDivs['right']
  									.width( containerWidth - fullScreenBtnOffsetLeft - fullScreenBtnWidth )
  									.height( fullScreenBtnHeight )
  									.css({top: fullScreenBtnOffsetTop,
  										 left: fullScreenBtnOffsetLeft + fullScreenBtnWidth});
  
  								// under the fullscreen button
  								hoverDivs['bottom']
  									.width( containerWidth )
  									.height( containerHeight - fullScreenBtnHeight - fullScreenBtnOffsetTop )
  									.css({top: fullScreenBtnOffsetTop + fullScreenBtnHeight});
  							};
  
  						t.globalBind('resize', function() {
  							positionHoverDivs();
  						});
  
  						for (i = 0, len = hoverDivNames.length; i < len; i++) {
  							hoverDivs[hoverDivNames[i]] = $('<div class="mejs-fullscreen-hover" />').appendTo(t.container).mouseover(restoreControls).hide();
  						}
  
  						// on hover, kill the fullscreen button's HTML handling, allowing clicks down to Flash
  						fullscreenBtn.on('mouseover',function() {
  
  							if (!t.isFullScreen) {
  
  								var buttonPos = fullscreenBtn.offset(),
  									containerPos = player.container.offset();
  
  								// move the button in Flash into place
  								media.positionFullscreenButton(buttonPos.left - containerPos.left, buttonPos.top - containerPos.top, false);
  
  								// allows click through
  								fullscreenBtn.css('pointer-events', 'none');
  								t.controls.css('pointer-events', 'none');
  
  								// restore click-to-play
  								t.media.addEventListener('click', t.clickToPlayPauseCallback);
  
  								// show the divs that will restore things
  								for (i in hoverDivs) {
  									hoverDivs[i].show();
  								}
  
  								positionHoverDivs();
  
  								fullscreenIsDisabled = true;
  							}
  
  						});
  
  						// restore controls anytime the user enters or leaves fullscreen
  						media.addEventListener('fullscreenchange', function(e) {
  							t.isFullScreen = !t.isFullScreen;
  							// don't allow plugin click to pause video - messes with
  							// plugin's controls
  							if (t.isFullScreen) {
  								t.media.removeEventListener('click', t.clickToPlayPauseCallback);
  							} else {
  								t.media.addEventListener('click', t.clickToPlayPauseCallback);
  							}
  							restoreControls();
  						});
  
  
  						// the mouseout event doesn't work on the fullscren button, because we already killed the pointer-events
  						// so we use the document.mousemove event to restore controls when the mouse moves outside the fullscreen button
  
  						t.globalBind('mousemove', function(e) {
  
  							// if the mouse is anywhere but the fullsceen button, then restore it all
  							if (fullscreenIsDisabled) {
  
  								var fullscreenBtnPos = fullscreenBtn.offset();
  
  
  								if (e.pageY < fullscreenBtnPos.top || e.pageY > fullscreenBtnPos.top + fullscreenBtn.outerHeight(true) ||
  									e.pageX < fullscreenBtnPos.left || e.pageX > fullscreenBtnPos.left + fullscreenBtn.outerWidth(true)
  									) {
  
  									fullscreenBtn.css('pointer-events', '');
  									t.controls.css('pointer-events', '');
  
  									fullscreenIsDisabled = false;
  								}
  							}
  						});
  
  
  
  					} else {
  
  						// the hover state will show the fullscreen button in Flash to hover up and click
  
  						fullscreenBtn
  							.on('mouseover', function() {
  
  								if (hideTimeout !== null) {
  									clearTimeout(hideTimeout);
  									delete hideTimeout;
  								}
  
  								var buttonPos = fullscreenBtn.offset(),
  									containerPos = player.container.offset();
  
  								media.positionFullscreenButton(buttonPos.left - containerPos.left, buttonPos.top - containerPos.top, true);
  
  							})
  							.on('mouseout', function() {
  
  								if (hideTimeout !== null) {
  									clearTimeout(hideTimeout);
  									delete hideTimeout;
  								}
  
  								hideTimeout = setTimeout(function() {
  									media.hideFullscreenButton();
  								}, 1500);
  
  
  							});
  					}
  				}
  
  			player.fullscreenBtn = fullscreenBtn;
  
  			t.globalBind('keydown',function (e) {
  				if (((mejs.MediaFeatures.hasTrueNativeFullScreen && mejs.MediaFeatures.isFullScreen()) || t.isFullScreen) && e.keyCode == 27) {
  					player.exitFullScreen();
  				}
  			});
  			
  			t.normalHeight = 0;
  			t.normalWidth = 0;
  
  		},
  
  		cleanfullscreen: function(player) {
  			player.exitFullScreen();
  		},
  
          containerSizeTimeout: null,
  
  		enterFullScreen: function() {
  
  			var t = this;
  
  			// firefox+flash can't adjust plugin sizes without resetting :(
  			if (t.media.pluginType !== 'native' && (mejs.MediaFeatures.isFirefox || t.options.usePluginFullScreen)) {
  				//t.media.setFullscreen(true);
  				//player.isFullScreen = true;
  				return;
  			}
  
  			// set it to not show scroll bars so 100% will work
              $(document.documentElement).addClass('mejs-fullscreen');
  
  			// store sizing
  			t.normalHeight = t.container.height();
  			t.normalWidth = t.container.width();
  
  			// attempt to do true fullscreen (Safari 5.1 and Firefox Nightly only for now)
  			if (t.media.pluginType === 'native') {
  				if (mejs.MediaFeatures.hasTrueNativeFullScreen) {
  
  					mejs.MediaFeatures.requestFullScreen(t.container[0]);
  					//return;
  
  					if (t.isInIframe) {
  						// sometimes exiting from fullscreen doesn't work
  						// notably in Chrome <iframe>. Fixed in version 17
  						setTimeout(function checkFullscreen() {
  
  							if (t.isNativeFullScreen) {
  								var zoomMultiplier = window["devicePixelRatio"] || 1,
  								// Use a percent error margin since devicePixelRatio is a float and not exact.
  									percentErrorMargin = 0.002, // 0.2%
  									windowWidth = zoomMultiplier * $(window).width(),
  									screenWidth = screen.width,
  									// ** 13twelve
  									// Screen width is sort of useless: http://www.quirksmode.org/blog/archives/2013/11/screenwidth_is.html
  									// My rMBP ignores devicePixelRatio when returning the values, so fullscreen would always fail the "suddenly not fullscreen" test
  									// Theory: the gap between reported values should give us an indication of browser behavior with screen.width and devicePixelRatio
  									zoomedWindowWidth = zoomMultiplier * windowWidth;
  									
  								if (Math.abs(screenWidth-windowWidth) > Math.abs(screenWidth-zoomedWindowWidth)) {
  									// screen.width is likely true pixels, not CSS pixels, so we need to use the zoomed window width for comparison
  									windowWidth = zoomedWindowWidth;
  								}
  								// ** / 13twelve
  
  								var absDiff = Math.abs(screenWidth - windowWidth),
  									marginError = screenWidth * percentErrorMargin;
  
  								// check if the video is suddenly not really fullscreen
  								if (absDiff > marginError) {
  									// manually exit
  									t.exitFullScreen();
  								} else {
  									// test again
  									setTimeout(checkFullscreen, 500);
  								}
  							}
  							
  						}, 1000);
  					}
  
  				} else if (mejs.MediaFeatures.hasSemiNativeFullScreen) {
  					t.media.webkitEnterFullscreen();
  					return;
  				}
  			}
  
  			// check for iframe launch
  			if (t.isInIframe) {
  				var url = t.options.newWindowCallback(this);
  
  
  				if (url !== '') {
  
  					// launch immediately
  					if (!mejs.MediaFeatures.hasTrueNativeFullScreen) {
  						t.pause();
  						window.open(url, t.id, 'top=0,left=0,width=' + screen.availWidth + ',height=' + screen.availHeight + ',resizable=yes,scrollbars=no,status=no,toolbar=no');
  						return;
  					} else {
  						setTimeout(function() {
  							if (!t.isNativeFullScreen) {
  								t.pause();
  								window.open(url, t.id, 'top=0,left=0,width=' + screen.availWidth + ',height=' + screen.availHeight + ',resizable=yes,scrollbars=no,status=no,toolbar=no');
  							}
  						}, 250);
  					}
  				}
  
  			}
  
  			// full window code
  
  
  
  			// make full size
  			t.container
  				.addClass('mejs-container-fullscreen')
  				.width('100%')
  				.height('100%');
  				//.css({position: 'fixed', left: 0, top: 0, right: 0, bottom: 0, overflow: 'hidden', width: '100%', height: '100%', 'z-index': 1000});
  
  			// Only needed for safari 5.1 native full screen, can cause display issues elsewhere
  			// Actually, it seems to be needed for IE8, too
  			//if (mejs.MediaFeatures.hasTrueNativeFullScreen) {
  				t.containerSizeTimeout = setTimeout(function() {
  					t.container.css({width: '100%', height: '100%'});
  					t.setControlsSize();
  				}, 500);
  			//}
  
  			if (t.media.pluginType === 'native') {
  				t.$media
  					.width('100%')
  					.height('100%');
  			} else {
  				t.container.find('.mejs-shim')
  					.width('100%')
  					.height('100%');
  
  				//if (!mejs.MediaFeatures.hasTrueNativeFullScreen) {
  					t.media.setVideoSize($(window).width(),$(window).height());
  				//}
  			}
  
  			t.layers.children('div')
  				.width('100%')
  				.height('100%');
  
  			if (t.fullscreenBtn) {
  				t.fullscreenBtn
  					.removeClass('mejs-fullscreen')
  					.addClass('mejs-unfullscreen');
  			}
  
  			t.setControlsSize();
  			t.isFullScreen = true;
  
  			t.container.find('.mejs-captions-text').css('font-size', screen.width / t.width * 1.00 * 100 + '%');
  			t.container.find('.mejs-captions-position').css('bottom', '45px');
  
  			t.container.trigger('enteredfullscreen');
  		},
  
  		exitFullScreen: function() {
  
  			var t = this;
  
              // Prevent container from attempting to stretch a second time
              clearTimeout(t.containerSizeTimeout);
  
  			// firefox can't adjust plugins
  			if (t.media.pluginType !== 'native' && mejs.MediaFeatures.isFirefox) {
  				t.media.setFullscreen(false);
  				//player.isFullScreen = false;
  				return;
  			}
  
  			// come outo of native fullscreen
  			if (mejs.MediaFeatures.hasTrueNativeFullScreen && (mejs.MediaFeatures.isFullScreen() || t.isFullScreen)) {
  				mejs.MediaFeatures.cancelFullScreen();
  			}
  
  			// restore scroll bars to document
              $(document.documentElement).removeClass('mejs-fullscreen');
  
  			t.container
  				.removeClass('mejs-container-fullscreen')
  				.width(t.normalWidth)
  				.height(t.normalHeight);
  
  			if (t.media.pluginType === 'native') {
  				t.$media
  					.width(t.normalWidth)
  					.height(t.normalHeight);
  			} else {
  				t.container.find('.mejs-shim')
  					.width(t.normalWidth)
  					.height(t.normalHeight);
  
  				t.media.setVideoSize(t.normalWidth, t.normalHeight);
  			}
  
  			t.layers.children('div')
  				.width(t.normalWidth)
  				.height(t.normalHeight);
  
  			t.fullscreenBtn
  				.removeClass('mejs-unfullscreen')
  				.addClass('mejs-fullscreen');
  
  			t.setControlsSize();
  			t.isFullScreen = false;
  
  			t.container.find('.mejs-captions-text').css('font-size','');
  			t.container.find('.mejs-captions-position').css('bottom', '');
  
  			t.container.trigger('exitedfullscreen');
  		}
  	});
  
  })(mejs.$);
  