RubyGems - j1-template - Versions diffs - 2020.0.0 - Mend

j1-template 2020.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (921) hide show

data/lib/starter_web/assets/themes/j1/extensions/iframe_resizer/examples/index.html ADDED Viewed

@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<title>iFrame message passing test</title>
+		<meta name="description" content="iFrame message passing test">
+		<meta name="viewport" content="width=device-width">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	</head>
+	<body>
+		<h2>Automagically resizing iFrame</h2>
+		<p>Resize window or click one of the links in the iFrame to watch it resize. Or try with <a name="anchorParentTest" href="two.html">two iFrames</a>.</p>
+		<div style="margin:20px;">
+			<iframe src="frame.content.html" width="100%" scrolling="no"></iframe>
+		</div>
+		<p id="callback">
+		</p>
+		<div style="margin: 8px 0;font-size:13px;">
+			For details on how this works, see
+			<a href="http://davidjbradshaw.github.io/iframe-resizer/">http://davidjbradshaw.github.io/iframe-resizer/</a>.
+		</div>
+		<!-- MDN PolyFils for IE8 (This is not normally needed if you use the jQuery version) -->
+		<!--[if lte IE 8]>
+			<script src="../js/ie8.polyfils.min.js"></script>
+		<![endif]-->
+		<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+		<script src="../js/client/iframeResizer.contentWindow.min.js" defer></script>
+		<script>
+			/*
+			 * If you do not understand what the code below does, then please just use the
+			 * following call in your own code.
+			 *
+			 *   iFrameResize({log:true});
+			 *
+			 * Once you have it working, set the log option to false.
+			 */
+			iFrameResize({
+				log                     : true,
+				inPageLinks             : true,
+				resizedCallback         : function(messageData){
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Height:</b> '     + messageData.height +
+						' <b>Width:</b> '      + messageData.width +
+						' <b>Event type:</b> ' + messageData.type
+					);
+				},
+				messageCallback         : function(messageData){
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Message:</b> '    + messageData.message
+					);
+					alert(messageData.message);
+					document.getElementsByTagName('iframe')[0].iFrameResizer.sendMessage('Hello back from parent page');
+				},
+				closedCallback         : function(id){
+					$('p#callback').html(
+						'<b>IFrame (</b>'    + id +
+						'<b>) removed from page.</b>'
+					);
+				}
+			});
+		</script>
+	</body>
+</html>

data/lib/starter_web/assets/themes/j1/extensions/iframe_resizer/examples/two.html ADDED Viewed

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta charset="utf-8">
+		<title>iFrame message passing test</title>
+		<meta name="description" content="iFrame message passing test">
+		<meta name="viewport" content="width=device-width">
+		<meta http-equiv="X-UA-Compatible" content="IE=edge">
+	</head>
+	<body>
+		<h2>Automagically resizing iFrame</h2>
+		<p>Resize window or click one of the links in the iFrame to watch it resize. Or go back to a <a name="anchorParentTest" href="index.html">single iFrame</a>.</p>
+		<div style="margin:20px;">
+			<iframe src="frame.content.html" width="48%" scrolling="no" style="float:left;margin-right:2%"></iframe>
+			<iframe src="frame.content.html" width="48%" scrolling="no"></iframe>
+		</div>
+		<p id="callback">
+		</p>
+		<div style="margin: 8px 0;font-size:13px;">
+			For details on how this works, see
+			<a href="http://davidjbradshaw.github.io/iframe-resizer/">http://davidjbradshaw.github.io/iframe-resizer/</a>.
+		</div>
+		<!-- MDN PolyFils for IE8 -->
+		<!--[if lte IE 8]>
+			<script src="../js/ie8.polyfils.min.js"></script>
+		<![endif]-->
+		<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js"></script>
+		<script src="../js/client/iframeResizer.contentWindow.min.js" defer></script>
+		<script>
+			/*
+			 * If you do not understand what the code below does, then please just use the
+			 * following call in your own code.
+			 *
+			 *   iFrameResize({log:true});
+			 *
+			 * Once you have it working, set the log option to false.
+			 */
+			iFrameResize({
+				log                     : true,
+				enablePublicMethods     : true,
+				enableInPageLinks       : true,
+				resizedCallback         : function(messageData){
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Height:</b> '     + messageData.height +
+						' <b>Width:</b> '      + messageData.width +
+						' <b>Event type:</b> ' + messageData.type
+					);
+				},
+				messageCallback         : function(messageData){
+					$('p#callback').html(
+						'<b>Frame ID:</b> '    + messageData.iframe.id +
+						' <b>Message:</b> '    + messageData.message
+					);
+					alert(messageData.message + ' (' + messageData.iframe.id + ')' );
+				},
+				closedCallback         : function(id){
+					$('p#callback').html(
+						'<b>IFrame (</b>'    + id +
+						'<b>) removed from page.</b>'
+					);
+				}
+			});
+		</script>
+	</body>
+</html>

data/lib/starter_web/assets/themes/j1/extensions/iframe_resizer/js/client/iframeResizer.contentWindow.js ADDED Viewed

@@ -0,0 +1,1104 @@
+/*
+ * File: iframeResizer.contentWindow.js
+ * Desc: Include this file in any page being loaded into an iframe
+ *       to force the iframe to resize to the content size.
+ * Requires: iframeResizer.js on host page.
+ * Doc: https://github.com/davidjbradshaw/iframe-resizer
+ * Author: David J. Bradshaw - dave@bradshaw.net
+ * Contributor: Jure Mav - jure.mav@gmail.com
+ * Contributor: Ian Caunce - ian@hallnet.co.uk
+ */
+;(function(window, undefined) {
+	'use strict';
+	var
+		autoResize            = true,
+		base                  = 10,
+		bodyBackground        = '',
+		bodyMargin            = 0,
+		bodyMarginStr         = '',
+		bodyObserver          = null,
+		bodyPadding           = '',
+		calculateWidth        = false,
+		doubleEventList       = {'resize':1,'click':1},
+		eventCancelTimer      = 128,
+		firstRun              = true,
+		height                = 1,
+		heightCalcModeDefault = 'bodyOffset',
+		heightCalcMode        = heightCalcModeDefault,
+		initLock              = true,
+		initMsg               = '',
+		inPageLinks           = {},
+		interval              = 32,
+		intervalTimer         = null,
+		logging               = false,
+		msgID                 = '[iFrameSizer]',  //Must match host page msg ID
+		msgIdLen              = msgID.length,
+		myID                  = '',
+		observer              = null,
+		resetRequiredMethods  = {max:1,min:1,bodyScroll:1,documentElementScroll:1},
+		resizeFrom            = 'child',
+		sendPermit            = true,
+		target                = window.parent,
+		targetOriginDefault   = '*',
+		tolerance             = 0,
+		triggerLocked         = false,
+		triggerLockedTimer    = null,
+		throttledTimer        = 16,
+		width                 = 1,
+		widthCalcModeDefault  = 'scroll',
+		widthCalcMode         = widthCalcModeDefault,
+		win                   = window,
+		messageCallback       = function(){ warn('MessageCallback function not defined'); },
+		readyCallback         = function(){},
+		pageInfoCallback      = function(){},
+		customCalcMethods     = {
+			height: function(){
+				warn('Custom height calculation function not defined');
+				return document.documentElement.offsetHeight;
+			},
+			width: function(){
+				warn('Custom width calculation function not defined');
+				return document.body.scrollWidth;
+			}
+		},
+		eventHandlersByName   = {};
+	function addEventListener(el,evt,func){
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if ('addEventListener' in window){
+			el.addEventListener(evt,func, false);
+		} else if ('attachEvent' in window){ //IE
+			el.attachEvent('on'+evt,func);
+		}
+	}
+	function removeEventListener(el,evt,func){
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if ('removeEventListener' in window){
+			el.removeEventListener(evt,func, false);
+		} else if ('detachEvent' in window){ //IE
+			el.detachEvent('on'+evt,func);
+		}
+	}
+	function capitalizeFirstLetter(string) {
+		return string.charAt(0).toUpperCase() + string.slice(1);
+	}
+	//Based on underscore.js
+	function throttle(func) {
+		var
+			context, args, result,
+			timeout = null,
+			previous = 0,
+			later = function() {
+				previous = getNow();
+				timeout = null;
+				result = func.apply(context, args);
+				if (!timeout) {
+					context = args = null;
+				}
+			};
+		return function() {
+			var now = getNow();
+			if (!previous) {
+				previous = now;
+			}
+			var remaining = throttledTimer - (now - previous);
+			context = this;
+			args = arguments;
+			if (remaining <= 0 || remaining > throttledTimer) {
+				if (timeout) {
+					clearTimeout(timeout);
+					timeout = null;
+				}
+				previous = now;
+				result = func.apply(context, args);
+				if (!timeout) {
+					context = args = null;
+				}
+			} else if (!timeout) {
+				timeout = setTimeout(later, remaining);
+			}
+			return result;
+		};
+	}
+	var getNow = Date.now || function() {
+		/* istanbul ignore next */ // Not testable in PhantonJS
+		return new Date().getTime();
+	};
+	function formatLogMsg(msg){
+		return msgID + '[' + myID + ']' + ' ' + msg;
+	}
+	function log(msg){
+		if (logging && ('object' === typeof window.console)){
+			console.log(formatLogMsg(msg));
+		}
+	}
+	function warn(msg){
+		if ('object' === typeof window.console){
+			console.warn(formatLogMsg(msg));
+		}
+	}
+	function init(){
+		readDataFromParent();
+		log('Initialising iFrame ('+location.href+')');
+		readDataFromPage();
+		setMargin();
+		setBodyStyle('background',bodyBackground);
+		setBodyStyle('padding',bodyPadding);
+		injectClearFixIntoBodyElement();
+		checkHeightMode();
+		checkWidthMode();
+		stopInfiniteResizingOfIFrame();
+		setupPublicMethods();
+		startEventListeners();
+		inPageLinks = setupInPageLinks();
+		sendSize('init','Init message from host page');
+		readyCallback();
+	}
+	function readDataFromParent(){
+		function strBool(str){
+			return 'true' === str ? true : false;
+		}
+		var data = initMsg.substr(msgIdLen).split(':');
+		myID               = data[0];
+		bodyMargin         = (undefined !== data[1]) ? Number(data[1])   : bodyMargin; //For V1 compatibility
+		calculateWidth     = (undefined !== data[2]) ? strBool(data[2])  : calculateWidth;
+		logging            = (undefined !== data[3]) ? strBool(data[3])  : logging;
+		interval           = (undefined !== data[4]) ? Number(data[4])   : interval;
+		autoResize         = (undefined !== data[6]) ? strBool(data[6])  : autoResize;
+		bodyMarginStr      = data[7];
+		heightCalcMode     = (undefined !== data[8]) ? data[8]           : heightCalcMode;
+		bodyBackground     = data[9];
+		bodyPadding        = data[10];
+		tolerance          = (undefined !== data[11]) ? Number(data[11]) : tolerance;
+		inPageLinks.enable = (undefined !== data[12]) ? strBool(data[12]): false;
+		resizeFrom         = (undefined !== data[13]) ? data[13]         : resizeFrom;
+		widthCalcMode      = (undefined !== data[14]) ? data[14]         : widthCalcMode;
+	}
+	function readDataFromPage(){
+		function readData(){
+			var data = window.iFrameResizer;
+			log('Reading data from page: ' + JSON.stringify(data));
+			messageCallback     = ('messageCallback'         in data) ? data.messageCallback         : messageCallback;
+			readyCallback       = ('readyCallback'           in data) ? data.readyCallback           : readyCallback;
+			targetOriginDefault = ('targetOrigin'            in data) ? data.targetOrigin            : targetOriginDefault;
+			heightCalcMode      = ('heightCalculationMethod' in data) ? data.heightCalculationMethod : heightCalcMode;
+			widthCalcMode       = ('widthCalculationMethod'  in data) ? data.widthCalculationMethod  : widthCalcMode;
+		}
+		function setupCustomCalcMethods(calcMode, calcFunc){
+			if ('function' === typeof calcMode) {
+				log('Setup custom ' + calcFunc + 'CalcMethod');
+				customCalcMethods[calcFunc] = calcMode;
+				calcMode = 'custom';
+			}
+			return calcMode;
+		}
+		if(('iFrameResizer' in window) && (Object === window.iFrameResizer.constructor)) {
+			readData();
+			heightCalcMode = setupCustomCalcMethods(heightCalcMode, 'height');
+			widthCalcMode  = setupCustomCalcMethods(widthCalcMode,  'width');
+		}
+		log('TargetOrigin for parent set to: ' + targetOriginDefault);
+	}
+	function chkCSS(attr,value){
+		if (-1 !== value.indexOf('-')){
+			warn('Negative CSS value ignored for '+attr);
+			value='';
+		}
+		return value;
+	}
+	function setBodyStyle(attr,value){
+		if ((undefined !== value) && ('' !== value) && ('null' !== value)){
+			document.body.style[attr] = value;
+			log('Body '+attr+' set to "'+value+'"');
+		}
+	}
+	function setMargin(){
+		//If called via V1 script, convert bodyMargin from int to str
+		if (undefined === bodyMarginStr){
+			bodyMarginStr = bodyMargin+'px';
+		}
+		setBodyStyle('margin',chkCSS('margin',bodyMarginStr));
+	}
+	function stopInfiniteResizingOfIFrame(){
+		document.documentElement.style.height = '';
+		document.body.style.height = '';
+		log('HTML & body height set to "auto"');
+	}
+	function manageTriggerEvent(options){
+		var listener = {
+			add:    function(eventName){
+				function handleEvent(){
+					sendSize(options.eventName,options.eventType);
+				}
+				eventHandlersByName[eventName] = handleEvent;
+				addEventListener(window,eventName,handleEvent);
+			},
+			remove: function(eventName){
+				var handleEvent = eventHandlersByName[eventName];
+				delete eventHandlersByName[eventName];
+				removeEventListener(window,eventName,handleEvent);
+			}
+		};
+		if(options.eventNames && Array.prototype.map){
+			options.eventName = options.eventNames[0];
+			options.eventNames.map(listener[options.method]);
+		} else {
+			listener[options.method](options.eventName);
+		}
+		log(capitalizeFirstLetter(options.method) + ' event listener: ' + options.eventType);
+	}
+	function manageEventListeners(method){
+		manageTriggerEvent({method:method, eventType: 'Animation Start',           eventNames: ['animationstart','webkitAnimationStart'] });
+		manageTriggerEvent({method:method, eventType: 'Animation Iteration',       eventNames: ['animationiteration','webkitAnimationIteration'] });
+		manageTriggerEvent({method:method, eventType: 'Animation End',             eventNames: ['animationend','webkitAnimationEnd'] });
+		manageTriggerEvent({method:method, eventType: 'Input',                     eventName:  'input' });
+		manageTriggerEvent({method:method, eventType: 'Mouse Up',                  eventName:  'mouseup' });
+		manageTriggerEvent({method:method, eventType: 'Mouse Down',                eventName:  'mousedown' });
+		manageTriggerEvent({method:method, eventType: 'Orientation Change',        eventName:  'orientationchange' });
+		manageTriggerEvent({method:method, eventType: 'Print',                     eventName:  ['afterprint', 'beforeprint'] });
+		manageTriggerEvent({method:method, eventType: 'Ready State Change',        eventName:  'readystatechange' });
+		manageTriggerEvent({method:method, eventType: 'Touch Start',               eventName:  'touchstart' });
+		manageTriggerEvent({method:method, eventType: 'Touch End',                 eventName:  'touchend' });
+		manageTriggerEvent({method:method, eventType: 'Touch Cancel',              eventName:  'touchcancel' });
+		manageTriggerEvent({method:method, eventType: 'Transition Start',          eventNames: ['transitionstart','webkitTransitionStart','MSTransitionStart','oTransitionStart','otransitionstart'] });
+		manageTriggerEvent({method:method, eventType: 'Transition Iteration',      eventNames: ['transitioniteration','webkitTransitionIteration','MSTransitionIteration','oTransitionIteration','otransitioniteration'] });
+		manageTriggerEvent({method:method, eventType: 'Transition End',            eventNames: ['transitionend','webkitTransitionEnd','MSTransitionEnd','oTransitionEnd','otransitionend'] });
+		if('child' === resizeFrom){
+			manageTriggerEvent({method:method, eventType: 'IFrame Resized',        eventName:  'resize' });
+		}
+	}
+	function checkCalcMode(calcMode,calcModeDefault,modes,type){
+		if (calcModeDefault !== calcMode){
+			if (!(calcMode in modes)){
+				warn(calcMode + ' is not a valid option for '+type+'CalculationMethod.');
+				calcMode=calcModeDefault;
+			}
+			log(type+' calculation method set to "'+calcMode+'"');
+		}
+		return calcMode;
+	}
+	function checkHeightMode(){
+		heightCalcMode = checkCalcMode(heightCalcMode,heightCalcModeDefault,getHeight,'height');
+	}
+	function checkWidthMode(){
+		widthCalcMode = checkCalcMode(widthCalcMode,widthCalcModeDefault,getWidth,'width');
+	}
+	function startEventListeners(){
+		if ( true === autoResize ) {
+			manageEventListeners('add');
+			setupMutationObserver();
+		}
+		else {
+			log('Auto Resize disabled');
+		}
+	}
+	function stopMsgsToParent(){
+		log('Disable outgoing messages');
+		sendPermit = false;
+	}
+	function removeMsgListener(){
+		log('Remove event listener: Message');
+		removeEventListener(window, 'message', receiver);
+	}
+	function disconnectMutationObserver(){
+		if (null !== bodyObserver){
+			/* istanbul ignore next */ // Not testable in PhantonJS
+			bodyObserver.disconnect();
+		}
+	}
+	function stopEventListeners(){
+		manageEventListeners('remove');
+		disconnectMutationObserver();
+		clearInterval(intervalTimer);
+	}
+	function teardown(){
+		stopMsgsToParent();
+		removeMsgListener();
+		if (true === autoResize) stopEventListeners();
+	}
+	function injectClearFixIntoBodyElement(){
+		var clearFix = document.createElement('div');
+		clearFix.style.clear   = 'both';
+		clearFix.style.display = 'block'; //Guard against this having been globally redefined in CSS.
+		document.body.appendChild(clearFix);
+	}
+	function setupInPageLinks(){
+		function getPagePosition (){
+			return {
+				x: (window.pageXOffset !== undefined) ? window.pageXOffset : document.documentElement.scrollLeft,
+				y: (window.pageYOffset !== undefined) ? window.pageYOffset : document.documentElement.scrollTop
+			};
+		}
+		function getElementPosition(el){
+			var
+				elPosition   = el.getBoundingClientRect(),
+				pagePosition = getPagePosition();
+			return {
+				x: parseInt(elPosition.left,10) + parseInt(pagePosition.x,10),
+				y: parseInt(elPosition.top,10)  + parseInt(pagePosition.y,10)
+			};
+		}
+		function findTarget(location){
+			function jumpToTarget(target){
+				var jumpPosition = getElementPosition(target);
+				log('Moving to in page link (#'+hash+') at x: '+jumpPosition.x+' y: '+jumpPosition.y);
+				sendMsg(jumpPosition.y, jumpPosition.x, 'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+			}
+			var
+				hash     = location.split('#')[1] || location, //Remove # if present
+				hashData = decodeURIComponent(hash),
+				target   = document.getElementById(hashData) || document.getElementsByName(hashData)[0];
+			if (undefined !== target){
+				jumpToTarget(target);
+			} else {
+				log('In page link (#' + hash + ') not found in iFrame, so sending to parent');
+				sendMsg(0,0,'inPageLink','#'+hash);
+			}
+		}
+		function checkLocationHash(){
+			if ('' !== location.hash && '#' !== location.hash){
+				findTarget(location.href);
+			}
+		}
+		function bindAnchors(){
+			function setupLink(el){
+				function linkClicked(e){
+					e.preventDefault();
+					/*jshint validthis:true */
+					findTarget(this.getAttribute('href'));
+				}
+				if ('#' !== el.getAttribute('href')){
+					addEventListener(el,'click',linkClicked);
+				}
+			}
+			Array.prototype.forEach.call( document.querySelectorAll( 'a[href^="#"]' ), setupLink );
+		}
+		function bindLocationHash(){
+			addEventListener(window,'hashchange',checkLocationHash);
+		}
+		function initCheck(){ //check if page loaded with location hash after init resize
+			setTimeout(checkLocationHash,eventCancelTimer);
+		}
+		function enableInPageLinks(){
+			/* istanbul ignore else */ // Not testable in phantonJS
+			if(Array.prototype.forEach && document.querySelectorAll){
+				log('Setting up location.hash handlers');
+				bindAnchors();
+				bindLocationHash();
+				initCheck();
+			} else {
+				warn('In page linking not fully supported in this browser! (See README.md for IE8 workaround)');
+			}
+		}
+		if(inPageLinks.enable){
+			enableInPageLinks();
+		} else {
+			log('In page linking not enabled');
+		}
+		return {
+			findTarget:findTarget
+		};
+	}
+	function setupPublicMethods(){
+		log('Enable public methods');
+		win.parentIFrame = {
+			autoResize: function autoResizeF(resize){
+				if (true === resize && false === autoResize) {
+					autoResize=true;
+					startEventListeners();
+					//sendSize('autoResize','Auto Resize enabled');
+				} else if (false === resize && true === autoResize) {
+					autoResize=false;
+					stopEventListeners();
+				}
+				return autoResize;
+			},
+			close: function closeF(){
+				sendMsg(0,0,'close');
+				teardown();
+			},
+			getId: function getIdF(){
+				return myID;
+			},
+			getPageInfo: function getPageInfoF(callback){
+				if ('function' === typeof callback){
+					pageInfoCallback = callback;
+					sendMsg(0,0,'pageInfo');
+				} else {
+					pageInfoCallback = function(){};
+					sendMsg(0,0,'pageInfoStop');
+				}
+			},
+			moveToAnchor: function moveToAnchorF(hash){
+				inPageLinks.findTarget(hash);
+			},
+			reset: function resetF(){
+				resetIFrame('parentIFrame.reset');
+			},
+			scrollTo: function scrollToF(x,y){
+				sendMsg(y,x,'scrollTo'); // X&Y reversed at sendMsg uses height/width
+			},
+			scrollToOffset: function scrollToF(x,y){
+				sendMsg(y,x,'scrollToOffset'); // X&Y reversed at sendMsg uses height/width
+			},
+			sendMessage: function sendMessageF(msg,targetOrigin){
+				sendMsg(0,0,'message',JSON.stringify(msg),targetOrigin);
+			},
+			setHeightCalculationMethod: function setHeightCalculationMethodF(heightCalculationMethod){
+				heightCalcMode = heightCalculationMethod;
+				checkHeightMode();
+			},
+			setWidthCalculationMethod: function setWidthCalculationMethodF(widthCalculationMethod){
+				widthCalcMode = widthCalculationMethod;
+				checkWidthMode();
+			},
+			setTargetOrigin: function setTargetOriginF(targetOrigin){
+				log('Set targetOrigin: '+targetOrigin);
+				targetOriginDefault = targetOrigin;
+			},
+			size: function sizeF(customHeight, customWidth){
+				var valString = ''+(customHeight?customHeight:'')+(customWidth?','+customWidth:'');
+				//lockTrigger();
+				sendSize('size','parentIFrame.size('+valString+')', customHeight, customWidth);
+			}
+		};
+	}
+	function initInterval(){
+		if ( 0 !== interval ){
+			log('setInterval: '+interval+'ms');
+			intervalTimer = setInterval(function(){
+				sendSize('interval','setInterval: '+interval);
+			},Math.abs(interval));
+		}
+	}
+	/* istanbul ignore next */  //Not testable in PhantomJS
+	function setupBodyMutationObserver(){
+		function addImageLoadListners(mutation) {
+			function addImageLoadListener(element){
+				if (false === element.complete) {
+					log('Attach listeners to ' + element.src);
+					element.addEventListener('load', imageLoaded, false);
+					element.addEventListener('error', imageError, false);
+					elements.push(element);
+				}
+			}
+			if (mutation.type === 'attributes' && mutation.attributeName === 'src'){
+				addImageLoadListener(mutation.target);
+			} else if (mutation.type === 'childList'){
+				Array.prototype.forEach.call(
+					mutation.target.querySelectorAll('img'),
+					addImageLoadListener
+				);
+			}
+		}
+		function removeFromArray(element){
+			elements.splice(elements.indexOf(element),1);
+		}
+		function removeImageLoadListener(element){
+			log('Remove listeners from ' + element.src);
+			element.removeEventListener('load', imageLoaded, false);
+			element.removeEventListener('error', imageError, false);
+			removeFromArray(element);
+		}
+		function imageEventTriggered(event,type,typeDesc){
+			removeImageLoadListener(event.target);
+			sendSize(type, typeDesc + ': ' + event.target.src, undefined, undefined);
+		}
+		function imageLoaded(event) {
+			imageEventTriggered(event,'imageLoad','Image loaded');
+		}
+		function imageError(event) {
+			imageEventTriggered(event,'imageLoadFailed','Image load failed');
+		}
+		function mutationObserved(mutations) {
+			sendSize('mutationObserver','mutationObserver: ' + mutations[0].target + ' ' + mutations[0].type);
+			//Deal with WebKit asyncing image loading when tags are injected into the page
+			mutations.forEach(addImageLoadListners);
+		}
+		function createMutationObserver(){
+			var
+				target = document.querySelector('body'),
+				config = {
+					attributes            : true,
+					attributeOldValue     : false,
+					characterData         : true,
+					characterDataOldValue : false,
+					childList             : true,
+					subtree               : true
+				};
+			observer = new MutationObserver(mutationObserved);
+			log('Create body MutationObserver');
+			observer.observe(target, config);
+			return observer;
+		}
+		var
+			elements         = [],
+			MutationObserver = window.MutationObserver || window.WebKitMutationObserver,
+			observer         = createMutationObserver();
+		return {
+			disconnect: function (){
+				if ('disconnect' in observer){
+					log('Disconnect body MutationObserver');
+					observer.disconnect();
+					elements.forEach(removeImageLoadListener);
+				}
+			}
+		};
+	}
+	function setupMutationObserver(){
+		var	forceIntervalTimer = 0 > interval;
+		/* istanbul ignore if */ // Not testable in PhantomJS
+		if (window.MutationObserver || window.WebKitMutationObserver){
+			if (forceIntervalTimer) {
+				initInterval();
+			} else {
+				bodyObserver = setupBodyMutationObserver();
+			}
+		} else {
+			log('MutationObserver not supported in this browser!');
+			initInterval();
+		}
+	}
+	// document.documentElement.offsetHeight is not reliable, so
+	// we have to jump through hoops to get a better value.
+	function getComputedStyle(prop,el) {
+		/* istanbul ignore next */  //Not testable in PhantomJS
+		function convertUnitsToPxForIE8(value) {
+			var PIXEL = /^\d+(px)?$/i;
+			if (PIXEL.test(value)) {
+				return parseInt(value,base);
+			}
+			var
+				style = el.style.left,
+				runtimeStyle = el.runtimeStyle.left;
+			el.runtimeStyle.left = el.currentStyle.left;
+			el.style.left = value || 0;
+			value = el.style.pixelLeft;
+			el.style.left = style;
+			el.runtimeStyle.left = runtimeStyle;
+			return value;
+		}
+		var retVal = 0;
+		el =  el || document.body;
+		/* istanbul ignore else */ // Not testable in phantonJS
+		if (('defaultView' in document) && ('getComputedStyle' in document.defaultView)) {
+			retVal = document.defaultView.getComputedStyle(el, null);
+			retVal = (null !== retVal) ? retVal[prop] : 0;
+		} else {//IE8
+			retVal =  convertUnitsToPxForIE8(el.currentStyle[prop]);
+		}
+		return parseInt(retVal,base);
+	}
+	function chkEventThottle(timer){
+		if(timer > throttledTimer/2){
+			throttledTimer = 2*timer;
+			log('Event throttle increased to ' + throttledTimer + 'ms');
+		}
+	}
+	//Idea from https://github.com/guardian/iframe-messenger
+	function getMaxElement(side,elements) {
+		var
+			elementsLength = elements.length,
+			elVal          = 0,
+			maxVal         = 0,
+			Side           = capitalizeFirstLetter(side),
+			timer          = getNow();
+		for (var i = 0; i < elementsLength; i++) {
+			elVal = elements[i].getBoundingClientRect()[side] + getComputedStyle('margin'+Side,elements[i]);
+			if (elVal > maxVal) {
+				maxVal = elVal;
+			}
+		}
+		timer = getNow() - timer;
+		log('Parsed '+elementsLength+' HTML elements');
+		log('Element position calculated in ' + timer + 'ms');
+		chkEventThottle(timer);
+		return maxVal;
+	}
+	function getAllMeasurements(dimention){
+		return [
+			dimention.bodyOffset(),
+			dimention.bodyScroll(),
+			dimention.documentElementOffset(),
+			dimention.documentElementScroll()
+		];
+	}
+	function getTaggedElements(side,tag){
+		function noTaggedElementsFound(){
+			warn('No tagged elements ('+tag+') found on page');
+			return document.querySelectorAll('body *');
+		}
+		var elements = document.querySelectorAll('['+tag+']');
+		if (0 === elements.length) noTaggedElementsFound();
+		return getMaxElement(side,elements);
+	}
+	function getAllElements(){
+		return document.querySelectorAll('body *');
+	}
+	var
+		getHeight = {
+			bodyOffset: function getBodyOffsetHeight(){
+				return  document.body.offsetHeight + getComputedStyle('marginTop') + getComputedStyle('marginBottom');
+			},
+			offset: function(){
+				return getHeight.bodyOffset(); //Backwards compatability
+			},
+			bodyScroll: function getBodyScrollHeight(){
+				return document.body.scrollHeight;
+			},
+			custom: function getCustomWidth(){
+				return customCalcMethods.height();
+			},
+			documentElementOffset: function getDEOffsetHeight(){
+				return document.documentElement.offsetHeight;
+			},
+			documentElementScroll: function getDEScrollHeight(){
+				return document.documentElement.scrollHeight;
+			},
+			max: function getMaxHeight(){
+				return Math.max.apply(null,getAllMeasurements(getHeight));
+			},
+			min: function getMinHeight(){
+				return Math.min.apply(null,getAllMeasurements(getHeight));
+			},
+			grow: function growHeight(){
+				return getHeight.max(); //Run max without the forced downsizing
+			},
+			lowestElement: function getBestHeight(){
+				return Math.max(getHeight.bodyOffset(), getMaxElement('bottom',getAllElements()));
+			},
+			taggedElement: function getTaggedElementsHeight(){
+				return getTaggedElements('bottom','data-iframe-height');
+			}
+		},
+		getWidth = {
+			bodyScroll: function getBodyScrollWidth(){
+				return document.body.scrollWidth;
+			},
+			bodyOffset: function getBodyOffsetWidth(){
+				return document.body.offsetWidth;
+			},
+			custom: function getCustomWidth(){
+				return customCalcMethods.width();
+			},
+			documentElementScroll: function getDEScrollWidth(){
+				return document.documentElement.scrollWidth;
+			},
+			documentElementOffset: function getDEOffsetWidth(){
+				return document.documentElement.offsetWidth;
+			},
+			scroll: function getMaxWidth(){
+				return Math.max(getWidth.bodyScroll(), getWidth.documentElementScroll());
+			},
+			max: function getMaxWidth(){
+				return Math.max.apply(null,getAllMeasurements(getWidth));
+			},
+			min: function getMinWidth(){
+				return Math.min.apply(null,getAllMeasurements(getWidth));
+			},
+			rightMostElement: function rightMostElement(){
+				return getMaxElement('right', getAllElements());
+			},
+			taggedElement: function getTaggedElementsWidth(){
+				return getTaggedElements('right', 'data-iframe-width');
+			}
+		};
+	function sizeIFrame(triggerEvent, triggerEventDesc, customHeight, customWidth){
+		function resizeIFrame(){
+			height = currentHeight;
+			width  = currentWidth;
+			sendMsg(height,width,triggerEvent);
+		}
+		function isSizeChangeDetected(){
+			function checkTolarance(a,b){
+				var retVal = Math.abs(a-b) <= tolerance;
+				return !retVal;
+			}
+			currentHeight = (undefined !== customHeight)  ? customHeight : getHeight[heightCalcMode]();
+			currentWidth  = (undefined !== customWidth )  ? customWidth  : getWidth[widthCalcMode]();
+			return	checkTolarance(height,currentHeight) || (calculateWidth && checkTolarance(width,currentWidth));
+		}
+		function isForceResizableEvent(){
+			return !(triggerEvent in {'init':1,'interval':1,'size':1});
+		}
+		function isForceResizableCalcMode(){
+			return (heightCalcMode in resetRequiredMethods) || (calculateWidth && widthCalcMode in resetRequiredMethods);
+		}
+		function logIgnored(){
+			log('No change in size detected');
+		}
+		function checkDownSizing(){
+			if (isForceResizableEvent() && isForceResizableCalcMode()){
+				resetIFrame(triggerEventDesc);
+			} else if (!(triggerEvent in {'interval':1})){
+				logIgnored();
+			}
+		}
+		var	currentHeight,currentWidth;
+		if (isSizeChangeDetected() || 'init' === triggerEvent){
+			lockTrigger();
+			resizeIFrame();
+		} else {
+			checkDownSizing();
+		}
+	}
+	var sizeIFrameThrottled = throttle(sizeIFrame);
+	function sendSize(triggerEvent, triggerEventDesc, customHeight, customWidth){
+		function recordTrigger(){
+			if (!(triggerEvent in {'reset':1,'resetPage':1,'init':1})){
+				log( 'Trigger event: ' + triggerEventDesc );
+			}
+		}
+		function isDoubleFiredEvent(){
+			return  triggerLocked && (triggerEvent in doubleEventList);
+		}
+		if (!isDoubleFiredEvent()){
+			recordTrigger();
+			sizeIFrameThrottled(triggerEvent, triggerEventDesc, customHeight, customWidth);
+		} else {
+			log('Trigger event cancelled: '+triggerEvent);
+		}
+	}
+	function lockTrigger(){
+		if (!triggerLocked){
+			triggerLocked = true;
+			log('Trigger event lock on');
+		}
+		clearTimeout(triggerLockedTimer);
+		triggerLockedTimer = setTimeout(function(){
+			triggerLocked = false;
+			log('Trigger event lock off');
+			log('--');
+		},eventCancelTimer);
+	}
+	function triggerReset(triggerEvent){
+		height = getHeight[heightCalcMode]();
+		width  = getWidth[widthCalcMode]();
+		sendMsg(height,width,triggerEvent);
+	}
+	function resetIFrame(triggerEventDesc){
+		var hcm = heightCalcMode;
+		heightCalcMode = heightCalcModeDefault;
+		log('Reset trigger event: ' + triggerEventDesc);
+		lockTrigger();
+		triggerReset('reset');
+		heightCalcMode = hcm;
+	}
+	function sendMsg(height,width,triggerEvent,msg,targetOrigin){
+		function setTargetOrigin(){
+			if (undefined === targetOrigin){
+				targetOrigin = targetOriginDefault;
+			} else {
+				log('Message targetOrigin: '+targetOrigin);
+			}
+		}
+		function sendToParent(){
+			var
+				size  = height + ':' + width,
+				message = myID + ':' +  size + ':' + triggerEvent + (undefined !== msg ? ':' + msg : '');
+			log('Sending message to host page (' + message + ')');
+			target.postMessage( msgID + message, targetOrigin);
+		}
+		if(true === sendPermit){
+			setTargetOrigin();
+			sendToParent();
+		}
+	}
+	function receiver(event) {
+		var processRequestFromParent = {
+			init: function initFromParent(){
+				function fireInit(){
+					initMsg = event.data;
+					target  = event.source;
+					init();
+					firstRun = false;
+					setTimeout(function(){ initLock = false;},eventCancelTimer);
+				}
+				if (document.body){
+					fireInit();
+				} else {
+					log('Waiting for page ready');
+					addEventListener(window,'readystatechange',processRequestFromParent.initFromParent);
+				}
+			},
+			reset: function resetFromParent(){
+				if (!initLock){
+					log('Page size reset by host page');
+					triggerReset('resetPage');
+				} else {
+					log('Page reset ignored by init');
+				}
+			},
+			resize: function resizeFromParent(){
+				sendSize('resizeParent','Parent window requested size check');
+			},
+			moveToAnchor: function moveToAnchorF(){
+				inPageLinks.findTarget(getData());
+			},
+			inPageLink: function inPageLinkF() {this.moveToAnchor();}, //Backward compatability
+			pageInfo: function pageInfoFromParent(){
+				var msgBody = getData();
+				log('PageInfoFromParent called from parent: ' + msgBody );
+				pageInfoCallback(JSON.parse(msgBody));
+				log(' --');
+			},
+			message: function messageFromParent(){
+				var msgBody = getData();
+				log('MessageCallback called from parent: ' + msgBody );
+				messageCallback(JSON.parse(msgBody));
+				log(' --');
+			}
+		};
+		function isMessageForUs(){
+			return msgID === (''+event.data).substr(0,msgIdLen); //''+ Protects against non-string messages
+		}
+		function getMessageType(){
+			return event.data.split(']')[1].split(':')[0];
+		}
+		function getData(){
+			return event.data.substr(event.data.indexOf(':')+1);
+		}
+		function isMiddleTier(){
+			return ('iFrameResize' in window);
+		}
+		function isInitMsg(){
+			//Test if this message is from a child below us. This is an ugly test, however, updating
+			//the message format would break backwards compatibity.
+			return event.data.split(':')[2] in {'true':1,'false':1};
+		}
+		function callFromParent(){
+			var messageType = getMessageType();
+			if (messageType in processRequestFromParent){
+				processRequestFromParent[messageType]();
+			} else if (!isMiddleTier() && !isInitMsg()){
+				warn('Unexpected message ('+event.data+')');
+			}
+		}
+		function processMessage(){
+			if (false === firstRun) {
+				callFromParent();
+			} else if (isInitMsg()) {
+				processRequestFromParent.init();
+			} else {
+				log('Ignored message of type "' + getMessageType() + '". Received before initialization.');
+			}
+		}
+		if (isMessageForUs()){
+			processMessage();
+		}
+	}
+	//Normally the parent kicks things off when it detects the iFrame has loaded.
+	//If this script is async-loaded, then tell parent page to retry init.
+	function chkLateLoaded(){
+		if('loading' !== document.readyState){
+			window.parent.postMessage('[iFrameResizerChild]Ready','*');
+		}
+	}
+	addEventListener(window, 'message', receiver);
+	chkLateLoaded();
+})(window || {});